From 49dd0c0e3b197b01e67afbd86684031523206e0f Mon Sep 17 00:00:00 2001
From: Khoi Hoang <57012152+khoih-prog@users.noreply.github.com>
Date: Tue, 22 Nov 2022 18:29:19 -0500
Subject: [PATCH] Update `README.md` and use `allman` astyle
---
CONTRIBUTING.md | 25 +-
README.md | 33 +-
changelog.md | 11 +-
.../ISR_8_PWMs_Array/ISR_8_PWMs_Array.ino | 45 +-
.../ISR_8_PWMs_Array_Complex.ino | 71 ++-
.../ISR_8_PWMs_Array_Simple.ino | 39 +-
.../ISR_Changing_PWM/ISR_Changing_PWM.ino | 54 +-
examples/ISR_Modify_PWM/ISR_Modify_PWM.ino | 44 +-
.../multiFileProject/multiFileProject.cpp | 2 +-
examples/multiFileProject/multiFileProject.h | 6 +-
.../multiFileProject/multiFileProject.ino | 12 +-
src/Dx_Slow_PWM.h | 2 +-
src/Dx_Slow_PWM_ISR.h | 2 +-
src/Dx_Slow_PWM_ISR_Impl.h | 194 +++---
src/Dx_Slow_PWM_Impl.h | 551 +++++++++---------
src/PWM_Generic_Debug.h | 2 +-
utils/astyle_library.conf | 70 +++
utils/restyle.sh | 6 +
18 files changed, 675 insertions(+), 494 deletions(-)
create mode 100644 utils/astyle_library.conf
create mode 100644 utils/restyle.sh
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a4f3615..70ec599 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -15,7 +15,7 @@ If you don't find anything, please [open a new issue](https://github.com/khoih-p
Please ensure to specify the following:
* Arduino IDE version (e.g. 1.8.19) or Platform.io version
-* `DxCore` or `megaTinyCore` Core Version (e.g. Arduino DxCore core v1.4.10 or megaTinyCore core v2.5.11)
+* `DxCore` or `megaTinyCore` Core Version (e.g. Arduino DxCore core v1.4.10)
* Board (e.g. AVR128DA64, AVR128DB48, AVR64DB32, etc.)
* Contextual information (e.g. what you were trying to achieve)
* Simplest possible steps to reproduce
@@ -31,10 +31,10 @@ Arduino IDE version: 1.8.19
Arduino DxCore core v1.4.10
OS: Ubuntu 20.04 LTS
Board: Curiosity AVR128DB48
-Linux xy-Inspiron-3593 5.15.0-46-generic #49~20.04.1-Ubuntu SMP Thu Aug 4 19:15:44 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux
+Linux xy-Inspiron-3593 5.15.0-53-generic #59~20.04.1-Ubuntu SMP Thu Oct 20 15:10:22 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux
Context:
-I encountered a crash while trying to use the Timer Interrupt.
+I encountered a crash while using this library
Steps to reproduce:
1. ...
@@ -42,14 +42,33 @@ Steps to reproduce:
3. ...
4. ...
```
+
+---
+
### Sending Feature Requests
Feel free to post feature requests. It's helpful if you can explain exactly why the feature would be useful.
There are usually some outstanding feature requests in the [existing issues list](https://github.com/khoih-prog/Dx_Slow_PWM/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement), feel free to add comments to them.
+---
+
### Sending Pull Requests
Pull Requests with changes and fixes are also welcome!
+Please use the `astyle` to reformat the updated library code as follows (demo for Ubuntu Linux)
+
+1. Change directory to the library GitHub
+
+```
+xy@xy-Inspiron-3593:~$ cd Arduino/xy/Dx_Slow_PWM_GitHub/
+xy@xy-Inspiron-3593:~/Arduino/xy/Dx_Slow_PWM_GitHub$
+```
+
+2. Issue astyle command
+
+```
+xy@xy-Inspiron-3593:~/Arduino/xy/Dx_Slow_PWM_GitHub$ bash utils/restyle.sh
+```
diff --git a/README.md b/README.md
index f42a820..c7d322b 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,11 @@
[](#Contributing)
[](http://github.com/khoih-prog/Dx_Slow_PWM/issues)
+
+
+
---
@@ -98,7 +101,7 @@ For example, to run [Change_Interval example](https://github.com/khoih-prog/Dx_T
- 
+ 
@@ -106,7 +109,7 @@ After drag-and-drop the `Change_Interval.ino.hex` into `CURIOSITY` virtual drive
- 
+ 
@@ -165,14 +168,14 @@ The catch is **your function is now part of an ISR (Interrupt Service Routine),
- **AVRDA-based boards (AVR128DA, AVR64DA, AVR32DA, etc.) using DxCore**
- 
+ 
- **AVRDB-based boards (AVR128DB, AVR64DB, AVR32DB, etc.) using DxCore**
- 
+ 
@@ -183,7 +186,7 @@ The catch is **your function is now part of an ISR (Interrupt Service Routine),
- **tinyAVR boards using megaTinyCore**
- 
+ 
---
@@ -245,14 +248,14 @@ The current library implementation, using `xyz-Impl.h` instead of standard `xyz.
You can include this `.hpp` file
-```
+```cpp
// Can be included as many times as necessary, without `Multiple Definitions` Linker Error
#include "Dx_Slow_PWM.hpp" //https://github.com/khoih-prog/Dx_Slow_PWM
```
in many files. But be sure to use the following `.h` file **in just 1 `.h`, `.cpp` or `.ino` file**, which must **not be included in any other file**, to avoid `Multiple Definitions` Linker Error
-```
+```cpp
// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
#include "Dx_Slow_PWM.h" //https://github.com/khoih-prog/Dx_Slow_PWM
```
@@ -299,7 +302,7 @@ Before using any Timer, you have to make sure the Timer has not been used by any
#### 1. Init Hardware Timer
-```
+```cpp
// Select USING_FULL_CLOCK == true for 24/16MHz to Timer TCBx => shorter timer, but better accuracy
// Select USING_HALF_CLOCK == true for 12/ 8MHz to Timer TCBx => shorter timer, but better accuracy
// Select USING_250KHZ == true for 250KHz to Timer TCBx => longer timer, but worse accuracy
@@ -334,7 +337,7 @@ Dx_Slow_PWM ISR_PWM;
#### 2. Set PWM Frequency, dutycycle, attach irqCallbackStartFunc and irqCallbackStopFunc functions
-```
+```cpp
void irqCallbackStartFunc()
{
@@ -387,7 +390,7 @@ https://github.com/khoih-prog/Dx_Slow_PWM/blob/a4f6824724484cd522fc9c98fac4cd5c6
The following is the sample terminal output when running example [ISR_8_PWMs_Array_Complex](examples/ISR_8_PWMs_Array_Complex) **Curiosity Nano AVR128DB48** to demonstrate how to use multiple PWM channels with complex callback functions, the accuracy of ISR Hardware PWM-channels, **especially when system is very busy**. The ISR PWM-channels is **running exactly according to corresponding programmed periods and duty-cycles**
-```
+```cpp
Starting ISR_8_PWMs_Array_Complex on AVR128DB
Dx_Slow_PWM v1.0.2
CPU Frequency = 24 MHz
@@ -429,7 +432,7 @@ PWM Channel : 7, prog Period (ms): 125.00, actual : 125028, prog DutyCycle : 55,
The following is the sample terminal output when running example [**ISR_8_PWMs_Array**](examples/ISR_8_PWMs_Array) on **AVR128DB** to demonstrate how to use multiple PWM channels with simple callback functions.
-```
+```cpp
Starting ISR_8_PWMs_Array on AVR128DB
Dx_Slow_PWM v1.0.2
CPU Frequency = 24 MHz
@@ -443,7 +446,7 @@ Starting ITimer1 OK, micros() = 12894
The following is the sample terminal output when running example [**ISR_8_PWMs_Array_Simple**](examples/ISR_8_PWMs_Array_Simple) on **AVR128DB** to demonstrate how to use multiple PWM channels.
-```
+```cpp
Starting ISR_8_PWMs_Array_Simple on AVR128DB
Dx_Slow_PWM v1.0.2
CPU Frequency = 24 MHz
@@ -457,7 +460,7 @@ Starting ITimer1 OK, micros() = 14169
The following is the sample terminal output when running example [ISR_Modify_PWM](examples/ISR_Modify_PWM) on **AVR128DB** to demonstrate how to modify PWM settings on-the-fly without deleting the PWM channel
-```
+```cpp
Starting ISR_Modify_PWM on AVR128DB
Dx_Slow_PWM v1.0.2
CPU Frequency = 24 MHz
@@ -472,7 +475,7 @@ Using PWM Freq = 2.00, PWM DutyCycle = 10.00
The following is the sample terminal output when running example [ISR_Changing_PWM](examples/ISR_Changing_PWM) on **AVR128DB** to demonstrate how to modify PWM settings on-the-fly by deleting the PWM channel and reinit the PWM channel
-```
+```cpp
Starting ISR_Changing_PWM on AVR128DB
Dx_Slow_PWM v1.0.2
CPU Frequency = 24 MHz
@@ -582,6 +585,6 @@ If you want to contribute to this project:
## Copyright
-Copyright 2022- Khoi Hoang
+Copyright (c) 2022- Khoi Hoang
diff --git a/changelog.md b/changelog.md
index d50f716..bff5714 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,4 +1,4 @@
-## Dx_Slow_PWM Library
+## Library
[](https://www.ardu-badge.com/Dx_Slow_PWM)
[](https://github.com/khoih-prog/Dx_Slow_PWM/releases)
@@ -6,6 +6,15 @@
[](#Contributing)
[](http://github.com/khoih-prog/Dx_Slow_PWM/issues)
+
+
+
+
+
+
+---
+---
+
## Table of Contents
* [Changelog](#changelog)
diff --git a/examples/ISR_8_PWMs_Array/ISR_8_PWMs_Array.ino b/examples/ISR_8_PWMs_Array/ISR_8_PWMs_Array.ino
index ccb34dc..c4fc786 100644
--- a/examples/ISR_8_PWMs_Array/ISR_8_PWMs_Array.ino
+++ b/examples/ISR_8_PWMs_Array/ISR_8_PWMs_Array.ino
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -25,9 +25,9 @@
// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
#define _PWM_LOGLEVEL_ 1
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -64,7 +64,7 @@
#elif USE_TIMER_4
#define CurrentTimer ITimer4
#else
- #error You must select one Timer
+ #error You must select one Timer
#endif
#define USING_MICROS_RESOLUTION true //false
@@ -83,9 +83,9 @@
// To modify according to your board
// For Curiosity Nano AVR128DA48 => PIN_PC6
// For Curiosity Nano AVR128DB48 => PIN_PB3
- #if defined(__AVR_AVR128DA48__)
+ #if defined(__AVR_AVR128DA48__)
#define LED_BUILTIN PIN_PC6 // PIN_PB3, 13
- #elif defined(__AVR_AVR128DB48__)
+ #elif defined(__AVR_AVR128DB48__)
#define LED_BUILTIN PIN_PB3 // PIN_PC6, 13
#else
// standard Arduino pin 13
@@ -107,7 +107,7 @@ DX_SLOW_PWM_ISR ISR_PWM;
//////////////////////////////////////////////////////
void TimerHandler()
-{
+{
ISR_PWM.run();
}
@@ -184,27 +184,32 @@ void doingSomething7()
irqCallback irqCallbackStartFunc[] =
{
- doingSomething0, doingSomething1, doingSomething2, doingSomething3,
+ doingSomething0, doingSomething1, doingSomething2, doingSomething3,
doingSomething4, doingSomething5, doingSomething6, doingSomething7
};
////////////////////////////////////////////////
void setup()
-{
+{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting ISR_8_PWMs_Array on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting ISR_8_PWMs_Array on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
- SerialDebug.print(F("CPU Frequency = ")); SerialDebug.print(F_CPU / 1000000); SerialDebug.println(F(" MHz"));
- SerialDebug.print(F("Max number PWM channels = ")); SerialDebug.println(MAX_NUMBER_CHANNELS);
+ SerialDebug.print(F("CPU Frequency = "));
+ SerialDebug.print(F_CPU / 1000000);
+ SerialDebug.println(F(" MHz"));
+ SerialDebug.print(F("Max number PWM channels = "));
+ SerialDebug.println(MAX_NUMBER_CHANNELS);
- SerialDebug.print(F("TCB Clock Frequency = "));
+ SerialDebug.print(F("TCB Clock Frequency = "));
-#if USING_FULL_CLOCK
+#if USING_FULL_CLOCK
SerialDebug.println(F("Full clock (24/16MHz, etc) for highest accuracy"));
-#elif USING_HALF_CLOCK
+#elif USING_HALF_CLOCK
SerialDebug.println(F("Half clock (12/8MHz, etc.) for high accuracy"));
#else
SerialDebug.println(F("250KHz for lower accuracy but longer time"));
@@ -216,24 +221,26 @@ void setup()
if (CurrentTimer.attachInterruptInterval(HW_TIMER_INTERVAL_MS, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
-
+
#else
CurrentTimer.init();
if (CurrentTimer.attachInterrupt(HW_TIMER_INTERVAL_FREQ, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
#endif // USING_HW_TIMER_INTERVAL_MS
-
+
// Just to demonstrate, don't use too many ISR Timers if not absolutely necessary
// You can use up to 16 timer for each ISR_PWM
diff --git a/examples/ISR_8_PWMs_Array_Complex/ISR_8_PWMs_Array_Complex.ino b/examples/ISR_8_PWMs_Array_Complex/ISR_8_PWMs_Array_Complex.ino
index fdfa81e..941721d 100644
--- a/examples/ISR_8_PWMs_Array_Complex/ISR_8_PWMs_Array_Complex.ino
+++ b/examples/ISR_8_PWMs_Array_Complex/ISR_8_PWMs_Array_Complex.ino
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -25,9 +25,9 @@
// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
#define _PWM_LOGLEVEL_ 1
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -64,7 +64,7 @@
#elif USE_TIMER_4
#define CurrentTimer ITimer4
#else
- #error You must select one Timer
+ #error You must select one Timer
#endif
#define USING_MICROS_RESOLUTION true //false
@@ -83,9 +83,9 @@
// To modify according to your board
// For Curiosity Nano AVR128DA48 => PIN_PC6
// For Curiosity Nano AVR128DB48 => PIN_PB3
- #if defined(__AVR_AVR128DA48__)
+ #if defined(__AVR_AVR128DA48__)
#define LED_BUILTIN PIN_PC6 // PIN_PB3, 13
- #elif defined(__AVR_AVR128DB48__)
+ #elif defined(__AVR_AVR128DB48__)
#define LED_BUILTIN PIN_PB3 // PIN_PC6, 13
#else
// standard Arduino pin 13
@@ -93,9 +93,9 @@
#endif
#endif
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -377,42 +377,52 @@ void simpleTimerDoingSomething2s()
unsigned long currMicros = micros();
- SerialDebug.print(F("SimpleTimer (us): ")); SerialDebug.print(SIMPLE_TIMER_MS);
- SerialDebug.print(F(", us : ")); SerialDebug.print(currMicros);
- SerialDebug.print(F(", Dus : ")); SerialDebug.println(currMicros - previousMicrosStart);
+ SerialDebug.print(F("SimpleTimer (us): "));
+ SerialDebug.print(SIMPLE_TIMER_MS);
+ SerialDebug.print(F(", us : "));
+ SerialDebug.print(currMicros);
+ SerialDebug.print(F(", Dus : "));
+ SerialDebug.println(currMicros - previousMicrosStart);
for (uint16_t i = 0; i < NUMBER_ISR_PWMS; i++)
{
#if USE_COMPLEX_STRUCT
- SerialDebug.print(F("PWM Channel : ")); SerialDebug.print(i);
+ SerialDebug.print(F("PWM Channel : "));
+ SerialDebug.print(i);
SerialDebug.print(F(", prog Period (ms): "));
SerialDebug.print(1000.f / curISR_PWM_Data[i].PWM_Freq);
- SerialDebug.print(F(", actual : ")); SerialDebug.print((uint32_t) curISR_PWM_Data[i].deltaMicrosStart);
+ SerialDebug.print(F(", actual : "));
+ SerialDebug.print((uint32_t) curISR_PWM_Data[i].deltaMicrosStart);
SerialDebug.print(F(", prog DutyCycle : "));
SerialDebug.print(curISR_PWM_Data[i].PWM_DutyCycle);
- SerialDebug.print(F(", actual : ")); SerialDebug.println((float) curISR_PWM_Data[i].deltaMicrosStop * 100.0f / curISR_PWM_Data[i].deltaMicrosStart);
+ SerialDebug.print(F(", actual : "));
+ SerialDebug.println((float) curISR_PWM_Data[i].deltaMicrosStop * 100.0f / curISR_PWM_Data[i].deltaMicrosStart);
//SerialDebug.print(F(", actual deltaMicrosStop : ")); SerialDebug.println(curISR_PWM_Data[i].deltaMicrosStop);
//SerialDebug.print(F(", actual deltaMicrosStart : ")); SerialDebug.println(curISR_PWM_Data[i].deltaMicrosStart);
#else
- SerialDebug.print(F("PWM Channel : ")); SerialDebug.print(i);
+ SerialDebug.print(F("PWM Channel : "));
+ SerialDebug.print(i);
SerialDebug.print(1000 / PWM_Freq[i]);
- SerialDebug.print(F(", prog. Period (us): ")); SerialDebug.print(PWM_Period[i]);
- SerialDebug.print(F(", actual : ")); SerialDebug.print(deltaMicrosStart[i]);
+ SerialDebug.print(F(", prog. Period (us): "));
+ SerialDebug.print(PWM_Period[i]);
+ SerialDebug.print(F(", actual : "));
+ SerialDebug.print(deltaMicrosStart[i]);
SerialDebug.print(F(", prog DutyCycle : "));
SerialDebug.print(PWM_DutyCycle[i]);
- SerialDebug.print(F(", actual : ")); SerialDebug.println( (float) deltaMicrosStop[i] * 100.0f / deltaMicrosStart[i]);
+ SerialDebug.print(F(", actual : "));
+ SerialDebug.println( (float) deltaMicrosStop[i] * 100.0f / deltaMicrosStart[i]);
//SerialDebug.print(F(", actual deltaMicrosStop : ")); SerialDebug.println(deltaMicrosStop[i]);
//SerialDebug.print(F(", actual deltaMicrosStart : ")); SerialDebug.println(deltaMicrosStart[i]);
#endif
@@ -424,18 +434,23 @@ void simpleTimerDoingSomething2s()
void setup()
{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting ISR_8_PWMs_Array_Complex on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting ISR_8_PWMs_Array_Complex on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
- SerialDebug.print(F("CPU Frequency = ")); SerialDebug.print(F_CPU / 1000000); SerialDebug.println(F(" MHz"));
- SerialDebug.print(F("Max number PWM channels = ")); SerialDebug.println(MAX_NUMBER_CHANNELS);
+ SerialDebug.print(F("CPU Frequency = "));
+ SerialDebug.print(F_CPU / 1000000);
+ SerialDebug.println(F(" MHz"));
+ SerialDebug.print(F("Max number PWM channels = "));
+ SerialDebug.println(MAX_NUMBER_CHANNELS);
- SerialDebug.print(F("TCB Clock Frequency = "));
+ SerialDebug.print(F("TCB Clock Frequency = "));
-#if USING_FULL_CLOCK
+#if USING_FULL_CLOCK
SerialDebug.println(F("Full clock (24/16MHz, etc) for highest accuracy"));
-#elif USING_HALF_CLOCK
+#elif USING_HALF_CLOCK
SerialDebug.println(F("Half clock (12/8MHz, etc.) for high accuracy"));
#else
SerialDebug.println(F("250KHz for lower accuracy but longer time"));
@@ -447,18 +462,20 @@ void setup()
if (CurrentTimer.attachInterruptInterval(HW_TIMER_INTERVAL_MS, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
-
+
#else
CurrentTimer.init();
if (CurrentTimer.attachInterrupt(HW_TIMER_INTERVAL_FREQ, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
diff --git a/examples/ISR_8_PWMs_Array_Simple/ISR_8_PWMs_Array_Simple.ino b/examples/ISR_8_PWMs_Array_Simple/ISR_8_PWMs_Array_Simple.ino
index 183a701..03e3f2b 100644
--- a/examples/ISR_8_PWMs_Array_Simple/ISR_8_PWMs_Array_Simple.ino
+++ b/examples/ISR_8_PWMs_Array_Simple/ISR_8_PWMs_Array_Simple.ino
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -25,9 +25,9 @@
// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
#define _PWM_LOGLEVEL_ 1
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -64,7 +64,7 @@
#elif USE_TIMER_4
#define CurrentTimer ITimer4
#else
- #error You must select one Timer
+ #error You must select one Timer
#endif
#define USING_MICROS_RESOLUTION true //false
@@ -81,9 +81,9 @@
// To modify according to your board
// For Curiosity Nano AVR128DA48 => PIN_PC6
// For Curiosity Nano AVR128DB48 => PIN_PB3
- #if defined(__AVR_AVR128DA48__)
+ #if defined(__AVR_AVR128DA48__)
#define LED_BUILTIN PIN_PC6 // PIN_PB3, 13
- #elif defined(__AVR_AVR128DB48__)
+ #elif defined(__AVR_AVR128DB48__)
#define LED_BUILTIN PIN_PB3 // PIN_PC6, 13
#else
// standard Arduino pin 13
@@ -105,7 +105,7 @@ DX_SLOW_PWM_ISR ISR_PWM;
//////////////////////////////////////////////////////
void TimerHandler()
-{
+{
ISR_PWM.run();
}
@@ -146,18 +146,23 @@ float PWM_DutyCycle[] =
void setup()
{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting ISR_8_PWMs_Array_Simple on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting ISR_8_PWMs_Array_Simple on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
- SerialDebug.print(F("CPU Frequency = ")); SerialDebug.print(F_CPU / 1000000); SerialDebug.println(F(" MHz"));
- SerialDebug.print(F("Max number PWM channels = ")); SerialDebug.println(MAX_NUMBER_CHANNELS);
+ SerialDebug.print(F("CPU Frequency = "));
+ SerialDebug.print(F_CPU / 1000000);
+ SerialDebug.println(F(" MHz"));
+ SerialDebug.print(F("Max number PWM channels = "));
+ SerialDebug.println(MAX_NUMBER_CHANNELS);
- SerialDebug.print(F("TCB Clock Frequency = "));
+ SerialDebug.print(F("TCB Clock Frequency = "));
-#if USING_FULL_CLOCK
+#if USING_FULL_CLOCK
SerialDebug.println(F("Full clock (24/16MHz, etc) for highest accuracy"));
-#elif USING_HALF_CLOCK
+#elif USING_HALF_CLOCK
SerialDebug.println(F("Half clock (12/8MHz, etc.) for high accuracy"));
#else
SerialDebug.println(F("250KHz for lower accuracy but longer time"));
@@ -169,18 +174,20 @@ void setup()
if (CurrentTimer.attachInterruptInterval(HW_TIMER_INTERVAL_MS, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
-
+
#else
CurrentTimer.init();
if (CurrentTimer.attachInterrupt(HW_TIMER_INTERVAL_FREQ, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
diff --git a/examples/ISR_Changing_PWM/ISR_Changing_PWM.ino b/examples/ISR_Changing_PWM/ISR_Changing_PWM.ino
index bb76dc2..a9c006c 100644
--- a/examples/ISR_Changing_PWM/ISR_Changing_PWM.ino
+++ b/examples/ISR_Changing_PWM/ISR_Changing_PWM.ino
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -25,9 +25,9 @@
// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
#define _PWM_LOGLEVEL_ 1
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -64,7 +64,7 @@
#elif USE_TIMER_4
#define CurrentTimer ITimer4
#else
- #error You must select one Timer
+ #error You must select one Timer
#endif
#define USING_MICROS_RESOLUTION true //false
@@ -81,9 +81,9 @@
// To modify according to your board
// For Curiosity Nano AVR128DA48 => PIN_PC6
// For Curiosity Nano AVR128DB48 => PIN_PB3
- #if defined(__AVR_AVR128DA48__)
+ #if defined(__AVR_AVR128DA48__)
#define LED_BUILTIN PIN_PC6 // PIN_PB3, 13
- #elif defined(__AVR_AVR128DB48__)
+ #elif defined(__AVR_AVR128DB48__)
#define LED_BUILTIN PIN_PB3 // PIN_PC6, 13
#else
// standard Arduino pin 13
@@ -105,7 +105,7 @@ DX_SLOW_PWM_ISR ISR_PWM;
//////////////////////////////////////////////////////
void TimerHandler()
-{
+{
ISR_PWM.run();
}
@@ -119,9 +119,9 @@ void TimerHandler()
uint32_t PWM_Pin = LED_BUILTIN;
// You can assign any interval for any timer here, in Hz
-float PWM_Freq1 = 1.0f;
+float PWM_Freq1 = 10.0f;
// You can assign any interval for any timer here, in Hz
-float PWM_Freq2 = 2.0f;
+float PWM_Freq2 = 20.0f;
// You can assign any interval for any timer here, in microseconds
uint32_t PWM_Period1 = 1000000 / PWM_Freq1;
@@ -141,18 +141,23 @@ int channelNum;
void setup()
{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting ISR_Changing_PWM on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting ISR_Changing_PWM on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
- SerialDebug.print(F("CPU Frequency = ")); SerialDebug.print(F_CPU / 1000000); SerialDebug.println(F(" MHz"));
- SerialDebug.print(F("Max number PWM channels = ")); SerialDebug.println(MAX_NUMBER_CHANNELS);
+ SerialDebug.print(F("CPU Frequency = "));
+ SerialDebug.print(F_CPU / 1000000);
+ SerialDebug.println(F(" MHz"));
+ SerialDebug.print(F("Max number PWM channels = "));
+ SerialDebug.println(MAX_NUMBER_CHANNELS);
- SerialDebug.print(F("TCB Clock Frequency = "));
+ SerialDebug.print(F("TCB Clock Frequency = "));
-#if USING_FULL_CLOCK
+#if USING_FULL_CLOCK
SerialDebug.println(F("Full clock (24/16MHz, etc) for highest accuracy"));
-#elif USING_HALF_CLOCK
+#elif USING_HALF_CLOCK
SerialDebug.println(F("Half clock (12/8MHz, etc.) for high accuracy"));
#else
SerialDebug.println(F("250KHz for lower accuracy but longer time"));
@@ -164,18 +169,20 @@ void setup()
if (CurrentTimer.attachInterruptInterval(HW_TIMER_INTERVAL_MS, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
-
+
#else
CurrentTimer.init();
if (CurrentTimer.attachInterrupt(HW_TIMER_INTERVAL_FREQ, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
@@ -185,8 +192,10 @@ void setup()
void loop()
{
- SerialDebug.print(F("Using PWM Freq = ")); SerialDebug.print(PWM_Freq1);
- SerialDebug.print(F(", PWM DutyCycle = ")); SerialDebug.println(PWM_DutyCycle1);
+ SerialDebug.print(F("Using PWM Freq = "));
+ SerialDebug.print(PWM_Freq1);
+ SerialDebug.print(F(", PWM DutyCycle = "));
+ SerialDebug.println(PWM_DutyCycle1);
#if USING_PWM_FREQUENCY
@@ -207,7 +216,10 @@ void loop()
ISR_PWM.deleteChannel((unsigned) channelNum);
- SerialDebug.print(F("Using PWM Freq = ")); SerialDebug.print(PWM_Freq2); SerialDebug.print(F(", PWM DutyCycle = ")); SerialDebug.println(PWM_DutyCycle2);
+ SerialDebug.print(F("Using PWM Freq = "));
+ SerialDebug.print(PWM_Freq2);
+ SerialDebug.print(F(", PWM DutyCycle = "));
+ SerialDebug.println(PWM_DutyCycle2);
#if USING_PWM_FREQUENCY
diff --git a/examples/ISR_Modify_PWM/ISR_Modify_PWM.ino b/examples/ISR_Modify_PWM/ISR_Modify_PWM.ino
index 41e5b06..f14f85a 100644
--- a/examples/ISR_Modify_PWM/ISR_Modify_PWM.ino
+++ b/examples/ISR_Modify_PWM/ISR_Modify_PWM.ino
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -25,9 +25,9 @@
// Don't define _PWM_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
#define _PWM_LOGLEVEL_ 1
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
@@ -64,7 +64,7 @@
#elif USE_TIMER_4
#define CurrentTimer ITimer4
#else
- #error You must select one Timer
+ #error You must select one Timer
#endif
#define USING_MICROS_RESOLUTION true //false
@@ -81,9 +81,9 @@
// To modify according to your board
// For Curiosity Nano AVR128DA48 => PIN_PC6
// For Curiosity Nano AVR128DB48 => PIN_PB3
- #if defined(__AVR_AVR128DA48__)
+ #if defined(__AVR_AVR128DA48__)
#define LED_BUILTIN PIN_PC6 // PIN_PB3, 13
- #elif defined(__AVR_AVR128DB48__)
+ #elif defined(__AVR_AVR128DB48__)
#define LED_BUILTIN PIN_PB3 // PIN_PC6, 13
#else
// standard Arduino pin 13
@@ -105,7 +105,7 @@ DX_SLOW_PWM_ISR ISR_PWM;
//////////////////////////////////////////////////////
void TimerHandler()
-{
+{
ISR_PWM.run();
}
@@ -141,18 +141,23 @@ int channelNum;
void setup()
{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting ISR_Modify_PWM on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting ISR_Modify_PWM on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
- SerialDebug.print(F("CPU Frequency = ")); SerialDebug.print(F_CPU / 1000000); SerialDebug.println(F(" MHz"));
- SerialDebug.print(F("Max number PWM channels = ")); SerialDebug.println(MAX_NUMBER_CHANNELS);
+ SerialDebug.print(F("CPU Frequency = "));
+ SerialDebug.print(F_CPU / 1000000);
+ SerialDebug.println(F(" MHz"));
+ SerialDebug.print(F("Max number PWM channels = "));
+ SerialDebug.println(MAX_NUMBER_CHANNELS);
- SerialDebug.print(F("TCB Clock Frequency = "));
+ SerialDebug.print(F("TCB Clock Frequency = "));
-#if USING_FULL_CLOCK
+#if USING_FULL_CLOCK
SerialDebug.println(F("Full clock (24/16MHz, etc) for highest accuracy"));
-#elif USING_HALF_CLOCK
+#elif USING_HALF_CLOCK
SerialDebug.println(F("Half clock (12/8MHz, etc.) for high accuracy"));
#else
SerialDebug.println(F("250KHz for lower accuracy but longer time"));
@@ -164,25 +169,30 @@ void setup()
if (CurrentTimer.attachInterruptInterval(HW_TIMER_INTERVAL_MS, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
-
+
#else
CurrentTimer.init();
if (CurrentTimer.attachInterrupt(HW_TIMER_INTERVAL_FREQ, TimerHandler))
{
- SerialDebug.print(F("Starting ITimer1 OK, micros() = ")); SerialDebug.println(micros());
+ SerialDebug.print(F("Starting ITimer1 OK, micros() = "));
+ SerialDebug.println(micros());
}
else
SerialDebug.println(F("Can't set CurrentTimer. Select another freq. or timer"));
#endif // USING_HW_TIMER_INTERVAL_MS
- SerialDebug.print(F("Using PWM Freq = ")); SerialDebug.print(PWM_Freq1); SerialDebug.print(F(", PWM DutyCycle = ")); SerialDebug.println(PWM_DutyCycle1);
+ SerialDebug.print(F("Using PWM Freq = "));
+ SerialDebug.print(PWM_Freq1);
+ SerialDebug.print(F(", PWM DutyCycle = "));
+ SerialDebug.println(PWM_DutyCycle1);
#if USING_PWM_FREQUENCY
diff --git a/examples/multiFileProject/multiFileProject.cpp b/examples/multiFileProject/multiFileProject.cpp
index cc82677..8a6afe5 100644
--- a/examples/multiFileProject/multiFileProject.cpp
+++ b/examples/multiFileProject/multiFileProject.cpp
@@ -1,6 +1,6 @@
/****************************************************************************************************************************
multiFileProject.cpp
-
+
For Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.) using DxCore
Written by Khoi Hoang
diff --git a/examples/multiFileProject/multiFileProject.h b/examples/multiFileProject/multiFileProject.h
index 6479e21..490f108 100644
--- a/examples/multiFileProject/multiFileProject.h
+++ b/examples/multiFileProject/multiFileProject.h
@@ -1,6 +1,6 @@
/****************************************************************************************************************************
multiFileProject.h
-
+
For Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.) using DxCore
Written by Khoi Hoang
@@ -12,9 +12,9 @@
#pragma once
-#if defined(__AVR_AVR128DA48__)
+#if defined(__AVR_AVR128DA48__)
#define SerialDebug Serial1
-#elif defined(__AVR_AVR128DB48__)
+#elif defined(__AVR_AVR128DB48__)
#define SerialDebug Serial3
#else
// standard Serial
diff --git a/examples/multiFileProject/multiFileProject.ino b/examples/multiFileProject/multiFileProject.ino
index b0c7b31..517e2b3 100644
--- a/examples/multiFileProject/multiFileProject.ino
+++ b/examples/multiFileProject/multiFileProject.ino
@@ -1,6 +1,6 @@
/****************************************************************************************************************************
multiFileProject.ino
-
+
For Arduino AVRDx-based boards (AVR128Dx, AVR64Dx, AVR32Dx, etc.) using DxCore
Written by Khoi Hoang
@@ -23,24 +23,28 @@
// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
#include "Dx_Slow_PWM.h"
-void setup()
+void setup()
{
SerialDebug.begin(115200);
+
while (!SerialDebug && millis() < 5000);
- SerialDebug.print(F("\nStarting multiFileProject on ")); SerialDebug.println(BOARD_NAME);
+ SerialDebug.print(F("\nStarting multiFileProject on "));
+ SerialDebug.println(BOARD_NAME);
SerialDebug.println(DX_SLOW_PWM_VERSION);
#if defined(DX_SLOW_PWM_VERSION_MIN)
+
if (DX_SLOW_PWM_VERSION_INT < DX_SLOW_PWM_VERSION_MIN)
{
SerialDebug.print("Warning. Must use this example on Version equal or later than : ");
SerialDebug.println(DX_SLOW_PWM_VERSION_MIN_TARGET);
}
+
#endif
}
-void loop()
+void loop()
{
// put your main code here, to run repeatedly:
}
diff --git a/src/Dx_Slow_PWM.h b/src/Dx_Slow_PWM.h
index b1ce9ac..4a40366 100644
--- a/src/Dx_Slow_PWM.h
+++ b/src/Dx_Slow_PWM.h
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
diff --git a/src/Dx_Slow_PWM_ISR.h b/src/Dx_Slow_PWM_ISR.h
index 694c268..6c76931 100644
--- a/src/Dx_Slow_PWM_ISR.h
+++ b/src/Dx_Slow_PWM_ISR.h
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
diff --git a/src/Dx_Slow_PWM_ISR_Impl.h b/src/Dx_Slow_PWM_ISR_Impl.h
index 046398d..08b9fda 100644
--- a/src/Dx_Slow_PWM_ISR_Impl.h
+++ b/src/Dx_Slow_PWM_ISR_Impl.h
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -28,19 +28,19 @@
#include
-///////////////////////////////////////////////////
+///////////////////////////////////////////////////
uint32_t timeNow()
{
-#if USING_MICROS_RESOLUTION
+#if USING_MICROS_RESOLUTION
return ( (uint32_t) micros() );
#else
return ( (uint32_t) millis() );
-#endif
+#endif
}
-
-///////////////////////////////////////////////////
+
+///////////////////////////////////////////////////
DX_SLOW_PWM_ISR::DX_SLOW_PWM_ISR()
: numChannels (-1)
@@ -49,42 +49,42 @@ DX_SLOW_PWM_ISR::DX_SLOW_PWM_ISR()
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::init()
+void DX_SLOW_PWM_ISR::init()
{
uint32_t currentTime = timeNow();
-
- for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
+
+ for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
{
memset((void*) &PWM[channelNum], 0, sizeof (PWM_t));
PWM[channelNum].prevTime = currentTime;
PWM[channelNum].pin = INVALID_MEGA_AVR_PIN;
}
-
+
numChannels = 0;
}
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::run()
-{
+void DX_SLOW_PWM_ISR::run()
+{
uint32_t currentTime = timeNow();
-
+
noInterrupts();
- for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
- {
+ for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
+ {
// If enabled => check
// start period / dutyCycle => digitalWrite HIGH
// end dutyCycle => digitalWrite LOW
- if (PWM[channelNum].enabled)
+ if (PWM[channelNum].enabled)
{
- if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) <= PWM[channelNum].onTime )
- {
+ if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) <= PWM[channelNum].onTime )
+ {
if (!PWM[channelNum].pinHigh)
{
digitalWrite(PWM[channelNum].pin, HIGH);
PWM[channelNum].pinHigh = true;
-
+
// callbackStart
if (PWM[channelNum].callbackStart != nullptr)
{
@@ -92,13 +92,13 @@ void DX_SLOW_PWM_ISR::run()
}
}
}
- else if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) < PWM[channelNum].period )
+ else if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) < PWM[channelNum].period )
{
if (PWM[channelNum].pinHigh)
{
digitalWrite(PWM[channelNum].pin, LOW);
PWM[channelNum].pinHigh = false;
-
+
// callback when PWM pulse stops (LOW)
if (PWM[channelNum].callbackStop != nullptr)
{
@@ -106,25 +106,27 @@ void DX_SLOW_PWM_ISR::run()
}
}
}
- //else
- else if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) >= PWM[channelNum].period )
+ //else
+ else if ( (uint32_t) (currentTime - PWM[channelNum].prevTime) >= PWM[channelNum].period )
{
PWM[channelNum].prevTime = currentTime;
-
+
#if CHANGING_PWM_END_OF_CYCLE
+
// Only update whenever having newPeriod
if (PWM[channelNum].newPeriod != 0)
{
PWM[channelNum].period = PWM[channelNum].newPeriod;
PWM[channelNum].newPeriod = 0;
-
+
PWM[channelNum].onTime = PWM[channelNum].newOnTime;
}
-#endif
- }
+
+#endif
+ }
}
}
-
+
interrupts();
}
@@ -133,16 +135,16 @@ void DX_SLOW_PWM_ISR::run()
// find the first available slot
// return -1 if none found
-int DX_SLOW_PWM_ISR::findFirstFreeSlot()
+int DX_SLOW_PWM_ISR::findFirstFreeSlot()
{
// all slots are used
- if (numChannels >= MAX_NUMBER_CHANNELS)
+ if (numChannels >= MAX_NUMBER_CHANNELS)
{
return -1;
}
// return the first slot with no callbackStart (i.e. free)
- for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
+ for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
{
if ( (PWM[channelNum].period == 0) && !PWM[channelNum].enabled )
{
@@ -156,10 +158,11 @@ int DX_SLOW_PWM_ISR::findFirstFreeSlot()
///////////////////////////////////////////////////
-int DX_SLOW_PWM_ISR::setupPWMChannel(const uint32_t& pin, const uint32_t& period, const float& dutycycle, void* cbStartFunc, void* cbStopFunc)
+int DX_SLOW_PWM_ISR::setupPWMChannel(const uint32_t& pin, const uint32_t& period, const float& dutycycle,
+ void* cbStartFunc, void* cbStopFunc)
{
int channelNum;
-
+
// Invalid input, such as period = 0, etc
if ( (period == 0) || (dutycycle < 0.0) || (dutycycle > 100.0) )
{
@@ -167,50 +170,55 @@ int DX_SLOW_PWM_ISR::setupPWMChannel(const uint32_t& pin, const uint32_t& period
return -1;
}
- if (numChannels < 0)
+ if (numChannels < 0)
{
init();
}
-
+
channelNum = findFirstFreeSlot();
-
- if (channelNum < 0)
+
+ if (channelNum < 0)
{
return -1;
}
PWM[channelNum].pin = pin;
PWM[channelNum].period = period;
-
+
// Must be 0 for new PWM channel
PWM[channelNum].newPeriod = 0;
-
+
PWM[channelNum].onTime = ( period * dutycycle ) / 100;
-
+
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
PWM[channelNum].pinHigh = true;
-
+
PWM[channelNum].prevTime = timeNow();
-
+
PWM[channelNum].callbackStart = cbStartFunc;
PWM[channelNum].callbackStop = cbStopFunc;
-
- PWM_LOGINFO0("Channel : "); PWM_LOGINFO0(channelNum);
- PWM_LOGINFO0("\t Period : "); PWM_LOGINFO0(PWM[channelNum].period);
- PWM_LOGINFO0("\t\tOnTime : "); PWM_LOGINFO0(PWM[channelNum].onTime);
- PWM_LOGINFO0("\tStart_Time : "); PWM_LOGINFOLN0(PWM[channelNum].prevTime);
-
+
+ PWM_LOGINFO0("Channel : ");
+ PWM_LOGINFO0(channelNum);
+ PWM_LOGINFO0("\t Period : ");
+ PWM_LOGINFO0(PWM[channelNum].period);
+ PWM_LOGINFO0("\t\tOnTime : ");
+ PWM_LOGINFO0(PWM[channelNum].onTime);
+ PWM_LOGINFO0("\tStart_Time : ");
+ PWM_LOGINFOLN0(PWM[channelNum].prevTime);
+
numChannels++;
-
+
PWM[channelNum].enabled = true;
-
+
return channelNum;
}
///////////////////////////////////////////////////
-bool DX_SLOW_PWM_ISR::modifyPWMChannel_Period(const uint8_t& channelNum, const uint32_t& pin, const uint32_t& period, const float& dutycycle)
+bool DX_SLOW_PWM_ISR::modifyPWMChannel_Period(const uint8_t& channelNum, const uint32_t& pin, const uint32_t& period,
+ const float& dutycycle)
{
// Invalid input, such as period = 0, etc
if ( (period == 0) || (dutycycle < 0.0) || (dutycycle > 100.0) )
@@ -219,54 +227,62 @@ bool DX_SLOW_PWM_ISR::modifyPWMChannel_Period(const uint8_t& channelNum, const u
return false;
}
- if (channelNum > MAX_NUMBER_CHANNELS)
+ if (channelNum > MAX_NUMBER_CHANNELS)
{
PWM_LOGERROR("Error: channelNum > MAX_NUMBER_CHANNELS");
return false;
}
-
- if (PWM[channelNum].pin != pin)
+
+ if (PWM[channelNum].pin != pin)
{
PWM_LOGERROR("Error: channelNum and pin mismatched");
return false;
}
-
+
#if CHANGING_PWM_END_OF_CYCLE
PWM[channelNum].newPeriod = period;
PWM[channelNum].newDutyCycle = dutycycle;
PWM[channelNum].newOnTime = ( period * dutycycle ) / 100;
-
- PWM_LOGINFO0("Channel : "); PWM_LOGINFO0(channelNum);
- PWM_LOGINFO0("\t Period : "); PWM_LOGINFO0(period);
- PWM_LOGINFO0("\t\tOnTime : "); PWM_LOGINFO0(PWM[channelNum].newOnTime);
- PWM_LOGINFO0("\tStart_Time : "); PWM_LOGINFOLN0(PWM[channelNum].prevTime);
-
+
+ PWM_LOGINFO0("Channel : ");
+ PWM_LOGINFO0(channelNum);
+ PWM_LOGINFO0("\t Period : ");
+ PWM_LOGINFO0(period);
+ PWM_LOGINFO0("\t\tOnTime : ");
+ PWM_LOGINFO0(PWM[channelNum].newOnTime);
+ PWM_LOGINFO0("\tStart_Time : ");
+ PWM_LOGINFOLN0(PWM[channelNum].prevTime);
+
#else
- PWM[channelNum].period = period;
+ PWM[channelNum].period = period;
PWM[channelNum].onTime = ( period * dutycycle ) / 100;
-
+
digitalWrite(pin, HIGH);
PWM[channelNum].pinHigh = true;
-
+
PWM[channelNum].prevTime = timeNow();
-
- PWM_LOGINFO0("Channel : "); PWM_LOGINFO0(channelNum);
- PWM_LOGINFO0("\t Period : "); PWM_LOGINFO0(PWM[channelNum].period);
- PWM_LOGINFO0("\t\tOnTime : "); PWM_LOGINFO0(PWM[channelNum].onTime);
- PWM_LOGINFO0("\tStart_Time : "); PWM_LOGINFOLN0(PWM[channelNum].prevTime);
-
+
+ PWM_LOGINFO0("Channel : ");
+ PWM_LOGINFO0(channelNum);
+ PWM_LOGINFO0("\t Period : ");
+ PWM_LOGINFO0(PWM[channelNum].period);
+ PWM_LOGINFO0("\t\tOnTime : ");
+ PWM_LOGINFO0(PWM[channelNum].onTime);
+ PWM_LOGINFO0("\tStart_Time : ");
+ PWM_LOGINFOLN0(PWM[channelNum].prevTime);
+
#endif
-
+
return true;
}
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::deleteChannel(const uint8_t& channelNum)
+void DX_SLOW_PWM_ISR::deleteChannel(const uint8_t& channelNum)
{
// nothing to delete if no timers are in use
if ( (channelNum >= MAX_NUMBER_CHANNELS) || (numChannels == 0) )
@@ -278,9 +294,9 @@ void DX_SLOW_PWM_ISR::deleteChannel(const uint8_t& channelNum)
if ( (PWM[channelNum].pin != INVALID_MEGA_AVR_PIN) && (PWM[channelNum].period != 0) )
{
memset((void*) &PWM[channelNum], 0, sizeof (PWM_t));
-
+
PWM[channelNum].pin = INVALID_MEGA_AVR_PIN;
-
+
// update number of timers
numChannels--;
}
@@ -288,9 +304,9 @@ void DX_SLOW_PWM_ISR::deleteChannel(const uint8_t& channelNum)
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::restartChannel(const uint8_t& channelNum)
+void DX_SLOW_PWM_ISR::restartChannel(const uint8_t& channelNum)
{
- if (channelNum >= MAX_NUMBER_CHANNELS)
+ if (channelNum >= MAX_NUMBER_CHANNELS)
{
return;
}
@@ -300,9 +316,9 @@ void DX_SLOW_PWM_ISR::restartChannel(const uint8_t& channelNum)
///////////////////////////////////////////////////
-bool DX_SLOW_PWM_ISR::isEnabled(const uint8_t& channelNum)
+bool DX_SLOW_PWM_ISR::isEnabled(const uint8_t& channelNum)
{
- if (channelNum >= MAX_NUMBER_CHANNELS)
+ if (channelNum >= MAX_NUMBER_CHANNELS)
{
return false;
}
@@ -312,9 +328,9 @@ bool DX_SLOW_PWM_ISR::isEnabled(const uint8_t& channelNum)
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::enable(const uint8_t& channelNum)
+void DX_SLOW_PWM_ISR::enable(const uint8_t& channelNum)
{
- if (channelNum >= MAX_NUMBER_CHANNELS)
+ if (channelNum >= MAX_NUMBER_CHANNELS)
{
return;
}
@@ -324,9 +340,9 @@ void DX_SLOW_PWM_ISR::enable(const uint8_t& channelNum)
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::disable(const uint8_t& channelNum)
+void DX_SLOW_PWM_ISR::disable(const uint8_t& channelNum)
{
- if (channelNum >= MAX_NUMBER_CHANNELS)
+ if (channelNum >= MAX_NUMBER_CHANNELS)
{
return;
}
@@ -336,11 +352,11 @@ void DX_SLOW_PWM_ISR::disable(const uint8_t& channelNum)
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::enableAll()
+void DX_SLOW_PWM_ISR::enableAll()
{
// Enable all timers with a callbackStart assigned (used)
- for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
+ for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
{
if (PWM[channelNum].period != 0)
{
@@ -351,10 +367,10 @@ void DX_SLOW_PWM_ISR::enableAll()
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::disableAll()
+void DX_SLOW_PWM_ISR::disableAll()
{
// Disable all timers with a callbackStart assigned (used)
- for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
+ for (uint8_t channelNum = 0; channelNum < MAX_NUMBER_CHANNELS; channelNum++)
{
if (PWM[channelNum].period != 0)
{
@@ -365,9 +381,9 @@ void DX_SLOW_PWM_ISR::disableAll()
///////////////////////////////////////////////////
-void DX_SLOW_PWM_ISR::toggle(const uint8_t& channelNum)
+void DX_SLOW_PWM_ISR::toggle(const uint8_t& channelNum)
{
- if (channelNum >= MAX_NUMBER_CHANNELS)
+ if (channelNum >= MAX_NUMBER_CHANNELS)
{
return;
}
@@ -377,7 +393,7 @@ void DX_SLOW_PWM_ISR::toggle(const uint8_t& channelNum)
///////////////////////////////////////////////////
-int8_t DX_SLOW_PWM_ISR::getnumChannels()
+int8_t DX_SLOW_PWM_ISR::getnumChannels()
{
return numChannels;
}
diff --git a/src/Dx_Slow_PWM_Impl.h b/src/Dx_Slow_PWM_Impl.h
index ff19944..cbf2685 100644
--- a/src/Dx_Slow_PWM_Impl.h
+++ b/src/Dx_Slow_PWM_Impl.h
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
@@ -34,24 +34,24 @@
/*****************************************************************************************
-// From ~/.arduino15/packages/arduino/7.3.0-atmel3.6.1-arduino5/avr/include/avr/iom4809.h
+ // From ~/.arduino15/packages/arduino/7.3.0-atmel3.6.1-arduino5/avr/include/avr/iom4809.h
-//#define TCB0 (*(TCB_t *) 0x0A80) // 16-bit Timer Type B
-//#define TCB1 (*(TCB_t *) 0x0A90) // 16-bit Timer Type B
-//#define TCB2 (*(TCB_t *) 0x0AA0) // 16-bit Timer Type B
-//#define TCB3 (*(TCB_t *) 0x0AB0) // 16-bit Timer Type B
+ //#define TCB0 (*(TCB_t *) 0x0A80) // 16-bit Timer Type B
+ //#define TCB1 (*(TCB_t *) 0x0A90) // 16-bit Timer Type B
+ //#define TCB2 (*(TCB_t *) 0x0AA0) // 16-bit Timer Type B
+ //#define TCB3 (*(TCB_t *) 0x0AB0) // 16-bit Timer Type B
-//
-typedef enum TCB_CLKSEL_enum
-{
+ //
+ typedef enum TCB_CLKSEL_enum
+ {
TCB_CLKSEL_CLKDIV1_gc = (0x00<<1), // CLK_PER (No Prescaling)
TCB_CLKSEL_CLKDIV2_gc = (0x01<<1), // CLK_PER/2 (From Prescaler)
TCB_CLKSEL_CLKTCA_gc = (0x02<<1), // Use Clock from TCA
-} TCB_CLKSEL_t;
+ } TCB_CLKSEL_t;
-//
-typedef enum TCB_CNTMODE_enum
-{
+ //
+ typedef enum TCB_CNTMODE_enum
+ {
TCB_CNTMODE_INT_gc = (0x00<<0), // Periodic Interrupt
TCB_CNTMODE_TIMEOUT_gc = (0x01<<0), // Periodic Timeout
TCB_CNTMODE_CAPT_gc = (0x02<<0), // Input Capture Event
@@ -60,47 +60,47 @@ typedef enum TCB_CNTMODE_enum
TCB_CNTMODE_FRQPW_gc = (0x05<<0), // Input Capture Frequency and Pulse-Width measurement
TCB_CNTMODE_SINGLE_gc = (0x06<<0), // Single Shot
TCB_CNTMODE_PWM8_gc = (0x07<<0), // 8-bit PWM
-} TCB_CNTMODE_t;
+ } TCB_CNTMODE_t;
*****************************************************************************************/
/*****************************************************************************************
-// From https://github.com/SpenceKonde/DxCore/blob/master/megaavr/cores/dxcore/Arduino.h#L455-L462
+ // From https://github.com/SpenceKonde/DxCore/blob/master/megaavr/cores/dxcore/Arduino.h#L455-L462
-#define TIMERA0 (0x10) // A "simple" type A timer mapping doesn't get constants for the WO channels.
-#define TIMERA1 (0x08) // Formerly 0x11 - giving it a dedicated bit makes the takeover tracking easy and efficient instead of being a morass of tests and bitmath.
-#define TIMERB0 (0x20) // TCB0
-#define TIMERB1 (0x21) // TCB1
-#define TIMERB2 (0x22) // TCB2
-#define TIMERB3 (0x23) // TCB3
-#define TIMERB4 (0x24) // TCB4
-#define TIMERD0 (0x70) // If any of these bits match it's potentially on TCD0
+ #define TIMERA0 (0x10) // A "simple" type A timer mapping doesn't get constants for the WO channels.
+ #define TIMERA1 (0x08) // Formerly 0x11 - giving it a dedicated bit makes the takeover tracking easy and efficient instead of being a morass of tests and bitmath.
+ #define TIMERB0 (0x20) // TCB0
+ #define TIMERB1 (0x21) // TCB1
+ #define TIMERB2 (0x22) // TCB2
+ #define TIMERB3 (0x23) // TCB3
+ #define TIMERB4 (0x24) // TCB4
+ #define TIMERD0 (0x70) // If any of these bits match it's potentially on TCD0
*****************************************************************************************/
#if defined(TCB4)
- #if (_PWM_LOGLEVEL_ > 2)
- #warning TCB0-TCB4 Timers available
- #endif
-
- TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2, &TCB3, &TCB4 };
-
+#if (_PWM_LOGLEVEL_ > 2)
+ #warning TCB0-TCB4 Timers available
+#endif
+
+TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2, &TCB3, &TCB4 };
+
#elif defined(TCB3)
- #if (_PWM_LOGLEVEL_ > 2)
- #warning TCB0-TCB3 Timers available
- #endif
-
- TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2, &TCB3 };
-
+#if (_PWM_LOGLEVEL_ > 2)
+ #warning TCB0-TCB3 Timers available
+#endif
+
+TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2, &TCB3 };
+
#else
- #if (_PWM_LOGLEVEL_ > 2)
- #warning TCB0-TCB2 Timers available
- #endif
-
- TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2 };
-
-#endif
+#if (_PWM_LOGLEVEL_ > 2)
+ #warning TCB0-TCB2 Timers available
+#endif
+
+TCB_t* TimerTCB[ NUM_HW_TIMERS ] = { &TCB0, &TCB1, &TCB2 };
+
+#endif
//////////////////////////////////////////////
@@ -115,62 +115,62 @@ typedef enum TCB_CNTMODE_enum
#if (_PWM_LOGLEVEL_ > 2)
#warning Using no prescaler => FULL_CLOCK (24MHz, 16MHz, etc)
#endif
-
+
#define TCB_CLKSEL_VALUE TCB_CLKSEL_DIV1_gc
#define CLOCK_PRESCALER 1
-
+
#elif USING_HALF_CLOCK
// Use prescaler 2 => 12/8MHz, etc.
#if (_PWM_LOGLEVEL_ > 2)
#warning Using prescaler 2 => HALF_CLOCK (12MHz, 8MHz, etc.)
#endif
-
+
#define TCB_CLKSEL_VALUE TCB_CLKSEL_DIV2_gc
#define CLOCK_PRESCALER 2
-// No TCB_CLKSEL_CLKTCA_gc in DXCore ???
-// Don't use 250KHz now
+ // No TCB_CLKSEL_CLKTCA_gc in DXCore ???
+ // Don't use 250KHz now
#elif USING_250KHZ
- // Optional, but for clarity
- // Use Timer A as clock (prescaler 64) => 250KHz
- #define TCB_CLKSEL_VALUE TCB_CLKSEL_CLKTCA_gc
- #define CLOCK_PRESCALER 64
-
- #error Not OK now. Do not use
-
+ // Optional, but for clarity
+ // Use Timer A as clock (prescaler 64) => 250KHz
+ #define TCB_CLKSEL_VALUE TCB_CLKSEL_CLKTCA_gc
+ #define CLOCK_PRESCALER 64
+
+ #error Not OK now. Do not use
+
#else
// Use prescaler 2 => 8MHz
#if (_PWM_LOGLEVEL_ > 2)
#warning Using prescaler 2 => 8MHz
#endif
-
+
#define TCB_CLKSEL_VALUE TCB_CLKSEL_DIV2_gc
#define CLOCK_PRESCALER 2
-
+
#endif
-
+
#define CLK_TCB_FREQ ( F_CPU / CLOCK_PRESCALER )
//////////////////////////////////////////////
void TimerInterrupt::init(const int8_t& timer)
-{
+{
// Set timer specific stuff
// All timers in CTC mode
// 8 bit timers will require changing prescalar values,
// whereas 16 bit timers are set to either ck/1 or ck/64 prescalar
-
+
noInterrupts();
-
+
// 16 bit timer
TimerTCB[timer]->CTRLB = TCB_CNTMODE_INT_gc; // Use timer compare mode
TimerTCB[timer]->CCMP = MAX_COUNT_16BIT; // Value to compare with.
TimerTCB[timer]->INTCTRL &= ~TCB_CAPT_bm; // Disable the interrupt
TimerTCB[timer]->CTRLA = TCB_CLKSEL_VALUE | TCB_ENABLE_bm; // Use Timer A as clock, enable timer
-
+
_timer = timer;
- interrupts();
+ interrupts();
}
//////////////////////////////////////////////
@@ -182,14 +182,14 @@ void TimerInterrupt::set_CCMP()
// set the toggle count,
// then turn on the interrupts
uint32_t _CCMPValueToUse;
-
+
_CCMPValueToUse = min(MAX_COUNT_16BIT, _CCMPValueRemaining);
_CCMPValueRemaining -= _CCMPValueToUse;
-
+
TimerTCB[_timer]->CCMP = _CCMPValueToUse; // Value to compare with.
-
+
TimerTCB[_timer]->INTCTRL = TCB_CAPT_bm; // Enable the interrupt
-
+
// Flag _CCMPValue == 0 => end of long timer
if (_CCMPValueRemaining == 0)
_timerDone = true;
@@ -200,25 +200,26 @@ void TimerInterrupt::set_CCMP()
// frequency (in hertz) and duration (in milliseconds).
// Return true if frequency is OK with selected timer (CCMPValue is in range)
-bool TimerInterrupt::setFrequency(const float& frequency, timer_callback_p callback, const uint32_t& params, const unsigned long& duration)
-{
+bool TimerInterrupt::setFrequency(const float& frequency, timer_callback_p callback, const uint32_t& params,
+ const unsigned long& duration)
+{
//frequencyLimit must > 1
float frequencyLimit = frequency * 17179.840;
// Limit frequency to larger than (0.00372529 / 64) Hz or interval 17179.840s / 17179840 ms to avoid uint32_t overflow
if ((_timer <= 0) || (callback == NULL) || ((frequencyLimit) < 1) )
- {
+ {
return false;
}
- else
- {
+ else
+ {
// Calculate the toggle count. Duration must be at least longer then one cycle
if (duration > 0)
- {
+ {
_toggle_count = frequency * duration / 1000;
-
+
if (_toggle_count < 1)
- {
+ {
return false;
}
}
@@ -226,7 +227,7 @@ bool TimerInterrupt::setFrequency(const float& frequency, timer_callback_p callb
{
_toggle_count = -1;
}
-
+
//Timer0-4 are 16 bit timers, meaning it can store a maximum counter value of 65535.
noInterrupts();
@@ -236,14 +237,14 @@ bool TimerInterrupt::setFrequency(const float& frequency, timer_callback_p callb
_params = reinterpret_cast(params);
_timerDone = false;
-
+
_CCMPValue = _CCMPValueRemaining = (uint32_t) (CLK_TCB_FREQ / frequency);
-
+
// Set the CCMP for the given timer,
// set the toggle count,
- // then turn on the interrupts
+ // then turn on the interrupts
set_CCMP();
-
+
interrupts();
return true;
@@ -255,12 +256,12 @@ bool TimerInterrupt::setFrequency(const float& frequency, timer_callback_p callb
void TimerInterrupt::detachInterrupt()
{
noInterrupts();
-
+
// Clear interrupt flag
TimerTCB[_timer]->INTFLAGS = TCB_CAPT_bm;
TimerTCB[_timer]->INTCTRL &= ~TCB_CAPT_bm; // Disable the interrupt
TimerTCB[_timer]->CTRLA &= ~TCB_ENABLE_bm; // Disable timer
-
+
interrupts();
}
@@ -280,11 +281,11 @@ void TimerInterrupt::reattachInterrupt(const unsigned long& duration)
{
_toggle_count = -1;
}
-
- // Set interrupt flag
+
+ // Set interrupt flag
TimerTCB[_timer]->INTCTRL |= TCB_CAPT_bm; // Enable the interrupt
TimerTCB[_timer]->CTRLA |= TCB_ENABLE_bm; // Enable timer
-
+
interrupts();
}
@@ -293,7 +294,7 @@ void TimerInterrupt::reattachInterrupt(const unsigned long& duration)
// Just stop clock source, still keep the count
// To fix this.
void TimerInterrupt::pauseTimer()
-{
+{
detachInterrupt();
}
@@ -301,7 +302,7 @@ void TimerInterrupt::pauseTimer()
// Just reconnect clock source, continue from the current count
void TimerInterrupt::resumeTimer()
-{
+{
reattachInterrupt();
}
@@ -337,102 +338,102 @@ void TimerInterrupt::resumeTimer()
////////////////////////////////////////////////////////////////////////////////
#if USE_TIMER_0
- #ifndef TIMER0_INSTANTIATED
- // To force pre-instantiate only once
- #define TIMER0_INSTANTIATED
- TimerInterrupt ITimer0(HW_TIMER_0);
-
- ISR(TCB0_INT_vect)
+#ifndef TIMER0_INSTANTIATED
+// To force pre-instantiate only once
+#define TIMER0_INSTANTIATED
+TimerInterrupt ITimer0(HW_TIMER_0);
+
+ISR(TCB0_INT_vect)
+{
+ long countLocal = ITimer0.getCount();
+
+ if (ITimer0.getTimer() == 0)
+ {
+ if (countLocal != 0)
{
- long countLocal = ITimer0.getCount();
-
- if (ITimer0.getTimer() == 0)
+ if (ITimer0.checkTimerDone())
{
- if (countLocal != 0)
+ ITimer0.callback();
+
+ if (ITimer0.get_CCMPValue() > MAX_COUNT_16BIT)
{
- if (ITimer0.checkTimerDone())
- {
- ITimer0.callback();
-
- if (ITimer0.get_CCMPValue() > MAX_COUNT_16BIT)
- {
- // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT
- ITimer0.reload_CCMPValue();
- }
-
- if (countLocal > 0)
- ITimer0.setCount(countLocal - 1);
- }
- else
- {
- //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
- // If _CCMPValue == 0, flag _timerDone for next cycle
- // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
- ITimer0.adjust_CCMPValue();
- }
- }
- else
- {
- ITimer0.detachInterrupt();
+ // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT
+ ITimer0.reload_CCMPValue();
}
+
+ if (countLocal > 0)
+ ITimer0.setCount(countLocal - 1);
}
-
- // Clear interrupt flag
- TCB0.INTFLAGS = TCB_CAPT_bm;
+ else
+ {
+ //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
+ // If _CCMPValue == 0, flag _timerDone for next cycle
+ // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
+ ITimer0.adjust_CCMPValue();
+ }
+ }
+ else
+ {
+ ITimer0.detachInterrupt();
}
- #endif //#ifndef TIMER0_INSTANTIATED
+ }
+
+ // Clear interrupt flag
+ TCB0.INTFLAGS = TCB_CAPT_bm;
+}
+#endif //#ifndef TIMER0_INSTANTIATED
#endif //#if USE_TIMER_0
//////////////////////////////////////////////
-#if USE_TIMER_1
+#if USE_TIMER_1
#ifndef TIMER1_INSTANTIATED
- // To force pre-instantiate only once
- #define TIMER1_INSTANTIATED
- TimerInterrupt ITimer1(HW_TIMER_1);
-
- // Timer0 is used for micros(), millis(), delay(), etc and can't be used
- // Pre-instantiate
-
- ISR(TCB1_INT_vect)
+// To force pre-instantiate only once
+#define TIMER1_INSTANTIATED
+TimerInterrupt ITimer1(HW_TIMER_1);
+
+// Timer0 is used for micros(), millis(), delay(), etc and can't be used
+// Pre-instantiate
+
+ISR(TCB1_INT_vect)
+{
+ long countLocal = ITimer1.getCount();
+
+ if (ITimer1.getTimer() == 1)
{
- long countLocal = ITimer1.getCount();
-
- if (ITimer1.getTimer() == 1)
+ if (countLocal != 0)
{
- if (countLocal != 0)
+ if (ITimer1.checkTimerDone())
{
- if (ITimer1.checkTimerDone())
- {
- ITimer1.callback();
-
- if (ITimer1.get_CCMPValue() > MAX_COUNT_16BIT)
- {
- // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
- ITimer1.reload_CCMPValue();
- }
-
- if (countLocal > 0)
- ITimer1.setCount(countLocal - 1);
- }
- else
+ ITimer1.callback();
+
+ if (ITimer1.get_CCMPValue() > MAX_COUNT_16BIT)
{
- //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
- // If _CCMPValue == 0, flag _timerDone for next cycle
- // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
- ITimer1.adjust_CCMPValue();
- }
+ // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
+ ITimer1.reload_CCMPValue();
+ }
+
+ if (countLocal > 0)
+ ITimer1.setCount(countLocal - 1);
}
else
- {
- ITimer1.detachInterrupt();
+ {
+ //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
+ // If _CCMPValue == 0, flag _timerDone for next cycle
+ // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
+ ITimer1.adjust_CCMPValue();
}
}
-
- // Clear interrupt flag
- TCB1.INTFLAGS = TCB_CAPT_bm;
+ else
+ {
+ ITimer1.detachInterrupt();
+ }
}
-
+
+ // Clear interrupt flag
+ TCB1.INTFLAGS = TCB_CAPT_bm;
+}
+
#endif //#ifndef TIMER1_INSTANTIATED
#endif //#if USE_TIMER_1
@@ -441,47 +442,47 @@ void TimerInterrupt::resumeTimer()
// Pre-instantiate
#if USE_TIMER_2
#ifndef TIMER2_INSTANTIATED
- #define TIMER2_INSTANTIATED
- TimerInterrupt ITimer2(HW_TIMER_2);
-
- ISR(TCB2_INT_vect)
+#define TIMER2_INSTANTIATED
+TimerInterrupt ITimer2(HW_TIMER_2);
+
+ISR(TCB2_INT_vect)
+{
+ long countLocal = ITimer2.getCount();
+
+ if (ITimer2.getTimer() == 2)
{
- long countLocal = ITimer2.getCount();
-
- if (ITimer2.getTimer() == 2)
+ if (countLocal != 0)
{
- if (countLocal != 0)
+ if (ITimer2.checkTimerDone())
{
- if (ITimer2.checkTimerDone())
- {
- ITimer2.callback();
-
- if (ITimer2.get_CCMPValue() > MAX_COUNT_16BIT)
- {
- // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
- ITimer2.reload_CCMPValue();
- }
-
- if (countLocal > 0)
- ITimer2.setCount(countLocal - 1);
+ ITimer2.callback();
+ if (ITimer2.get_CCMPValue() > MAX_COUNT_16BIT)
+ {
+ // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
+ ITimer2.reload_CCMPValue();
}
- else
- {
- //Deduct _CCMPValue by min(MAX_COUNT_8BIT, _CCMPValue)
- // If _CCMPValue == 0, flag _timerDone for next cycle
- ITimer2.adjust_CCMPValue();
- }
- }
+
+ if (countLocal > 0)
+ ITimer2.setCount(countLocal - 1);
+
+ }
else
- {
- ITimer2.detachInterrupt();
+ {
+ //Deduct _CCMPValue by min(MAX_COUNT_8BIT, _CCMPValue)
+ // If _CCMPValue == 0, flag _timerDone for next cycle
+ ITimer2.adjust_CCMPValue();
}
}
-
- // Clear interrupt flag
- TCB2.INTFLAGS = TCB_CAPT_bm;
- }
+ else
+ {
+ ITimer2.detachInterrupt();
+ }
+ }
+
+ // Clear interrupt flag
+ TCB2.INTFLAGS = TCB_CAPT_bm;
+}
#endif //#ifndef TIMER2_INSTANTIATED
#endif //#if USE_TIMER_2
@@ -489,102 +490,102 @@ void TimerInterrupt::resumeTimer()
// Pre-instantiate
#if ( USE_TIMER_3 && ( ( defined(DX_64_PINS) || defined(DX_48_PINS) ) && defined(TCB3) ) )
- #ifndef TIMER3_INSTANTIATED
- // To force pre-instantiate only once
- #define TIMER3_INSTANTIATED
- TimerInterrupt ITimer3(HW_TIMER_3);
-
- ISR(TCB3_INT_vect)
+#ifndef TIMER3_INSTANTIATED
+// To force pre-instantiate only once
+#define TIMER3_INSTANTIATED
+TimerInterrupt ITimer3(HW_TIMER_3);
+
+ISR(TCB3_INT_vect)
+{
+ long countLocal = ITimer3.getCount();
+
+ if (ITimer3.getTimer() == 3)
+ {
+ if (countLocal != 0)
{
- long countLocal = ITimer3.getCount();
-
- if (ITimer3.getTimer() == 3)
+ if (ITimer3.checkTimerDone())
{
- if (countLocal != 0)
+ ITimer3.callback();
+
+ if (ITimer3.get_CCMPValue() > MAX_COUNT_16BIT)
{
- if (ITimer3.checkTimerDone())
- {
- ITimer3.callback();
-
- if (ITimer3.get_CCMPValue() > MAX_COUNT_16BIT)
- {
- // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
- ITimer3.reload_CCMPValue();
- }
-
- if (countLocal > 0)
- ITimer3.setCount(countLocal - 1);
- }
- else
- {
- //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
- // If _CCMPValue == 0, flag _timerDone for next cycle
- // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
- ITimer3.adjust_CCMPValue();
- }
- }
- else
- {
- ITimer3.detachInterrupt();
+ // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
+ ITimer3.reload_CCMPValue();
}
+
+ if (countLocal > 0)
+ ITimer3.setCount(countLocal - 1);
}
-
- // Clear interrupt flag
- TCB3.INTFLAGS = TCB_CAPT_bm;
- }
-
- #endif //#ifndef TIMER3_INSTANTIATED
+ else
+ {
+ //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
+ // If _CCMPValue == 0, flag _timerDone for next cycle
+ // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
+ ITimer3.adjust_CCMPValue();
+ }
+ }
+ else
+ {
+ ITimer3.detachInterrupt();
+ }
+ }
+
+ // Clear interrupt flag
+ TCB3.INTFLAGS = TCB_CAPT_bm;
+}
+
+#endif //#ifndef TIMER3_INSTANTIATED
#endif //#if USE_TIMER_3
//////////////////////////////////////////////
// Pre-instantiate
#if ( USE_TIMER_4 && defined(DX_64_PINS) && defined(TCB4) )
- #ifndef TIMER4_INSTANTIATED
- // To force pre-instantiate only once
- #define TIMER4_INSTANTIATED
- TimerInterrupt ITimer4(HW_TIMER_4);
-
- ISR(TCB4_INT_vect)
+#ifndef TIMER4_INSTANTIATED
+// To force pre-instantiate only once
+#define TIMER4_INSTANTIATED
+TimerInterrupt ITimer4(HW_TIMER_4);
+
+ISR(TCB4_INT_vect)
+{
+ long countLocal = ITimer4.getCount();
+
+ if (ITimer4.getTimer() == 4)
+ {
+ if (countLocal != 0)
{
- long countLocal = ITimer4.getCount();
-
- if (ITimer4.getTimer() == 4)
+ if (ITimer4.checkTimerDone())
{
- if (countLocal != 0)
+ ITimer4.callback();
+
+ if (ITimer4.get_CCMPValue() > MAX_COUNT_16BIT)
{
- if (ITimer4.checkTimerDone())
- {
- ITimer4.callback();
-
- if (ITimer4.get_CCMPValue() > MAX_COUNT_16BIT)
- {
- // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
- ITimer4.reload_CCMPValue();
- }
-
- if (countLocal > 0)
- ITimer4.setCount(countLocal - 1);
- }
- else
- {
- //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
- // If _CCMPValue == 0, flag _timerDone for next cycle
- // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
- ITimer4.adjust_CCMPValue();
- }
- }
- else
- {
- ITimer4.detachInterrupt();
+ // To reload _CCMPValueRemaining as well as _CCMP register to MAX_COUNT_16BIT if _CCMPValueRemaining > MAX_COUNT_16BIT
+ ITimer4.reload_CCMPValue();
}
+
+ if (countLocal > 0)
+ ITimer4.setCount(countLocal - 1);
}
-
- // Clear interrupt flag
- TCB4.INTFLAGS = TCB_CAPT_bm;
- }
-
- #endif //#ifndef TIMER4_INSTANTIATED
+ else
+ {
+ //Deduct _CCMPValue by min(MAX_COUNT_16BIT, _CCMPValue)
+ // If _CCMPValue == 0, flag _timerDone for next cycle
+ // If last one (_CCMPValueRemaining < MAX_COUNT_16BIT) => load _CCMP register _CCMPValueRemaining
+ ITimer4.adjust_CCMPValue();
+ }
+ }
+ else
+ {
+ ITimer4.detachInterrupt();
+ }
+ }
+
+ // Clear interrupt flag
+ TCB4.INTFLAGS = TCB_CAPT_bm;
+}
+
+#endif //#ifndef TIMER4_INSTANTIATED
#endif //#if USE_TIMER_4
#endif // DX_SLOW_PWM_IMPL_H
diff --git a/src/PWM_Generic_Debug.h b/src/PWM_Generic_Debug.h
index ab4b919..aabc01a 100644
--- a/src/PWM_Generic_Debug.h
+++ b/src/PWM_Generic_Debug.h
@@ -5,7 +5,7 @@
Built by Khoi Hoang https://github.com/khoih-prog/Dx_Slow_PWM
Licensed under MIT license
-
+
Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by
unsigned long miliseconds), you just consume only one AVRDx-based timer and avoid conflicting with other cores' tasks.
The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
diff --git a/utils/astyle_library.conf b/utils/astyle_library.conf
new file mode 100644
index 0000000..8a73bc2
--- /dev/null
+++ b/utils/astyle_library.conf
@@ -0,0 +1,70 @@
+# Code formatting rules for Arduino libraries, modified from for KH libraries:
+#
+# https://github.com/arduino/Arduino/blob/master/build/shared/examples_formatter.conf
+#
+
+# astyle --style=allman -s2 -t2 -C -S -xW -Y -M120 -f -p -xg -H -xb -c --xC120 -xL *.h *.cpp *.ino
+
+--mode=c
+--lineend=linux
+--style=allman
+
+# -r or -R
+#--recursive
+
+# -c => Converts tabs into spaces
+convert-tabs
+
+# -s2 => 2 spaces indentation
+--indent=spaces=2
+
+# -t2 => tab =2 spaces
+#--indent=tab=2
+
+# -C
+--indent-classes
+
+# -S
+--indent-switches
+
+# -xW
+--indent-preproc-block
+
+# -Y => indent classes, switches (and cases), comments starting at column 1
+--indent-col1-comments
+
+# -M120 => maximum of 120 spaces to indent a continuation line
+--max-continuation-indent=120
+
+# -xC120 => max‑code‑length will break a line if the code exceeds # characters
+--max-code-length=120
+
+# -f =>
+--break-blocks
+
+# -p => put a space around operators
+--pad-oper
+
+# -xg => Insert space padding after commas
+--pad-comma
+
+# -H => put a space after if/for/while
+pad-header
+
+# -xb => Break one line headers (e.g. if/for/while)
+--break-one-line-headers
+
+# -c => Converts tabs into spaces
+#--convert-tabs
+
+# if you like one-liners, keep them
+#keep-one-line-statements
+
+# -xV
+--attach-closing-while
+
+#unpad-paren
+
+# -xp
+remove-comment-prefix
+
diff --git a/utils/restyle.sh b/utils/restyle.sh
new file mode 100644
index 0000000..bcd846f
--- /dev/null
+++ b/utils/restyle.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+for dir in . ; do
+ find $dir -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.ino" \) -exec astyle --suffix=none --options=./utils/astyle_library.conf \{\} \;
+done
+