+
+
+
+---
+---
+
+## Table of Contents
+
+* [Why do we need this ContinuousStepper_Generic library](#why-do-we-need-this-ContinuousStepper_Generic-library)
+ * [Features](#features)
+ * [Why using hardware-based PWM is better](#why-using-hardware-based-pwm-is-better)
+ * [Currently supported Boards](#currently-supported-boards)
+* [Changelog](changelog.md)
+* [Prerequisites](#prerequisites)
+* [Installation](#installation)
+ * [Use Arduino Library Manager](#use-arduino-library-manager)
+ * [Manual Install](#manual-install)
+ * [VS Code & PlatformIO](#vs-code--platformio)
+* [More useful Information about RP2040 PWM](#more-useful-information-about-RP2040-PWM)
+ * [PWM overview](#PWM-overview)
+ * [Programmer’s Model](#Programmers-Model)
+* [Usage](#usage)
+ * [1. Create PWM Instance with Pin, Frequency and dutycycle](#1-Create-PWM-Instance-with-Pin-Frequency-and-dutycycle)
+ * [2. Initialize PWM Instance](#2-Initialize-PWM-Instance)
+ * [3. Set or change PWM frequency or dutyCycle](#3-set-or-change-PWM-frequency-or-dutyCycle)
+ * [4. Set or change PWM frequency and dutyCycle manually and efficiently in waveform creation](#4-Set-or-change-PWM-frequency-and-dutyCycle-manually-and-efficiently-in-waveform-creation)
+ * [5. Important Notes](#5-Important-Notes)
+* [Examples](#examples)
+ * [ 1. ATtiny_PWM_StepperControl](examples/ATtiny_PWM_StepperControl)
+ * [ 2. AVR_PWM_StepperControl](examples/AVR_PWM_StepperControl)
+ * [ 3. Dx_PWM_StepperControl](examples/Dx_PWM_StepperControl)
+ * [ 4. ESP32_PWM_StepperControl](examples/ESP32_PWM_StepperControl)
+ * [ 5. MBED_RP2040_PWM_StepperControl](examples/MBED_RP2040_PWM_StepperControl)
+ * [ 6. megaAVR_PWM_StepperControl](examples/megaAVR_PWM_StepperControl)
+ * [ 7. nRF52_MBED_PWM_StepperControl](examples/nRF52_MBED_PWM_StepperControl)
+ * [ 8. nRF52_PWM_StepperControl](examples/nRF52_PWM_StepperControl)
+ * [ 9. Portenta_H7_PWM_StepperControl](examples/Portenta_H7_PWM_StepperControl)
+ * [ 10. RP2040_PWM_StepperControl](examples/RP2040_PWM_StepperControl)
+ * [ 11. SAMD_PWM_StepperControl](examples/SAMD_PWM_StepperControl)
+ * [ 12. SAMDUE_PWM_StepperControl](examples/SAMDUE_PWM_StepperControl)
+ * [ 13. STM32_PWM_StepperControl](examples/STM32_PWM_StepperControl)
+ * [ 14. Teensy_PWM_StepperControl](examples/Teensy_PWM_StepperControl)
+* [Example RP2040_PWM_StepperControl](#example-RP2040_PWM_StepperControl)
+* [Debug Terminal Output Samples](#debug-terminal-output-samples)
+ * [1. PWM_Multi on MBED RaspberryPi Pico](#1-PWM_Multi-on-MBED-RaspberryPi-Pico)
+ * [2. PWM_Multi on RASPBERRY_PI_PICO](#2-PWM_Multi-on-RASPBERRY_PI_PICO)
+ * [3. PWM_DynamicFreq on Nano RP2040 Connect](#3-PWM_DynamicFreq-on-Nano-RP2040-Connect)
+ * [4. PWM_DynamicDutyCycle on RASPBERRY_PI_PICO](#4-PWM_DynamicDutyCycle-on-RASPBERRY_PI_PICO)
+ * [5. PWM_MultiChannel on RASPBERRY_PI_PICO](#5-PWM_MultiChannel-on-RASPBERRY_PI_PICO)
+ * [6. PWM_Waveform on RASPBERRY_PI_PICO](#6-PWM_Waveform-on-RASPBERRY_PI_PICO)
+ * [7. PWM_Waveform_Fast on RASPBERRY_PI_PICO](#7-PWM_Waveform_Fast-on-RASPBERRY_PI_PICO)
+* [Debug](#debug)
+* [Troubleshooting](#troubleshooting)
+* [Issues](#issues)
+* [TO DO](#to-do)
+* [DONE](#done)
+* [Contributions and Thanks](#contributions-and-thanks)
+* [Contributing](#contributing)
+* [License](#license)
+* [Copyright](#copyright)
+
+---
+---
+
+### Why do we need this [ContinuousStepper_Generic library](https://github.com/khoih-prog/ContinuousStepper_Generic)
+
+### Features
+
+This PWM-wrapper library enables you to use Hardware-PWM use PWM to control continuous Stepper Motor.
+
+This library is the wrapper of the following FastPWM libraries to enable you to **port your PWM code easily between platforms**
+
+ 1. [**RP2040_PWM**](https://github.com/khoih-prog/RP2040_PWM)
+ 2. [**AVR_PWM**](https://github.com/khoih-prog/AVR_PWM)
+ 3. [**megaAVR_PWM**](https://github.com/khoih-prog/megaAVR_PWM)
+ 4. [**ESP32_FastPWM**](https://github.com/khoih-prog/ESP32_FastPWM)
+ 5. [**SAMD_PWM**](https://github.com/khoih-prog/SAMD_PWM)
+ 6. [**SAMDUE_PWM**](https://github.com/khoih-prog/SAMDUE_PWM)
+ 7. [**nRF52_PWM**](https://github.com/khoih-prog/nRF52_PWM)
+ 8. [**Teensy_PWM**](https://github.com/khoih-prog/Teensy_PWM)
+ 9. [**ATtiny_PWM**](https://github.com/khoih-prog/ATtiny_PWM)
+10. [**Dx_PWM**](https://github.com/khoih-prog/Dx_PWM)
+11. [**Portenta_H7_PWM**](https://github.com/khoih-prog/Portenta_H7_PWM)
+12. [**MBED_ContinuousStepper_Generic**](https://github.com/khoih-prog/MBED_ContinuousStepper_Generic)
+13. [**nRF52_MBED_PWM**](https://github.com/khoih-prog/nRF52_MBED_PWM)
+14. [**STM32_PWM**](https://github.com/khoih-prog/STM32_PWM)
+
+---
+
+The most important feature is they're purely hardware-based PWM channels. Therefore, their operations are **not blocked by bad-behaving software functions / tasks**.
+
+This important feature is absolutely necessary for mission-critical tasks. These hardware PWM-channels, still work even if other software functions are blocking. Moreover, they are much more precise (certainly depending on clock frequency accuracy) than other software timers using `millis()` or `micros()`. That's necessary if you need to control external systems (Servo, etc.) requiring better accuracy.
+
+Being hardware-based PWM, their executions are not blocked by bad-behaving functions / tasks, such as connecting to WiFi, Internet or Blynk services. You can also have many `(up to 16)` PWM output signals to use.
+
+This non-being-blocked important feature is absolutely necessary for mission-critical tasks.
+
+---
+
+#### Why using hardware-based PWM is better
+
+Imagine you have a system with a **mission-critical** function, controlling a robot or doing something much more important. You normally use a software timer to poll, or even place the function in loop(). But what if another function is **blocking** the loop() or setup().
+
+So your function **might not be executed, and the result would be disastrous.**
+
+You'd prefer to have your function called, no matter what happening with other functions (busy loop, bug, etc.).
+
+The correct choice is to use a Hardware Timer with **Interrupt** to call your function.
+
+These hardware-based PWM channels still work even if other software functions are blocking. Moreover, they are much more **precise** (certainly depending on clock frequency accuracy) than other software-based PWMs, using millis() or micros(). That's necessary if you need to measure some data requiring better accuracy.
+
+Functions using normal software-based PWMs, relying on loop() and calling millis(), won't work if the loop() or setup() is blocked by certain operation. For example, certain function is blocking while it's connecting to WiFi or some services.
+
+
+---
+
+### Currently supported Boards
+
+This [**ContinuousStepper_Generic** library](https://github.com/khoih-prog/ContinuousStepper_Generic) currently supports these following boards:
+
+ 1. **nRF52 boards**, such as **AdaFruit Feather nRF52832, nRF52840 Express, BlueFruit Sense, Itsy-Bitsy nRF52840 Express, Metro nRF52840 Express, NINA_B302_ublox, NINA_B112_ublox, etc.**
+ 2. **SAM DUE**
+ 3. **SAMD21**
+ - Arduino SAMD21: ZERO, MKRs, NANO_33_IOT, etc.
+ - Adafruit SAMD21 (M0): ItsyBitsy M0, Feather M0, Feather M0 Express, Metro M0 Express, Circuit Playground Express, Trinket M0, PIRkey, Hallowing M0, Crickit M0, etc.
+ - Seeeduino: LoRaWAN, Zero, Femto M0, XIAO M0, Wio GPS Board, etc.
+
+ 4. **SAMD51**
+ - Adafruit SAMD51 (M4): Metro M4, Grand Central M4, ItsyBitsy M4, Feather M4 Express, Trellis M4, Metro M4 AirLift Lite, MONSTER M4SK Express, Hallowing M4, etc.
+ - Seeeduino: Wio Terminal, Grove UI Wireless
+
+ 5. **Teensy (4.1, 4.0, 3.6, 3.5, 3,2, 3.1, 3.0, LC) with SPI, SPI1, SPI2**
+ 6. **AVR Mega1280, 2560, ADK.**
+ 7. ESP32
+ 8. ESP8266 **To be addded**
+
+ 9. RP2040-based boards, such as **RASPBERRY_PI_PICO, ADAFRUIT_FEATHER_RP2040 and GENERIC_RP2040**, using [**Arduino-mbed RP2040** core](https://github.com/arduino/ArduinoCore-mbed) or [**Earle Philhower's arduino-pico** core](https://github.com/earlephilhower/arduino-pico) with **SPI, SPI1**
+
+ 10. **Portenta_H7**
+
+ 11. **Arduino UNO WiFi Rev2, AVR_NANO_EVERY, etc.**
+
+ 12. **Arduino AVR_Dx boards using DxCore**
+
+- **AVRDA-based boards (AVR128DA, AVR64DA, AVR32DA, etc.)**
+
+- **AVRDB-based boards (AVR128DB, AVR64DB, AVR32DB, etc.)**
+
+ 13. **Seeeduino nRF52840-based boards such as XIAO_NRF52840 and XIAO_NRF52840_SENSE**, etc. using Seeed `mbed` or `nRF52` core
+
+
+---
+---
+
+## Prerequisites
+
+ 1. [`Arduino IDE 1.8.19+` for Arduino](https://github.com/arduino/Arduino). [](https://github.com/arduino/Arduino/releases/latest)
+ 2. [`Arduino AVR core 1.8.6+`](https://github.com/arduino/ArduinoCore-avr) for Arduino (Use Arduino Board Manager) AVR boards. [](https://github.com/arduino/ArduinoCore-avr/releases/latest)
+ 3. [`Teensy core v1.57+`](https://www.pjrc.com/teensy/td_download.html) for Teensy (4.1, 4.0, 3.6, 3.5, 3,2, 3.1, 3.0) boards. [](https://github.com/PaulStoffregen/cores/releases/latest)
+ 4. [`Arduino SAM DUE core v1.6.12+`](https://github.com/arduino/ArduinoCore-sam) for SAM DUE ARM Cortex-M3 boards.
+ 5. [`Arduino SAMD core 1.8.13+`](https://github.com/arduino/ArduinoCore-samd) for SAMD ARM Cortex-M0+ boards. [](https://github.com/arduino/ArduinoCore-samd/releases/latest)
+ 6. [`Adafruit SAMD core 1.7.11+`](https://github.com/adafruit/ArduinoCore-samd) for SAMD ARM Cortex-M0+ and M4 boards (Nano 33 IoT, etc.). [](https://github.com/adafruit/ArduinoCore-samd/releases/latest)
+ 7. [`Seeeduino SAMD core 1.8.3+`](https://github.com/Seeed-Studio/ArduinoCore-samd) for SAMD21/SAMD51 boards (XIAO M0, Wio Terminal, etc.). [](https://github.com/Seeed-Studio/ArduinoCore-samd/releases/latest/)
+ 8. [`Adafruit nRF52 v1.3.0+`](https://github.com/adafruit/Adafruit_nRF52_Arduino) for nRF52 boards such as Adafruit NRF52840_FEATHER, NRF52832_FEATHER, NRF52840_FEATHER_SENSE, NRF52840_ITSYBITSY, NRF52840_CIRCUITPLAY, NRF52840_CLUE, NRF52840_METRO, NRF52840_PCA10056, PARTICLE_XENON, **NINA_B302_ublox**, etc. [](https://github.com/adafruit/Adafruit_nRF52_Arduino/releases/latest)
+ 9. [`ESP32 Core 2.0.6+`](https://github.com/espressif/arduino-esp32) for ESP32-based boards. [](https://github.com/espressif/arduino-esp32/releases/latest/)
+10. [`ESP8266 Core 3.1.1+`](https://github.com/esp8266/Arduino) for ESP8266-based boards. [](https://github.com/esp8266/Arduino/releases/latest/). To use ESP8266 core 2.7.1+ for LittleFS.
+11. [`ArduinoCore-mbed mbed_rp2040, mbed_nano, mbed_portenta core 3.5.4+`](https://github.com/arduino/ArduinoCore-mbed) for Arduino (Use Arduino Board Manager) **Portenta_H7, RP2040-based boards, such as Nano_RP2040_Connect, RASPBERRY_PI_PICO**. [](https://github.com/arduino/ArduinoCore-mbed/releases/latest)
+12. [`Earle Philhower's arduino-pico core v2.7.1+`](https://github.com/earlephilhower/arduino-pico) for RP2040-based boards such as **RASPBERRY_PI_PICO, ADAFRUIT_FEATHER_RP2040 and GENERIC_RP2040**, etc. [](https://github.com/earlephilhower/arduino-pico/releases/latest)
+13. [`Arduino megaAVR core 1.8.7+`](https://github.com/arduino/ArduinoCore-megaavr/releases) for Arduino megaAVR boards such as **Arduino UNO WiFi Rev2, AVR_NANO_EVERY, etc.**. [](https://github.com/arduino/ArduinoCore-megaavr/releases/latest)
+14. [`SpenceKonde DxCore core 1.5.3+`](https://github.com/SpenceKonde/DxCore) for Arduino AVRDx boards. [](https://github.com/SpenceKonde/DxCore/releases/latest). Follow [**DxCore Installation**](https://github.com/SpenceKonde/DxCore/blob/master/Installation.md).
+15. [`Seeeduino nRF52 core 1.1.0+`](https://github.com/Seeed-Studio/Adafruit_nRF52_Arduino) for Seeed nRF52840-based boards such as **Seeed_XIAO_NRF52840 and Seeed_XIAO_NRF52840_SENSE**. [](https://github.com/Seeed-Studio/Adafruit_nRF52_Arduino/releases/latest)
+16. [`Seeeduino mbed core 2.9.0+`](https://github.com/Seeed-Studio/ArduinoCore-mbed) for Seeed nRF52840-based boards such as **SEEED_XIAO_NRF52840 and SEEED_XIAO_NRF52840_SENSE**. [](https://github.com/Seeed-Studio/ArduinoCore-mbed/releases/latest)
+
+---
+
+17. [`RP2040_PWM library v1.4.1+`](https://github.com/khoih-prog/RP2040_PWM). To install. check [](https://www.ardu-badge.com/RP2040_PWM)
+18. [`AVR_PWM library v1.0.1+`](https://github.com/khoih-prog/AVR_PWM). To install. check [](https://www.ardu-badge.com/AVR_PWM)
+19. [`megaAVR_PWM library v1.0.1+`](https://github.com/khoih-prog/megaAVR_PWM). To install. check [](https://www.ardu-badge.com/megaAVR_PWM)
+20. [`ESP32_FastPWM library v1.0.1+`](https://github.com/khoih-prog/ESP32_FastPWM). To install. check [](https://www.ardu-badge.com/ESP32_FastPWM)
+21. [`SAMD_PWM library v1.0.1+`](https://github.com/khoih-prog/SAMD_PWM). To install. check [](https://www.ardu-badge.com/SAMD_PWM)
+22. [`SAMDUE_PWM library v1.0.1+`](https://github.com/khoih-prog/SAMDUE_PWM). To install. check [](https://www.ardu-badge.com/SAMDUE_PWM)
+23. [`nRF52_PWM library v1.0.1+`](https://github.com/khoih-prog/nRF52_PWM). To install. check [](https://www.ardu-badge.com/nRF52_PWM)
+24. [`Teensy_PWM library v1.0.1+`](https://github.com/khoih-prog/Teensy_PWM). To install. check [](https://www.ardu-badge.com/Teensy_PWM)
+25. [`ATtiny_PWM library v1.0.1+`](https://github.com/khoih-prog/ATtiny_PWM). To install. check [](https://www.ardu-badge.com/ATtiny_PWM)
+26. [`Dx_PWM library v1.0.1+`](https://github.com/khoih-prog/Dx_PWM). To install. check [](https://www.ardu-badge.com/Dx_PWM)
+27. [`Portenta_H7_PWM library v2.0.3+`](https://github.com/khoih-prog/Portenta_H7_PWM). To install. check [](https://www.ardu-badge.com/Portenta_H7_PWM)
+28. [`MBED_RP2040_PWM library v1.0.1+`](https://github.com/khoih-prog/MBED_RP2040_PWM). To install. check [](https://www.ardu-badge.com/MBED_RP2040_PWM)
+29. [`nRF52_MBED_PWM library v1.0.3+`](https://github.com/khoih-prog/nRF52_MBED_PWM). To install. check [](https://www.ardu-badge.com/nRF52_MBED_PWM)
+30. [`STM32_PWM library v1.0.1+`](https://github.com/khoih-prog/STM32_PWM). To install. check [](https://www.ardu-badge.com/STM32_PWM)
+
+---
+---
+
+## Installation
+
+### Use Arduino Library Manager
+
+The best and easiest way is to use `Arduino Library Manager`. Search for [**ContinuousStepper_Generic**](https://github.com/khoih-prog/ContinuousStepper_Generic), then select / install the latest version.
+You can also use this link [](https://www.ardu-badge.com/ContinuousStepper_Generic) for more detailed instructions.
+
+### Manual Install
+
+Another way to install is to:
+
+1. Navigate to [**ContinuousStepper_Generic**](https://github.com/khoih-prog/ContinuousStepper_Generic) page.
+2. Download the latest release `ContinuousStepper_Generic-main.zip`.
+3. Extract the zip file to `ContinuousStepper_Generic-main` directory
+4. Copy whole `ContinuousStepper_Generic-main` folder to Arduino libraries' directory such as `~/Arduino/libraries/`.
+
+### VS Code & PlatformIO
+
+1. Install [VS Code](https://code.visualstudio.com/)
+2. Install [PlatformIO](https://platformio.org/platformio-ide)
+3. Install [**ContinuousStepper_Generic** library](https://registry.platformio.org/libraries/khoih-prog/ContinuousStepper_Generic) by using [Library Manager](https://registry.platformio.org/libraries/khoih-prog/ContinuousStepper_Generic/installation). Search for **ContinuousStepper_Generic** in [Platform.io Author's Libraries](https://platformio.org/lib/search?query=author:%22Khoi%20Hoang%22)
+4. Use included [platformio.ini](platformio/platformio.ini) file from examples to ensure that all dependent libraries will installed automatically. Please visit documentation for the other options and examples at [Project Configuration File](https://docs.platformio.org/page/projectconf.html)
+
+---
+---
+
+### Examples:
+
+ 1. [ATtiny_PWM_StepperControl](examples/ATtiny_PWM_StepperControl)
+ 2. [AVR_PWM_StepperControl](examples/AVR_PWM_StepperControl)
+ 3. [Dx_PWM_StepperControl](examples/Dx_PWM_StepperControl)
+ 4. [ESP32_PWM_StepperControl](examples/ESP32_PWM_StepperControl)
+ 5. [MBED_RP2040_PWM_StepperControl](examples/MBED_RP2040_PWM_StepperControl)
+ 6. [megaAVR_PWM_StepperControl](examples/megaAVR_PWM_StepperControl)
+ 7. [nRF52_MBED_PWM_StepperControl](examples/nRF52_MBED_PWM_StepperControl)
+ 8. [nRF52_PWM_StepperControl](examples/nRF52_PWM_StepperControl)
+ 9. [Portenta_H7_PWM_StepperControl](examples/Portenta_H7_PWM_StepperControl)
+10. [RP2040_PWM_StepperControl](examples/RP2040_PWM_StepperControl)
+11. [SAMD_PWM_StepperControl](examples/SAMD_PWM_StepperControl)
+12. [SAMDUE_PWM_StepperControl](examples/SAMDUE_PWM_StepperControl)
+13. [STM32_PWM_StepperControl](examples/STM32_PWM_StepperControl)
+14. [Teensy_PWM_StepperControl](examples/Teensy_PWM_StepperControl)
+
+
+---
+---
+
+### Example [RP2040_PWM_StepperControl](examples/RP2040_PWM_StepperControl)
+
+https://github.com/khoih-prog/ContinuousStepper_Generic/blob/9d4196bb4dbe699f32f5b92159ffa0235d86397b/examples/RP2040_PWM_StepperControl/RP2040_PWM_StepperControl.ino#L16-L92
+
+
+---
+---
+
+### Debug
+
+Debug is enabled by default on Serial.
+
+You can also change the debugging level `_PWM_LOGLEVEL_` from 0 to 4
+
+```cpp
+// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
+#define _PWM_LOGLEVEL_ 0
+```
+
+---
+
+### Troubleshooting
+
+If you get compilation errors, more often than not, you may need to install a newer version of the core for Arduino boards.
+
+Sometimes, the library will only work if you update the board core to the latest version because I am using newly added functions.
+
+
+---
+---
+
+### Issues
+
+Submit issues to: [ContinuousStepper_Generic issues](https://github.com/khoih-prog/ContinuousStepper_Generic/issues)
+
+---
+
+## TO DO
+
+1. Search for bug and improvement
+2. Similar features for remaining or new Arduino boards
+
+---
+
+## DONE
+
+ 1. Initial coding to use PWM to control continuous Stepper Motor. Check [Using PWM to step a stepper driver #16](https://github.com/khoih-prog/ContinuousStepper_Generic/issues/16)
+ 2. Use `allman astyle` and add `utils`
+
+---
+---
+
+### Contributions and Thanks
+
+Many thanks for everyone for bug reporting, new feature suggesting, testing and contributing to the development of this library.
+
+1. Thanks to [Paul van Dinther](https://github.com/dinther) for proposing new way to use PWM to drive Stepper-Motor in [Using PWM to step a stepper driver #16](https://github.com/khoih-prog/RP2040_PWM/issues/16), leading to this library
+
+
+ Paul van Dinther |
+
+
+
+
+---
+---
+
+## Table of Contents
+
+* [Changelog](#changelog)
+ * [Initial Releases v1.0.0](#Initial-Releases-v100)
+
+---
+---
+
+## Changelog
+
+### Initial Releases v1.0.0
+
+1. Initial coding to use PWM to control continuous Stepper Motor. Check [Using PWM to step a stepper driver #16](https://github.com/khoih-prog/ContinuousStepper_Generic/issues/16)
+2. Use `allman astyle` and add `utils`
+
diff --git a/examples/ATtiny_PWM_StepperControl/ATtiny_PWM_StepperControl.ino b/examples/ATtiny_PWM_StepperControl/ATtiny_PWM_StepperControl.ino
new file mode 100644
index 0000000..ee7b68e
--- /dev/null
+++ b/examples/ATtiny_PWM_StepperControl/ATtiny_PWM_StepperControl.ino
@@ -0,0 +1,128 @@
+/****************************************************************************************************************************
+ ATtiny_PWM_StepperControl.ino
+ For Arduino AVR ATtiny-based boards (ATtiny3217, etc.) using megaTinyCore
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !defined(MEGATINYCORE)
+ #error This is designed only for AVR_ATtiny boards using megaTinyCore
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+// Select false to use PWM
+#define USING_TIMER false //true
+
+#include "ContinuousStepper_Generic.h"
+
+/*
+ const uint8_t digital_pin_to_timer[] = {
+ // Left side, top to bottom
+ TIMERA0, // 0 PA4 WO4 WOA
+ TIMERA0, // 1 PA5 WO5 WOB
+ #if defined(DAC0)
+ DACOUT, // 2 PA6
+ #else
+ NOT_ON_TIMER, // 2 PA6
+ #endif
+ NOT_ON_TIMER, // 3 PA7
+ NOT_ON_TIMER, // 4 PB7
+ NOT_ON_TIMER, // 5 PB6
+ NOT_ON_TIMER, // 6 PB5 WO2 Alt
+ NOT_ON_TIMER, // 7 PB4 WO1 Alt
+ NOT_ON_TIMER, // 8 PB3 WO0 Alt
+ TIMERA0, // 9 PB2 WO2
+ TIMERA0, // 10 PB1 WO1
+ // Right side, bottom to top
+ TIMERA0, // 11 PB0 WO0
+ #if (defined(TCD0) && defined(USE_TIMERD0_PWM))
+ TIMERD0, // 12 PC0 WOC
+ TIMERD0, // 13 PC1 WOD
+ #else
+ NOT_ON_TIMER, // 12 PC0
+ NOT_ON_TIMER, // 13 PC1
+ #endif
+ NOT_ON_TIMER, // 14 PC2
+ NOT_ON_TIMER, // 15 PC3 WO3 Alt
+ NOT_ON_TIMER, // 16 PC4 WO4 Alt
+ NOT_ON_TIMER, // 17 PC5 WO5 Alt
+ NOT_ON_TIMER, // 18 PA1
+ NOT_ON_TIMER, // 19 PA2
+ TIMERA0, // 20 PA3 WO3
+ NOT_ON_TIMER // 21 PA0
+ };
+*/
+
+// OK, only PIN_PA4-5:TCA0
+// PIN_PC0-1: TCD0 => not OK yet for frequency
+// Not OK, PIN_PA6, 7, PIN_PB0-2:TCA0
+
+#define STEP_PIN PIN_PA5 //PIN_PB4
+
+#define DIR_PIN PIN_PA6
+
+ATtiny_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting ATtiny_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(AT_TINY_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new ATtiny_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/AVR_PWM_StepperControl/AVR_PWM_StepperControl.ino b/examples/AVR_PWM_StepperControl/AVR_PWM_StepperControl.ino
new file mode 100644
index 0000000..762d578
--- /dev/null
+++ b/examples/AVR_PWM_StepperControl/AVR_PWM_StepperControl.ino
@@ -0,0 +1,155 @@
+/****************************************************************************************************************************
+ AVR_PWM_StepperControl.ino
+ For AVR-based boards (UNO, Nano, Mega, 32U4, 16U4, etc. )
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ This is pure hardware-based PWM
+*****************************************************************************************************************************/
+/******************************************************************************************************************************
+ // For UNO / Nano
+ Timer0 ( 8-bit) used by delay(), millis() and micros(), and PWM generation on pins 5 (6 not usable)
+ Timer1 (16-bit) used by the Servo.h library and PWM generation on pins 9 and 10
+ Timer2 ( 8-bit) used by Tone() and PWM generation on pins 3 and 11
+ // For Mega
+ Timer0 ( 8-bit) used by delay(), millis() and micros(), and PWM generation on pins 4 (13 not usable)
+ Timer1 (16-bit) used by the Servo.h library and PWM generation on pins 11, 12
+ Timer2 ( 8-bit) used by Tone() and PWM generation on pins 9 and 10
+ Timer3 (16-bit) used by PWM generation on pins 2, 3 and 5
+ Timer4 (16-bit) used by PWM generation on pins 6, 7 and 8
+ Timer5 (16-bit) used by PWM generation on pins 44, 45 and 46
+
+ ////////////////////////////////////////////
+ // For Mega (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 44, 45, 46)
+ Pin 2 => TIMER3B // PE 4 ** 2 ** PWM2
+ Pin 3 => TIMER3C // PE 5 ** 3 ** PWM3
+ Pin 4 => TIMER0B // PG 5 ** 4 ** PWM4
+ Pin 5 => TIMER3A // PE 3 ** 5 ** PWM5
+ Pin 6 => TIMER4A // PH 3 ** 6 ** PWM6
+ Pin 7 => TIMER4B // PH 4 ** 7 ** PWM7
+ Pin 8 => TIMER4C // PH 5 ** 8 ** PWM8
+ Pin 9 => TIMER2B // PH 6 ** 9 ** PWM9
+ Pin 10 => TIMER2A // PB 4 ** 10 ** PWM10
+ Pin 11 => TIMER1A // PB 5 ** 11 ** PWM11
+ Pin 12 => TIMER1B // PB 6 ** 12 ** PWM12
+ Pin 13 => TIMER0A // PB 7 ** 13 ** PWM13
+ Pin 44 => TIMER5C // PL 5 ** 44 ** D44
+ Pin 45 => TIMER5B // PL 4 ** 45 ** D45
+ Pin 46 => TIMER5A // PL 3 ** 46 ** D46
+ ////////////////////////////////////////////
+ // For 32u4 (3, 5, 6, 9, 10, 11, 13)
+ Pin 3 => TIMER0B
+ Pin 5 => TIMER3A
+ Pin 6 => TIMER4D
+ Pin 9 => TIMER1A
+ Pin 10 => TIMER1B
+ Pin 11 => TIMER0A
+ Pin 13 => TIMER4A
+ ////////////////////////////////////////////
+ // For UNO, Nano (3, 5, 6, 9, 10, 11)
+ Pin 3 => TIMER2B,
+ Pin 5 => TIMER0B
+ Pin 6 => TIMER0A
+ Pin 9 => TIMER1A
+ Pin 10 => TIMER1B
+ Pin 11 => TIMER2(A)
+******************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#define _PWM_LOGLEVEL_ 4
+
+#include "ContinuousStepper_Generic.h"
+
+#if ( PWM_USING_ATMEGA2560 )
+// Pins tested OK in Mega
+//#define STEP_PIN 12 // Timer1B on Mega
+//#define STEP_PIN 11 // Timer1A on Mega
+//#define STEP_PIN 9 // Timer2B on Mega
+//#define STEP_PIN 2 // Timer3B on Mega
+//#define STEP_PIN 3 // Timer3C on Mega
+//#define STEP_PIN 5 // Timer3A on Mega
+//#define STEP_PIN 6 // Timer4A on Mega
+//#define STEP_PIN 7 // Timer4B on Mega
+#define STEP_PIN 8 // Timer4C on Mega
+//#define STEP_PIN 46 // Timer5A on Mega
+//#define STEP_PIN 45 // Timer5B on Mega
+//#define STEP_PIN 44 // Timer5C on Mega
+
+#elif ( PWM_USING_ATMEGA_32U4 )
+// Pins tested OK on 32u4
+//#define STEP_PIN 5 // Timer3A on 32u4
+#define STEP_PIN 9 // Timer1A on 32u4
+//#define STEP_PIN 10 // Timer1B on 32u4
+
+#else
+
+// Pins tested OK on Nano / UNO
+//#define STEP_PIN 9 // Timer1A on UNO, Nano, etc
+#define STEP_PIN 10 // Timer1B on UNO, Nano, etc
+//#define STEP_PIN 5 // Timer0B on UNO, Nano, e
+//#define STEP_PIN 3 // Timer2B on UNO, Nano, etc
+#endif
+
+#define DIR_PIN 12
+
+AVR_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting AVR_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(AVR_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new AVR_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/Dx_PWM_StepperControl/Dx_PWM_StepperControl.ino b/examples/Dx_PWM_StepperControl/Dx_PWM_StepperControl.ino
new file mode 100644
index 0000000..8d1a866
--- /dev/null
+++ b/examples/Dx_PWM_StepperControl/Dx_PWM_StepperControl.ino
@@ -0,0 +1,109 @@
+/****************************************************************************************************************************
+ Dx_PWM_StepperControl.ino
+ For Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.) using DxCore
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !defined(DXCORE)
+ #error This is designed only for AVRDx boards using DXCORE
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+#if defined(__AVR_AVR128DA48__)
+ #define SerialDebug Serial1
+#elif defined(__AVR_AVR128DB48__)
+ #define SerialDebug Serial3
+#else
+ // standard Serial
+ #define SerialDebug Serial
+#endif
+
+#define PWM_GENERIC_DEBUG_PORT SerialDebug
+
+#include "ContinuousStepper_Generic.h"
+
+// On DX AVR128DB48
+// PA0-3: Not PWM
+// PA4-7: TD0 => not supported yet
+// PB0-5: TCA1
+// PC0-5: TCA0
+// PC6-7: Not PWM
+// PD0-7: Not PWM
+// PE0-3: Not PWM
+// PF0-3: Not PWM
+// PF4-5: TCB
+
+#if defined(PIN_PF5)
+ #define STEP_PIN PIN_PF5
+#else
+ #define STEP_PIN PIN_PC0
+#endif
+
+#define DIR_PIN PIN_PA0
+
+Dx_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ SerialDebug.begin(115200);
+
+ while (!SerialDebug && millis() < 5000);
+
+ delay(100);
+
+ SerialDebug.print(F("\nStarting Dx_PWM_StepperControl on "));
+ SerialDebug.println(BOARD_NAME);
+ SerialDebug.println(DX_PWM_VERSION);
+ SerialDebug.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new Dx_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/ESP32_PWM_StepperControl/ESP32_PWM_StepperControl.ino b/examples/ESP32_PWM_StepperControl/ESP32_PWM_StepperControl.ino
new file mode 100644
index 0000000..6db9eed
--- /dev/null
+++ b/examples/ESP32_PWM_StepperControl/ESP32_PWM_StepperControl.ino
@@ -0,0 +1,104 @@
+/****************************************************************************************************************************
+ ESP32_PWM_StepperControl.ino
+ For ESP32, ESP32_S2, ESP32_S3, ESP32_C3 boards with ESP32 core v2.0.0+
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ This is pure hardware-based PWM
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+/******************************************************************************************************************************
+ // All GPIO pins (but GPIO34-39) can be used to generate PWM
+ // For ESP32, number of channels is 16, max 20-bit resolution
+ // For ESP32_S2, ESP32_S3, number of channels is 8
+ // For ESP32_C3, number of channels is 6
+******************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !defined(ESP32)
+ #error This is designed only for ESP32 boards
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+#include "ContinuousStepper_Generic.h"
+
+#if ARDUINO_ESP32C3_DEV
+ #define STEP_PIN 9
+#else
+ #define STEP_PIN 16
+#endif
+
+#define DIR_PIN 4
+
+// Max resolution is 20-bit
+// Resolution 65536 (16-bit) for lower frequencies, OK @ 1K
+// Resolution 4096 (12-bit) for lower frequencies, OK @ 10K
+// Resolution 1024 (10-bit) for higher frequencies, OK @ 50K
+// Resolution 256 ( 8-bit)for higher frequencies, OK @ 100K, 200K
+// Resolution 128 ( 7-bit) for higher frequencies, OK @ 500K
+int PWM_resolution = 10;
+
+//creates pwm instance
+ESP32_FAST_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting ESP32_PWM_StepperControl on "));
+ Serial.println(ARDUINO_BOARD);
+ Serial.println(ESP32_FAST_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new ESP32_FAST_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/MBED_RP2040_PWM_StepperControl/MBED_RP2040_PWM_StepperControl.ino b/examples/MBED_RP2040_PWM_StepperControl/MBED_RP2040_PWM_StepperControl.ino
new file mode 100644
index 0000000..aed08b8
--- /dev/null
+++ b/examples/MBED_RP2040_PWM_StepperControl/MBED_RP2040_PWM_StepperControl.ino
@@ -0,0 +1,81 @@
+/****************************************************************************************************************************
+ MBED_RP2040_PWM_StepperControl.ino
+ For MBED RP2040 boards
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_RASPBERRY_PI_PICO) || defined(ARDUINO_ADAFRUIT_FEATHER_RP2040) || \
+ defined(ARDUINO_GENERIC_RP2040) ) && defined(ARDUINO_ARCH_MBED)
+ #error This code is intended to run on the MBED RP2040 platform! Please check your Tools->Board setting.
+#endif
+
+#define _PWM_LOGLEVEL_ 1
+
+#include "ContinuousStepper_Generic.h"
+
+mbed::PwmOut* stepper = nullptr;
+
+#define STEP_PIN 8
+#define DIR_PIN 9
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ setPWM(stepper, STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ setPWM(stepper, STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting MBED_RP2040_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(MBED_RP2040_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ //setSpeed(0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/Portenta_H7_PWM_StepperControl/Portenta_H7_PWM_StepperControl.ino b/examples/Portenta_H7_PWM_StepperControl/Portenta_H7_PWM_StepperControl.ino
new file mode 100644
index 0000000..7444ca2
--- /dev/null
+++ b/examples/Portenta_H7_PWM_StepperControl/Portenta_H7_PWM_StepperControl.ino
@@ -0,0 +1,104 @@
+/****************************************************************************************************************************
+ Portenta_H7_PWM_StepperControlerControl.ino
+
+ For Portenta_H7 boards
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( defined(ARDUINO_PORTENTA_H7_M7) || defined(ARDUINO_PORTENTA_H7_M4) )
+ #error For Portenta_H7 only
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
+#include "ContinuousStepper_Generic.h"
+
+// Can't use same TimerIndex again, e.g., the D1 and D2, using TIM1, can't be use concurrently
+// That's why D0, D1, D3, D4 and D6 (using TimerIndex 8, 1, HRTIM and 3) are OK together
+
+// Only OK for D0, D1, D2, D4 and D5, PA_0C(D15/A0), PA_1C(D16/A1),
+// D3, D6, D7, D8, D9, D10, D11, D12, D13, D14, D17(PC_2C/A2), D18(PC_3C/3), PC2(D19/A4) LEDG, LEDB not OK
+#define pinD0 D0 // PH15 / TIM8_CH3N
+#define pinD1 D1 // PK1 / TIM1_CH1, TIM8_CH3
+#define pinD2 D2 // PJ11 / TIM1_CH2, TIM8_CH2N
+#define pinD3 D3 // PG7 / HRTIM_CHE2
+#define pinD4 D4 // PC7 / TIM3_CH2, TIM8_CH2, HRTIM_CHA2
+#define pinD5 D5 // PC6 / TIM3_CH1, TIM8_CH1, HRTIM_CHA1, LPTIM3_OUT
+#define pinD6 D6 // PA8 / HRTIM_CHB2 (TIM1_CH1, TIM8_BKIN2)
+
+// See https://www.st.com/resource/en/datasheet/stm32h747xi.pdf, Table 7, page 53
+// Can't use pins with same TIMx. For example,
+// pinD1 and pinD2, using same TIM1, can't be used at the same time
+// pinD4 and pinD5, using same TIM3, can't be used at the same time
+// pinD3 and pinD6 are using HRTIM, can't be used at the same time and the minimum freq must be ~770Hz
+
+#define STEP_PIN pinD5
+
+#define DIR_PIN D9
+
+mbed::PwmOut* stepper = nullptr;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ setPWM(stepper, STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ setPWM(stepper, STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting Portenta_H7_PWM_StepperControlerControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(PORTENTA_H7_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // SetPWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ setPWM(stepper, STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/RP2040_PWM_StepperControl/RP2040_PWM_StepperControl.ino b/examples/RP2040_PWM_StepperControl/RP2040_PWM_StepperControl.ino
new file mode 100644
index 0000000..6474860
--- /dev/null
+++ b/examples/RP2040_PWM_StepperControl/RP2040_PWM_StepperControl.ino
@@ -0,0 +1,92 @@
+/****************************************************************************************************************************
+ RP2040_PWM_StepperControl.ino
+ For RP2040 boards
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or measure the frequency
+ or duty cycle of an input signal. This gives a total of up to 16 controllable PWM outputs. All 30 GPIO pins can be driven
+ by the PWM block
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#define _PWM_LOGLEVEL_ 1
+
+#if ( defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_RASPBERRY_PI_PICO) || defined(ARDUINO_ADAFRUIT_FEATHER_RP2040) || \
+ defined(ARDUINO_GENERIC_RP2040) ) && !defined(ARDUINO_ARCH_MBED)
+
+ #if(_PWM_LOGLEVEL_>3)
+ #warning USING_RP2040_PWM
+ #endif
+#else
+ #error This code is intended to run on the RP2040 arduino-pico platform! Please check your Tools->Board setting.
+#endif
+
+#include "ContinuousStepper_Generic.h"
+
+RP2040_PWM* stepper;
+
+#define STEP_PIN 8
+#define DIR_PIN 9
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting RP2040_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(RP2040_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500 in it
+ // The duty cycle is how you turn the motor on and off
+ stepper = new RP2040_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/SAMDUE_PWM_StepperControl/SAMDUE_PWM_StepperControl.ino b/examples/SAMDUE_PWM_StepperControl/SAMDUE_PWM_StepperControl.ino
new file mode 100644
index 0000000..bce4c96
--- /dev/null
+++ b/examples/SAMDUE_PWM_StepperControl/SAMDUE_PWM_StepperControl.ino
@@ -0,0 +1,92 @@
+/****************************************************************************************************************************
+ SAMDUE_PWM_StepperControl.ino
+ For SAM_DUE boards using hardware-based PWM
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#define _PWM_LOGLEVEL_ 4
+
+// Select false to use PWM
+#define USING_TIMER true
+
+#include "ContinuousStepper_Generic.h"
+
+// SAM_DUE:
+// PWM pins: 6, 7, 8, 9
+// Timer pins: 2-5, 10-13.
+// pin2: TC0_CHA0, pin3: TC2_CHA7, pin4: TC2_CHB6, pin5: TC2_CHA6
+// pin 10: TC2_CHB7, pin11: TC2_CHA8, pin12: TC2_CHB8, pin13: TC0_CHB0
+
+#if USING_TIMER
+ #define STEP_PIN 5
+#else
+ #define STEP_PIN 6
+#endif
+
+SAMDUE_PWM* stepper;
+
+#define DIR_PIN 9
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting SAMDUE_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(SAMDUE_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new SAMDUE_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/SAMD_PWM_StepperControl/SAMD_PWM_StepperControl.ino b/examples/SAMD_PWM_StepperControl/SAMD_PWM_StepperControl.ino
new file mode 100644
index 0000000..2787a0e
--- /dev/null
+++ b/examples/SAMD_PWM_StepperControl/SAMD_PWM_StepperControl.ino
@@ -0,0 +1,86 @@
+/****************************************************************************************************************************
+ SAMD_PWM_StepperControl.ino
+ For SAMD21/SAMD51 boards using hardware-based PWM
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#define _PWM_LOGLEVEL_ 4
+
+#include "ContinuousStepper_Generic.h"
+
+// Not OK for Nano_33_IoT (0, 1, 7, 8, 13, 14, 15 )
+// OK for Nano_33_IoT (2, 3, 4, 5, 6, 9, 10, 11, 12, 16, 17)
+// TCC OK => pin 4, 5, 6, 8, 9, 10, 11, 16/A2, 17/A3
+// TC OK => pin 12
+// For ITSYBITSY_M4
+// 16-bit Higher accuracy, Lower Frequency, PWM Pin OK: TCCx: 0-2, 4, 5, 7, 9-13
+// 8-bit Lower accuracy, Hi Frequency, PWM Pin OK: TCx: 18-20, 24-25
+
+SAMD_PWM* stepper;
+
+#define STEP_PIN 9
+#define DIR_PIN 8
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting SAMD_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(SAMD_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new SAMD_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/STM32_PWM_StepperControl/STM32_PWM_StepperControl.ino b/examples/STM32_PWM_StepperControl/STM32_PWM_StepperControl.ino
new file mode 100644
index 0000000..7d5ec28
--- /dev/null
+++ b/examples/STM32_PWM_StepperControl/STM32_PWM_StepperControl.ino
@@ -0,0 +1,215 @@
+/****************************************************************************************************************************
+ STM32_PWM_StepperControl.ino
+
+ For STM32F/L/H/G/WB/MP1 boards
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Hardware-based multi-channel PWM wrapper library for STM32F/L/H/G/WB/MP1 boards
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( defined(STM32F0) || defined(STM32F1) || defined(STM32F2) || defined(STM32F3) ||defined(STM32F4) || defined(STM32F7) || \
+ defined(STM32L0) || defined(STM32L1) || defined(STM32L4) || defined(STM32H7) ||defined(STM32G0) || defined(STM32G4) || \
+ defined(STM32WB) || defined(STM32MP1) || defined(STM32L5))
+ #error This code is designed to run on STM32F/L/H/G/WB/MP1 platform! Please check your Tools->Board setting.
+#endif
+
+// These define's must be placed at the beginning before #include "ESP32_PWM.h"
+// _PWM_LOGLEVEL_ from 0 to 4
+// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
+#define _PWM_LOGLEVEL_ 4
+
+#define USING_MICROS_RESOLUTION true //false
+
+#include "ContinuousStepper_Generic.h"
+
+/////////////////////////////////////////////////
+
+// Change the pin according to your STM32 board. There is no single definition for all boards.
+#define pin0 PA0
+#define pin1 D1
+#define pin2 D2
+#define pin3 D3
+#define pin4 D4
+#define pin5 D5
+#define pin6 D6
+#define pin7 D7
+
+#define pin8 D8
+#define pin9 D9
+#define pin10 D10
+#define pin11 D11
+#define pin12 D12
+#define pin13 D13
+#define pin14 D14
+#define pin15 D15
+#define pin16 D16
+
+//////////////////////////////////////////////////////
+
+// Change the pin according to your STM32 board. There is no single definition for all boards.
+
+#if ( defined(STM32F1) && ( defined(ARDUINO_BLUEPILL_F103CB) || defined(ARDUINO_BLUEPILL_F103C8) ) )
+
+ #warning Using BLUEPILL_F103CB / BLUEPILL_F103C8 pins
+
+ // For F103CB => pin0, pin4, pin10 ============>> TimerIndex = 1, 2, 0
+ #define STEP_PIN pin3
+
+#elif ( defined(STM32F7) && defined(ARDUINO_NUCLEO_F767ZI) )
+
+ #warning Using NUCLEO_F767ZI pins
+
+ // For F767ZI => pin0, pin3, pin9/10 ============>> TimerIndex = 1, 0, 3
+ #define STEP_PIN pin3
+
+#elif ( defined(STM32L5) && defined(ARDUINO_NUCLEO_L552ZE_Q) )
+
+ #warning Using NUCLEO_L552ZE_Q pins
+
+ // For NUCLEO_L552ZE_Q => pin0, pin3, pin9/10 ============>> TimerIndex = 1, 0, 3
+ #define STEP_PIN pin3
+
+#elif ( defined(STM32H7) && defined(ARDUINO_NUCLEO_H743ZI2) )
+
+ #warning Using NUCLEO_H743ZI2 pins
+
+ // For NUCLEO_L552ZE_Q => pin0, pin3, pin9/10 ============>> TimerIndex = 1, 0, 3
+ #define STEP_PIN pin3
+
+#else
+
+ // For ??? => pin0, pin3, pin9/10 ============>> TimerIndex = 1, 0, 3
+ #define STEP_PIN pin3
+
+#endif
+
+//////////////////////////////////////////////////////
+
+#define DIR_PIN pin1
+
+TIM_TypeDef *stepperTimer;
+
+HardwareTimer *stepper;
+
+uint32_t channel;
+
+int previousSpeed = 0;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ // Do nothing if same speed
+ if (speed == previousSpeed)
+ return;
+
+ Serial.print(F("setSpeed = "));
+ Serial.println(speed);
+
+ // Create new instance for new speed
+ if (stepper)
+ delete stepper;
+
+ stepper = new HardwareTimer(stepperTimer);
+
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(channel, STEP_PIN, 500, 0, nullptr);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(channel, STEP_PIN, abs(speed), 50, nullptr);
+ }
+
+ previousSpeed = speed;
+}
+
+void initPWM(uint32_t step_pin)
+{
+ // Using pin = PA0, PA1, etc.
+ PinName pinNameToUse = digitalPinToPinName(step_pin);
+
+ // Automatically retrieve TIM instance and channel associated to pin
+ // This is used to be compatible with all STM32 series automatically.
+ stepperTimer = (TIM_TypeDef *) pinmap_peripheral(pinNameToUse, PinMap_PWM);
+
+ if (stepperTimer != nullptr)
+ {
+ uint8_t timerIndex = get_timer_index(stepperTimer);
+
+ // pin => 0, 1, etc
+ channel = STM_PIN_CHANNEL(pinmap_function( pinNameToUse, PinMap_PWM));
+
+ Serial.print("stepperTimer = 0x");
+ Serial.print( (uint32_t) stepperTimer, HEX);
+ Serial.print(", channel = ");
+ Serial.print(channel);
+ Serial.print(", TimerIndex = ");
+ Serial.print(get_timer_index(stepperTimer));
+ Serial.print(", PinName = ");
+ Serial.println( pinNameToUse );
+
+ stepper = new HardwareTimer(stepperTimer);
+
+ // SetPWM object and passed just a random frequency of 500 steps/s
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-revolution
+ // The duty cycle is how you turn the motor on and off
+ previousSpeed = 500;
+ stepper->setPWM(channel, step_pin, previousSpeed, 0, nullptr);
+ }
+ else
+ {
+ Serial.println("ERROR => Wrong pin, You have to select another one. Skip NULL stepperTimer");
+ }
+}
+
+void setup()
+{
+ pinMode(STEP_PIN, OUTPUT);
+ digitalWrite(STEP_PIN, LOW);
+ pinMode(DIR_PIN, OUTPUT);
+ digitalWrite(DIR_PIN, LOW);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting STM32_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(STM32_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ initPWM(STEP_PIN);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(2000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/Teensy_PWM_StepperControl/Teensy_PWM_StepperControl.ino b/examples/Teensy_PWM_StepperControl/Teensy_PWM_StepperControl.ino
new file mode 100644
index 0000000..05060eb
--- /dev/null
+++ b/examples/Teensy_PWM_StepperControl/Teensy_PWM_StepperControl.ino
@@ -0,0 +1,99 @@
+/****************************************************************************************************************************
+ Teensy_PWM_StepperControl.ino
+
+ For Teensy boards (Teensy 2.x, Teensy LC, Teensy 3.x, Teensy 4.x, etc.)
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( defined(CORE_TEENSY) || defined(__IMXRT1062__) || defined(__MK66FX1M0__) || defined(__MK64FX512__) || \
+ defined(__MKL26Z64__) || defined(__MK20DX256__) || defined(__MK20DX128__) )
+ #error This is designed only for Teensy boards using Teensy Core
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+#include "ContinuousStepper_Generic.h"
+
+#define USING_FLEX_TIMERS true
+
+#if USING_FLEX_TIMERS
+ #define STEP_PIN 5
+#else
+ #define STEP_PIN 15
+#endif
+
+#define DIR_PIN 9
+
+float frequency;
+float dutyCycle;
+
+Teensy_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+#if USING_FLEX_TIMERS
+ Serial.print(F("\nStarting Teensy_PWM_StepperControl using FlexTimers on "));
+#else
+ Serial.print(F("\nStarting Teensy_PWM_StepperControl using QuadTimers on "));
+#endif
+
+ Serial.println(BOARD_NAME);
+ Serial.println(TEENSY_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500 in it
+ // The duty cycle is how you turn the motor on and off
+ stepper = new Teensy_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/megaAVR_PWM_StepperControl/megaAVR_PWM_StepperControl.ino b/examples/megaAVR_PWM_StepperControl/megaAVR_PWM_StepperControl.ino
new file mode 100644
index 0000000..dd319eb
--- /dev/null
+++ b/examples/megaAVR_PWM_StepperControl/megaAVR_PWM_StepperControl.ino
@@ -0,0 +1,119 @@
+/****************************************************************************************************************************
+ megaAVR_PWM_StepperControl.ino
+ For Arduino megaAVR ATMEGA4809-based boards (UNO WiFi Rev2, NANO_EVERY, etc. )
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ This is pure hardware-based PWM
+*****************************************************************************************************************************/
+/******************************************************************************************************************************
+ Pins can be used for hardware-PWM
+ // For ATmega4809 (Nano Every, Uno WiFi Rev2, etc.)
+ TCA0 (16-bit) used by PWM generation on pins 5, 9 and 10
+ TCB0 (16-bit) used by PWM generation on pin 6
+ TCB1 (16-bit) used by PWM generation on pin 3
+ TCB2 (16-bit)
+ TCB3 (16-bit)
+ ////////////////////////////////////////////
+ // For ATmega4809 (Nano Every, Uno WiFi Rev2, etc.)
+ Pin 3 => TIMERB1, // 3 PF5, 8-bit PWM, 16-bit counter
+ Pin 5 => TIMERA0, // 5 PB2, 16-bit PWM, 16-bit counter
+ Pin 6 => TIMERB0, // 6 PF4, 8-bit PWM, 16-bit counter
+ Pin 9 => TIMERA0, // 9 PB0, 16-bit PWM, 16-bit counter
+ Pin 10 => TIMERA0, // 10 PB1, 16-bit PWM, 16-bit counter
+ ////////////////////////////////////////////
+******************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( defined(__AVR_ATmega4809__) || defined(ARDUINO_AVR_UNO_WIFI_REV2) || defined(ARDUINO_AVR_NANO_EVERY) || \
+ defined(ARDUINO_AVR_ATmega4809) || defined(ARDUINO_AVR_ATmega4808) || defined(ARDUINO_AVR_ATmega3209) || \
+ defined(ARDUINO_AVR_ATmega3208) || defined(ARDUINO_AVR_ATmega1609) || defined(ARDUINO_AVR_ATmega1608) || \
+ defined(ARDUINO_AVR_ATmega809) || defined(ARDUINO_AVR_ATmega808) )
+ #error This code is intended to run on the megaAVR platform! Please check your Tools->Board setting.
+#endif
+
+#define _PWM_LOGLEVEL_ 4
+
+#include "ContinuousStepper_Generic.h"
+
+#define USING_TIMERB true
+
+#if USING_TIMERB
+ // Pins tested OK in Nano Every ATmega4809
+ #define STEP_PIN 3 // TimerB1, for higher frequencies, up to 100KHz
+ //#define STEP_PIN 6 // TimerB0, for higher frequencies, up to 100KHz
+#elif USING_ARDUINO_MEGA_AVR_CORE
+ // Pins tested OK in Nano Every ATmega4809 using Arduino megaAVR core
+ // TimerA0 somehow can't be used with MegaCoreX
+ #define STEP_PIN 5 // TimerA0, only accurate @ low frequencies (< 1KHz) because of low 250KHz clock
+ //#define STEP_PIN 9 // TimerA0, only accurate @ low frequencies (< 1KHz) because of low 250KHz clock
+ //#define STEP_PIN 10 // TimerA0, only accurate @ low frequencies (< 1KHz) because of low 250KHz clock
+#else
+ #error TimerA0 to be used with Arduino megaAVR Core
+#endif
+
+#define DIR_PIN 4
+
+////////////////////////////////////////////
+
+megaAVR_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting megaAVR_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(MEGA_AVR_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new megaAVR_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/nRF52_MBED_PWM_StepperControl/nRF52_MBED_PWM_StepperControl.ino b/examples/nRF52_MBED_PWM_StepperControl/nRF52_MBED_PWM_StepperControl.ino
new file mode 100644
index 0000000..f4da984
--- /dev/null
+++ b/examples/nRF52_MBED_PWM_StepperControl/nRF52_MBED_PWM_StepperControl.ino
@@ -0,0 +1,81 @@
+/****************************************************************************************************************************
+ nRF52_MBED_PWM_StepperControl.ino
+ For Nano_33_BLE or Nano_33_BLE_Sense boards
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !( ARDUINO_ARCH_NRF52840 && TARGET_NAME == ARDUINO_NANO33BLE )
+ #error This code is designed to run on nRF52-based Nano-33-BLE boards using mbed-RTOS platform! Please check your Tools->Board setting.
+#endif
+
+#define _PWM_LOGLEVEL_ 1
+
+// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
+#include "ContinuousStepper_Generic.h"
+
+// All the digital pins on Arduino Nano 33 BLE sense are PWM-enabled pins which are numbered from D0 to D13
+
+#define STEP_PIN D2
+#define DIR_PIN D9
+
+mbed::PwmOut* stepper = nullptr;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ setPWM(stepper, STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ setPWM(stepper, STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting nRF52_MBED_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(nRF52_MBED_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/examples/nRF52_PWM_StepperControl/nRF52_PWM_StepperControl.ino b/examples/nRF52_PWM_StepperControl/nRF52_PWM_StepperControl.ino
new file mode 100644
index 0000000..b80a193
--- /dev/null
+++ b/examples/nRF52_PWM_StepperControl/nRF52_PWM_StepperControl.ino
@@ -0,0 +1,92 @@
+/****************************************************************************************************************************
+ nRF52_PWM_StepperControl.ino
+ For nRF52-based boards usinghardware-based PWM with Adafruit_nRF52_Arduino core
+ Written by Khoi Hoang
+
+ Built by Khoi Hoang https://github.com/khoih-prog/ContinuousStepper_Generic
+ Licensed under MIT license
+
+ Credits of Paul van Dinther (https://github.com/dinther). Check https://github.com/khoih-prog/RP2040_PWM/issues/16
+*****************************************************************************************************************************/
+
+// Use with Stepper-Motor driver, such as TMC2209
+
+#if !(defined(NRF52840_FEATHER) || defined(NRF52832_FEATHER) || defined(NRF52_SERIES) || defined(ARDUINO_NRF52_ADAFRUIT) || \
+ defined(NRF52840_FEATHER_SENSE) || defined(NRF52840_ITSYBITSY) || defined(NRF52840_CIRCUITPLAY) || \
+ defined(NRF52840_CLUE) || defined(NRF52840_METRO) || defined(NRF52840_PCA10056) || defined(PARTICLE_XENON) || \
+ defined(MDBT50Q_RX) || defined(NINA_B302_ublox) || defined(NINA_B112_ublox) )
+ #error This code is designed to run on nRF52-based platform! Please check your Tools->Board setting.
+#endif
+
+
+#define _PWM_LOGLEVEL_ 4
+
+// Select false to use PWM
+#define USING_TIMER false //true
+
+#include "ContinuousStepper_Generic.h"
+
+// OK for Feather_nRF52840_Express (5, 6, 9-13, 14-21/A0-A7, etc.)
+// OK for ItsyBitsy_nRF52840_Express (5, 7, 9-13, 14-20/A0-A6, etc.)
+
+#define STEP_PIN 5
+#define DIR_PIN 9
+
+nRF52_PWM* stepper;
+
+// The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+// For example, 28BYJ-48 Stepper Motor (https://lastminuteengineers.com/28byj48-stepper-motor-arduino-tutorial/) has 32 Steps/Rev
+// Speed = 640 Hz => Stepper RPM = (640 * 60 / 32) = 1200 RPM
+void setSpeed(int speed)
+{
+ if (speed == 0)
+ {
+ // Use DC = 0 to stop stepper
+ stepper->setPWM(STEP_PIN, 500, 0);
+ }
+ else
+ {
+ // Set the frequency of the PWM output and a duty cycle of 50%
+ digitalWrite(DIR_PIN, (speed < 0));
+ stepper->setPWM(STEP_PIN, abs(speed), 50);
+ }
+}
+
+void setup()
+{
+ pinMode(DIR_PIN, OUTPUT);
+
+ Serial.begin(115200);
+
+ while (!Serial && millis() < 5000);
+
+ delay(100);
+
+ Serial.print(F("\nStarting nRF52_PWM_StepperControl on "));
+ Serial.println(BOARD_NAME);
+ Serial.println(NRF52_PWM_VERSION);
+ Serial.println(CONTINUOUS_STEPPER_GENERIC_VERSION);
+
+ // Create PWM object and passed just a random frequency of 500
+ // The duty cycle is how you turn the motor on and off
+ stepper = new nRF52_PWM(STEP_PIN, 500, 0);
+}
+
+void loop()
+{
+ // The Stepper RPM will be ( speed * 60 ) / steps-per-rev
+ setSpeed(1000);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+
+ // Reversing
+ setSpeed(-500);
+ delay(3000);
+
+ // Stop before reversing
+ setSpeed(0);
+ delay(3000);
+}
diff --git a/library.json b/library.json
new file mode 100644
index 0000000..2442b92
--- /dev/null
+++ b/library.json
@@ -0,0 +1,117 @@
+{
+ "name": "ContinuousStepper_Generic",
+ "version": "1.0.0",
+ "keywords": "timing, device, control, timer, pwm, pwm-slice, hardware-based-pwm, high-frequency-pwm, hardware-pwm, mission-critical, accuracy, non-blocking, mbed, mbed-nano, mbed-rp2040, rpi-pico, rp2040, nano-rp2040-connect, duty-cycle, hardware",
+ "description": "This library enables you to use Hardware-based PWM channels on Generic boards to use PWM to control continuous Stepper Motor. The most important feature is they're purely hardware-based PWM channels, supporting very high PWM frequencies. Therefore, their executions are not blocked by bad-behaving functions or tasks. This important feature is absolutely necessary for mission-critical tasks. These hardware-based PWMs, still work even if other software functions are blocking. Moreover, they are much more precise (certainly depending on clock frequency accuracy) than other software-based PWM using ISR, millis() or micros(). That's necessary if you need to control devices requiring high precision",
+ "authors":
+ {
+ "name": "Khoi Hoang",
+ "url": "https://github.com/khoih-prog",
+ "maintainer": true
+ },
+ "repository":
+ {
+ "type": "git",
+ "url": "https://github.com/khoih-prog/ContinuousStepper_Generic"
+ },
+ "homepage": "https://github.com/khoih-prog/ContinuousStepper_Generic",
+ "export": {
+ "exclude": [
+ "linux",
+ "extras",
+ "tests"
+ ]
+ },
+ "dependencies":
+ [
+ {
+ "owner": "khoih-prog",
+ "name": "RP2040_PWM",
+ "version": "^1.4.1",
+ "platforms": ["raspberrypi"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "AVR_PWM",
+ "version": "^1.0.1",
+ "platforms": ["avr"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "megaAVR_PWM",
+ "version": "^1.0.1",
+ "platforms": ["megaavr"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "ESP32_FastPWM",
+ "version": "^1.0.1",
+ "platforms": ["espressif32"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "SAMD_PWM",
+ "version": "^1.0.1",
+ "platforms": ["samd"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "SAMDUE_PWM",
+ "version": "^1.0.1",
+ "platforms": ["atmelsam"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "nRF52_PWM",
+ "version": "^1.0.1",
+ "platforms": ["nordicnrf52", "nrf52"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "Teensy_PWM",
+ "version": "^1.1.1",
+ "platforms": ["avr"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "ATtiny_PWM",
+ "version": "^1.0.1",
+ "platforms": ["megaavr"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "Dx_PWM",
+ "version": "^1.1.1",
+ "platforms": ["megaavr"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "Portenta_H7_PWM",
+ "version": "^2.0.3",
+ "platforms": ["mbed_portenta"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "MBED_RP2040_PWM",
+ "version": "^1.0.1",
+ "platforms": ["mbed", "mbed_nano", "mbed_rp2040"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "nRF52_MBED_PWM",
+ "version": "^1.0.3",
+ "platforms": ["mbed", "nrf52"]
+ },
+ {
+ "owner": "khoih-prog",
+ "name": "STM32_PWM",
+ "version": "^1.0.1",
+ "platforms": ["ststm32"]
+ }
+ ],
+ "license": "MIT",
+ "frameworks": "*",
+ "platforms": "*",
+ "examples": "examples/*/*/*.ino",
+ "headers": ["ContinuousStepper_Generic.h"]
+}
diff --git a/library.properties b/library.properties
new file mode 100644
index 0000000..6dee0c3
--- /dev/null
+++ b/library.properties
@@ -0,0 +1,13 @@
+name=ContinuousStepper_Generic
+version=1.0.0
+author=Khoi Hoang