v1.0.3

### Release v1.0.3

1. 1. Add example [**ISR_16_Timers_Array_Complex**](examples/ISR_16_Timers_Array_Complex) and optimize example [**ISR_Timers_Array_Simple**](examples/ISR_Timers_Array_Simple) to demonstrate the usage of **16 ISR-based timers**

Author: khoih-prog

README.md

@@ -1,34 +1,37 @@
 /****************************************************************************************************************************
- * examples/Argument_Complex.ino
- * For Arduino AVR boards
- * Written by Khoi Hoang
- * 
- * Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
- * Licensed under MIT license
- * Version: v1.0.2
- *
- * Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
- * Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
- * The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
- * Therefore, their executions are not blocked by bad-behaving functions / tasks.
- * This important feature is absolutely necessary for mission-critical tasks.
- * 
- * Notes:
- * Special design is necessary to share data between interrupt code and the rest of your program.
- * Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume 
- * variable can not spontaneously change. Because your function may change variables while your program is using them, 
- * the compiler needs this hint. But volatile alone is often not enough.
- * When accessing shared variables, usually interrupts must be disabled. Even with volatile, 
- * if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly. 
- * If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled 
- * or the entire sequence of your code which accesses the data.
- * 
- * Version Modified By   Date      Comments
- * ------- -----------  ---------- -----------
- *  1.0.0   K Hoang      23/11/2019 Initial coding
- *  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
- *  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
- *****************************************************************************************************************************/
+  Argument_Complex.ino
+  For Arduino boards (UNO, Nano, Mega, etc. )
+  Written by Khoi Hoang
+  
+  Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
+  Licensed under MIT license
+  
+  Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
+  Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
+  The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
+  Therefore, their executions are not blocked by bad-behaving functions / tasks.
+  This important feature is absolutely necessary for mission-critical tasks.
+  
+  Notes:
+  Special design is necessary to share data between interrupt code and the rest of your program.
+  Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume
+  variable can not spontaneously change. Because your function may change variables while your program is using them,
+  the compiler needs this hint. But volatile alone is often not enough.
+  When accessing shared variables, usually interrupts must be disabled. Even with volatile,
+  if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly.
+  If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled
+  or the entire sequence of your code which accesses the data.
+  
+  Version: 1.0.3
+  
+  Version Modified By   Date      Comments
+  ------- -----------  ---------- -----------
+  1.0.0   K Hoang      23/11/2019 Initial coding
+  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
+  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
+  1.0.3   K.Hoang      01/12/2020 Add complex examples ISR_16_Timers_Array_Complex and ISR_16_Timers_Array_Complex
+*****************************************************************************************************************************/
+
 //These define's must be placed at the beginning before #include "TimerInterrupt.h"
 #define TIMER_INTERRUPT_DEBUG      0
 
@@ -61,16 +64,16 @@ void TimerHandler1(unsigned int outputPinsAddress)
     pinMode(((pinStruct *) outputPinsAddress)->Pin2, INPUT_PULLUP);
     pinMode(((pinStruct *) outputPinsAddress)->Pin3, INPUT_PULLUP);
   }
-    
+
   //timer interrupt toggles pins
   Serial.println("Toggle pin1 = " + String(((pinStruct *) outputPinsAddress)->Pin1) );
   digitalWrite(((pinStruct *) outputPinsAddress)->Pin1, toggle1);
 
-  Serial.println("Read pin2 A0 (" + String(((pinStruct *) outputPinsAddress)->Pin2) + ") = " + 
-        String( digitalRead(((pinStruct *) outputPinsAddress)->Pin2)? "HIGH" : "LOW" ) );
-  
-Serial.println("Read pin3 A1 (" + String(((pinStruct *) outputPinsAddress)->Pin3) + ") = " + 
-        String( digitalRead(((pinStruct *) outputPinsAddress)->Pin3)? "HIGH" : "LOW" ) );
+  Serial.println("Read pin2 A0 (" + String(((pinStruct *) outputPinsAddress)->Pin2) + ") = " +
+                 String( digitalRead(((pinStruct *) outputPinsAddress)->Pin2) ? "HIGH" : "LOW" ) );
+
+  Serial.println("Read pin3 A1 (" + String(((pinStruct *) outputPinsAddress)->Pin3) + ") = " +
+                 String( digitalRead(((pinStruct *) outputPinsAddress)->Pin3) ? "HIGH" : "LOW" ) );
 
   toggle1 = !toggle1;
 }
@@ -80,24 +83,28 @@ Serial.println("Read pin3 A1 (" + String(((pinStruct *) outputPinsAddress)->Pin3
 void setup()
 {
   Serial.begin(115200);
-  Serial.println("\nStarting");
+  while (!Serial);
+
+  Serial.println("\nStarting Argument_Complex");
+  Serial.println("Version : " + String(TIMER_INTERRUPT_VERSION));
+  Serial.println("CPU Frequency = " + String(F_CPU / 1000000) + " MHz");
 
   // Timer0 is used for micros(), millis(), delay(), etc and can't be used
   // Select Timer 1-2 for UNO, 0-5 for MEGA
-  // Timer 2 is 8-bit timer, only for higher frequency 
-  
+  // Timer 2 is 8-bit timer, only for higher frequency
+
   ITimer1.init();
-   
-  // Using ATmega328 used in UNO => 16MHz CPU clock , 
+
+  // Using ATmega328 used in UNO => 16MHz CPU clock ,
   // For 16-bit timer 1, 3, 4 and 5, set frequency from 0.2385 to some KHz
   // For 8-bit timer 2 (prescaler up to 1024, set frequency from 61.5Hz to some KHz
-  
+
   if (ITimer1.attachInterruptInterval(TIMER1_INTERVAL_MS, TimerHandler1, (unsigned int) &myOutputPins))
     Serial.println("Starting  ITimer1 OK, millis() = " + String(millis()));
   else
-    Serial.println("Can't set ITimer1. Select another freq. or timer");    
+    Serial.println("Can't set ITimer1. Select another freq. or timer");
 }
 
 void loop()
-{  
+{
 }

examples/Argument_Complex/Argument_Complex.ino

@@ -1,33 +1,35 @@
 /****************************************************************************************************************************
- * examples/Argument_None.ino
- * For Arduino AVR boards
- * Written by Khoi Hoang
- * 
- * Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
- * Licensed under MIT license
- * Version: v1.0.2
- *
- * Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
- * Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
- * The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
- * Therefore, their executions are not blocked by bad-behaving functions / tasks.
- * This important feature is absolutely necessary for mission-critical tasks.
- * 
- * Notes:
- * Special design is necessary to share data between interrupt code and the rest of your program.
- * Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume 
- * variable can not spontaneously change. Because your function may change variables while your program is using them, 
- * the compiler needs this hint. But volatile alone is often not enough.
- * When accessing shared variables, usually interrupts must be disabled. Even with volatile, 
- * if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly. 
- * If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled 
- * or the entire sequence of your code which accesses the data.
- *
- * Version Modified By   Date      Comments
- * ------- -----------  ---------- -----------
- *  1.0.0   K Hoang      23/11/2019 Initial coding
- *  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
- *  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
+  Argument_None.ino
+  For Arduino boards (UNO, Nano, Mega, etc. )
+  Written by Khoi Hoang
+  
+  Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
+  Licensed under MIT license
+  
+  Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
+  Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
+  The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
+  Therefore, their executions are not blocked by bad-behaving functions / tasks.
+  This important feature is absolutely necessary for mission-critical tasks.
+  
+  Notes:
+  Special design is necessary to share data between interrupt code and the rest of your program.
+  Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume
+  variable can not spontaneously change. Because your function may change variables while your program is using them,
+  the compiler needs this hint. But volatile alone is often not enough.
+  When accessing shared variables, usually interrupts must be disabled. Even with volatile,
+  if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly.
+  If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled
+  or the entire sequence of your code which accesses the data.
+  
+  Version: 1.0.3
+  
+  Version Modified By   Date      Comments
+  ------- -----------  ---------- -----------
+  1.0.0   K Hoang      23/11/2019 Initial coding
+  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
+  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
+  1.0.3   K.Hoang      01/12/2020 Add complex examples ISR_16_Timers_Array_Complex and ISR_16_Timers_Array_Complex
  *****************************************************************************************************************************/
 //These define's must be placed at the beginning before #include "TimerInterrupt.h"
 #define TIMER_INTERRUPT_DEBUG      0
@@ -66,7 +68,7 @@ void TimerHandler2(void)
     started = true;
     pinMode(A0, OUTPUT);
   }
-  
+
   //timer interrupt toggles outputPin
   digitalWrite(A0, toggle2);
   toggle2 = !toggle2;
@@ -79,32 +81,36 @@ void TimerHandler2(void)
 void setup()
 {
   Serial.begin(115200);
-  Serial.println("\nStarting");
+  while (!Serial);
+
+  Serial.println("\nStarting Argument_None");
+  Serial.println("Version : " + String(TIMER_INTERRUPT_VERSION));
+  Serial.println("CPU Frequency = " + String(F_CPU / 1000000) + " MHz");
 
   // Select Timer 1-2 for UNO, 0-5 for MEGA
-  // Timer 2 is 8-bit timer, only for higher frequency   
+  // Timer 2 is 8-bit timer, only for higher frequency
   ITimer1.init();
-   
-  // Using ATmega328 used in UNO => 16MHz CPU clock , 
+
+  // Using ATmega328 used in UNO => 16MHz CPU clock ,
   // For 16-bit timer 1, 3, 4 and 5, set frequency from 0.2385 to some KHz
   // For 8-bit timer 2 (prescaler up to 1024, set frequency from 61.5Hz to some KHz
-  
+
   if (ITimer1.attachInterruptInterval(TIMER1_INTERVAL_MS, TimerHandler1))
     Serial.println("Starting  ITimer1 OK, millis() = " + String(millis()));
   else
     Serial.println("Can't set ITimer1. Select another freq. or timer");
 
   // Select Timer 1-2 for UNO, 0-5 for MEGA
-  // Timer 2 is 8-bit timer, only for higher frequency       
+  // Timer 2 is 8-bit timer, only for higher frequency
   ITimer2.init();
-      
+
   if (ITimer2.attachInterruptInterval(TIMER2_INTERVAL_MS, TimerHandler2))
     Serial.println("Starting  ITimer2 OK, millis() = " + String(millis()));
   else
-    Serial.println("Can't set ITimer2. Select another freq. or timer");    
+    Serial.println("Can't set ITimer2. Select another freq. or timer");
 }
 
 void loop()
 {
-  
+
 }

examples/Argument_None/Argument_None.ino

@@ -1,33 +1,35 @@
 /****************************************************************************************************************************
- * examples/Argument_Simple.ino
- * For Arduino AVR boards
- * Written by Khoi Hoang
- * 
- * Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
- * Licensed under MIT license
- * Version: v1.0.2
- *
- * Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
- * Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
- * The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
- * Therefore, their executions are not blocked by bad-behaving functions / tasks.
- * This important feature is absolutely necessary for mission-critical tasks.
- * 
- * Notes:
- * Special design is necessary to share data between interrupt code and the rest of your program.
- * Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume 
- * variable can not spontaneously change. Because your function may change variables while your program is using them, 
- * the compiler needs this hint. But volatile alone is often not enough.
- * When accessing shared variables, usually interrupts must be disabled. Even with volatile, 
- * if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly. 
- * If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled 
- * or the entire sequence of your code which accesses the data.
- *
- * Version Modified By   Date      Comments
- * ------- -----------  ---------- -----------
- *  1.0.0   K Hoang      23/11/2019 Initial coding
- *  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
- *  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
+  Argument_Simple.ino
+  For Arduino boards (UNO, Nano, Mega, etc. )
+  Written by Khoi Hoang
+  
+  Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt
+  Licensed under MIT license
+  
+  Now we can use these new 16 ISR-based timers, while consuming only 1 hardware Timer.
+  Their independently-selected, maximum interval is practically unlimited (limited only by unsigned long miliseconds)
+  The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers
+  Therefore, their executions are not blocked by bad-behaving functions / tasks.
+  This important feature is absolutely necessary for mission-critical tasks.
+  
+  Notes:
+  Special design is necessary to share data between interrupt code and the rest of your program.
+  Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume
+  variable can not spontaneously change. Because your function may change variables while your program is using them,
+  the compiler needs this hint. But volatile alone is often not enough.
+  When accessing shared variables, usually interrupts must be disabled. Even with volatile,
+  if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly.
+  If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled
+  or the entire sequence of your code which accesses the data.
+  
+  Version: 1.0.3
+  
+  Version Modified By   Date      Comments
+  ------- -----------  ---------- -----------
+  1.0.0   K Hoang      23/11/2019 Initial coding
+  1.0.1   K Hoang      25/11/2019 New release fixing compiler error
+  1.0.2   K.Hoang      28/11/2019 Permit up to 16 super-long-time, super-accurate ISR-based timers to avoid being blocked
+  1.0.3   K.Hoang      01/12/2020 Add complex examples ISR_16_Timers_Array_Complex and ISR_16_Timers_Array_Complex
  *****************************************************************************************************************************/
 //These define's must be placed at the beginning before #include "TimerInterrupt.h"
 #define TIMER_INTERRUPT_DEBUG      0
@@ -53,7 +55,7 @@ void TimerHandler1(unsigned int outputPin = LED_BUILTIN)
     started = true;
     pinMode(outputPin, OUTPUT);
   }
-  
+
   //timer interrupt toggles pin outputPin, default LED_BUILTIN
   Serial.println("pin1 = " + String(outputPin) + " address: " + String((uint32_t) &outputPin) );
   digitalWrite(outputPin, toggle1);
@@ -70,47 +72,51 @@ void TimerHandler2(unsigned int outputPin = LED_BUILTIN)
     started = true;
     pinMode(outputPin, OUTPUT);
   }
-  
+
   //timer interrupt toggles pin outputPin, default LED_BUILTIN
   digitalWrite(outputPin, toggle2);
   toggle2 = !toggle2;
 }
 
-#define TIMER1_INTERVAL_MS    1000 
+#define TIMER1_INTERVAL_MS    1000
 
-#define TIMER2_INTERVAL_MS    2000 
+#define TIMER2_INTERVAL_MS    2000
 
 void setup()
 {
   Serial.begin(115200);
-  Serial.println("\nStarting");
+  while (!Serial);
+
+  Serial.println("\nStarting Argument_Simple");
+  Serial.println("Version : " + String(TIMER_INTERRUPT_VERSION));
+  Serial.println("CPU Frequency = " + String(F_CPU / 1000000) + " MHz");
 
   // Timer0 is used for micros(), millis(), delay(), etc and can't be used
   // Select Timer 1-2 for UNO, 0-5 for MEGA
-  // Timer 2 is 8-bit timer, only for higher frequency 
-  
+  // Timer 2 is 8-bit timer, only for higher frequency
+
   ITimer1.init();
-   
-  // Using ATmega328 used in UNO => 16MHz CPU clock , 
+
+  // Using ATmega328 used in UNO => 16MHz CPU clock ,
   // For 16-bit timer 1, 3, 4 and 5, set frequency from 0.2385 to some KHz
   // For 8-bit timer 2 (prescaler up to 1024, set frequency from 61.5Hz to some KHz
-  
+
   if (ITimer1.attachInterruptInterval(TIMER1_INTERVAL_MS, TimerHandler1, outputPin1))
   {
     Serial.println("Starting  ITimer1 OK, millis() = " + String(millis()));
     Serial.println("OutputPin1 = " + String(outputPin1) + ", address = " + String((uint32_t) &outputPin1) );
   }
   else
     Serial.println("Can't set ITimer1. Select another freq. or timer");
-    
+
   ITimer2.init();
-      
+
   if (ITimer2.attachInterruptInterval(TIMER2_INTERVAL_MS, TimerHandler2, outputPin2))
     Serial.println("Starting  ITimer2 OK, millis() = " + String(millis()));
   else
-    Serial.println("Can't set ITimer2. Select another freq. or timer");    
+    Serial.println("Can't set ITimer2. Select another freq. or timer");
 }
 
 void loop()
-{  
+{
 }