GitHub - khoih-prog/SAMD_TimerInterrupt at v1.10.1

 #if !( defined(ARDUINO_SAMD_ZERO) || defined(ARDUINO_SAMD_MKR1000) || defined(ARDUINO_SAMD_MKRWIFI1010) \
 || defined(ARDUINO_SAMD_NANO_33_IOT) || defined(ARDUINO_SAMD_MKRFox1200) || defined(ARDUINO_SAMD_MKRWAN1300) || defined(ARDUINO_SAMD_MKRWAN1310) \
 || defined(ARDUINO_SAMD_MKRGSM1400) || defined(ARDUINO_SAMD_MKRNB1500) || defined(ARDUINO_SAMD_MKRVIDOR4000) \
 || defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS) || defined(__SAMD51__) || defined(__SAMD51J20A__) \
 || defined(__SAMD51J19A__) || defined(__SAMD51G19A__) || defined(__SAMD51P19A__) \
 || defined(__SAMD21E15A__) || defined(__SAMD21E16A__) || defined(__SAMD21E17A__) || defined(__SAMD21E18A__) \
 || defined(__SAMD21G15A__) || defined(__SAMD21G16A__) || defined(__SAMD21G17A__) || defined(__SAMD21G18A__) \
 || defined(__SAMD21J15A__) || defined(__SAMD21J16A__) || defined(__SAMD21J17A__) || defined(__SAMD21J18A__) )
 #error This code is designed to run on SAMD21/SAMD51 platform! Please check your Tools->Board setting.
 #endif

 /////////////////////////////////////////////////////////////////

 // These define's must be placed at the beginning before #include "SAMDTimerInterrupt.h"
 // _TIMERINTERRUPT_LOGLEVEL_ from 0 to 4
 // Don't define _TIMERINTERRUPT_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
 // Don't define TIMER_INTERRUPT_DEBUG > 2. Only for special ISR debugging only. Can hang the system.
 #define TIMER_INTERRUPT_DEBUG 0
 #define _TIMERINTERRUPT_LOGLEVEL_ 0

 // Select only one to be true for SAMD21. Must must be placed at the beginning before #include "SAMDTimerInterrupt.h"
 #define USING_TIMER_TC3 true // Only TC3 can be used for SAMD51
 #define USING_TIMER_TC4 false // Not to use with Servo library
 #define USING_TIMER_TC5 false
 #define USING_TIMER_TCC false
 #define USING_TIMER_TCC1 false
 #define USING_TIMER_TCC2 false // Don't use this, can crash on some boards

 // Uncomment To test if conflict with Servo library
 //#include "Servo.h"

 /////////////////////////////////////////////////////////////////

 // To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
 #include "SAMDTimerInterrupt.h"

 // To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
 #include "SAMD_ISR_Timer.h"

 #include <SimpleTimer.h> // https://github.com/jfturcot/SimpleTimer

 #ifndef LED_BUILTIN
 #define LED_BUILTIN 13
 #endif

 #ifndef LED_BLUE
 #define LED_BLUE 2
 #endif

 #ifndef LED_RED
 #define LED_RED 3
 #endif

 // TC3, TC4, TC5 max permissible HW_TIMER_INTERVAL_US is 1398101 us, larger will overflow, therefore not permitted
 // Use TCC, TCC1, TCC2 for longer HW_TIMER_INTERVAL_US
 #define HW_TIMER_INTERVAL_US 10000L

 volatile uint32_t startMillis = 0;

 ///////////////////////////////////////////////

 #if (TIMER_INTERRUPT_USING_SAMD21)

 #if USING_TIMER_TC3
 #define SELECTED_TIMER TIMER_TC3
 #elif USING_TIMER_TC4
 #define SELECTED_TIMER TIMER_TC4
 #elif USING_TIMER_TC5
 #define SELECTED_TIMER TIMER_TC5
 #elif USING_TIMER_TCC
 #define SELECTED_TIMER TIMER_TCC
 #elif USING_TIMER_TCC1
 #define SELECTED_TIMER TIMER_TCC1
 #elif USING_TIMER_TCC2
 #define SELECTED_TIMER TIMER_TCC
 #else
 #error You have to select 1 Timer
 #endif

 #else

 #if !(USING_TIMER_TC3)
 #error You must select TC3 for SAMD51
 #endif

 #define SELECTED_TIMER TIMER_TC3

 #endif

 // Init selected SAMD timer
 SAMDTimer ITimer(SELECTED_TIMER);

 ////////////////////////////////////////////////

 // Init SAMD_ISR_Timer
 // Each SAMD_ISR_Timer can service 16 different ISR-based timers
 SAMD_ISR_Timer ISR_Timer;

 #define LED_TOGGLE_INTERVAL_MS 2000L

 void TimerHandler()
 {
 static bool toggle = false;
 static int timeRun = 0;

 ISR_Timer.run();

 // Toggle LED every LED_TOGGLE_INTERVAL_MS = 2000ms = 2s
 if (++timeRun == ((LED_TOGGLE_INTERVAL_MS * 1000) / HW_TIMER_INTERVAL_US) )
 {
 timeRun = 0;

 //timer interrupt toggles pin LED_BUILTIN
 digitalWrite(LED_BUILTIN, toggle);
 toggle = !toggle;
 }
 }

 /////////////////////////////////////////////////

 #define NUMBER_ISR_TIMERS 16

 typedef void (*irqCallback) ();

 /////////////////////////////////////////////////

 #define USE_COMPLEX_STRUCT true

 #if USE_COMPLEX_STRUCT

 typedef struct
 {
 irqCallback irqCallbackFunc;
 uint32_t TimerInterval;
 unsigned long deltaMillis;
 unsigned long previousMillis;
 } ISRTimerData;

 // In NRF52, avoid doing something fancy in ISR, for example Serial.print()
 // The pure simple Serial.prints here are just for demonstration and testing. Must be eliminate in working environment
 // Or you can get this run-time error / crash

 void doingSomething(int index);

 #else

 volatile unsigned long deltaMillis [NUMBER_ISR_TIMERS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 volatile unsigned long previousMillis [NUMBER_ISR_TIMERS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

 // You can assign any interval for any timer here, in milliseconds
 uint32_t TimerInterval[NUMBER_ISR_TIMERS] =
 {
 5000L, 10000L, 15000L, 20000L, 25000L, 30000L, 35000L, 40000L,
 45000L, 50000L, 55000L, 60000L, 65000L, 70000L, 75000L, 80000L
 };

 void doingSomething(int index)
 {
 unsigned long currentMillis = millis();

 deltaMillis[index] = currentMillis - previousMillis[index];
 previousMillis[index] = currentMillis;
 }

 #endif

 ////////////////////////////////////
 // Shared
 ////////////////////////////////////

 void doingSomething0()
 {
 doingSomething(0);
 }

 void doingSomething1()
 {
 doingSomething(1);
 }

 void doingSomething2()
 {
 doingSomething(2);
 }

 void doingSomething3()
 {
 doingSomething(3);
 }

 void doingSomething4()
 {
 doingSomething(4);
 }

 void doingSomething5()
 {
 doingSomething(5);
 }

 void doingSomething6()
 {
 doingSomething(6);
 }

 void doingSomething7()
 {
 doingSomething(7);
 }

 void doingSomething8()
 {
 doingSomething(8);
 }

 void doingSomething9()
 {
 doingSomething(9);
 }

 void doingSomething10()
 {
 doingSomething(10);
 }

 void doingSomething11()
 {
 doingSomething(11);
 }

 void doingSomething12()
 {
 doingSomething(12);
 }

 void doingSomething13()
 {
 doingSomething(13);
 }

 void doingSomething14()
 {
 doingSomething(14);
 }

 void doingSomething15()
 {
 doingSomething(15);
 }

 #if USE_COMPLEX_STRUCT

 ISRTimerData curISRTimerData[NUMBER_ISR_TIMERS] =
 {
 //irqCallbackFunc, TimerInterval, deltaMillis, previousMillis
 { doingSomething0, 5000L, 0, 0 },
 { doingSomething1, 10000L, 0, 0 },
 { doingSomething2, 15000L, 0, 0 },
 { doingSomething3, 20000L, 0, 0 },
 { doingSomething4, 25000L, 0, 0 },
 { doingSomething5, 30000L, 0, 0 },
 { doingSomething6, 35000L, 0, 0 },
 { doingSomething7, 40000L, 0, 0 },
 { doingSomething8, 45000L, 0, 0 },
 { doingSomething9, 50000L, 0, 0 },
 { doingSomething10, 55000L, 0, 0 },
 { doingSomething11, 60000L, 0, 0 },
 { doingSomething12, 65000L, 0, 0 },
 { doingSomething13, 70000L, 0, 0 },
 { doingSomething14, 75000L, 0, 0 },
 { doingSomething15, 80000L, 0, 0 }
 };

 void doingSomething(int index)
 {
 unsigned long currentMillis = millis();

 curISRTimerData[index].deltaMillis = currentMillis - curISRTimerData[index].previousMillis;
 curISRTimerData[index].previousMillis = currentMillis;
 }

 #else

 irqCallback irqCallbackFunc[NUMBER_ISR_TIMERS] =
 {
 doingSomething0, doingSomething1, doingSomething2, doingSomething3,
 doingSomething4, doingSomething5, doingSomething6, doingSomething7,
 doingSomething8, doingSomething9, doingSomething10, doingSomething11,
 doingSomething12, doingSomething13, doingSomething14, doingSomething15
 };

 #endif
 ///////////////////////////////////////////

 #define SIMPLE_TIMER_MS 2000L

 // Init SimpleTimer
 SimpleTimer simpleTimer;

 // Here is software Timer, you can do somewhat fancy stuffs without many issues.
 // But always avoid
 // 1. Long delay() it just doing nothing and pain-without-gain wasting CPU power.Plan and design your code / strategy ahead
 // 2. Very long "do", "while", "for" loops without predetermined exit time.
 void simpleTimerDoingSomething2s()
 {
 static unsigned long previousMillis = startMillis;

 unsigned long currMillis = millis();

 Serial.print(F("SimpleTimer : ")); Serial.print(SIMPLE_TIMER_MS / 1000);
 Serial.print(F(", ms : ")); Serial.print(currMillis);
 Serial.print(F(", Dms : ")); Serial.println(currMillis - previousMillis);

 for (uint16_t i = 0; i < NUMBER_ISR_TIMERS; i++)
 {
 #if USE_COMPLEX_STRUCT
 Serial.print(F("Timer : ")); Serial.print(i);
 Serial.print(F(", programmed : ")); Serial.print(curISRTimerData[i].TimerInterval);
 Serial.print(F(", actual : ")); Serial.println(curISRTimerData[i].deltaMillis);
 #else
 Serial.print(F("Timer : ")); Serial.print(i);
 Serial.print(F(", programmed : ")); Serial.print(TimerInterval[i]);
 Serial.print(F(", actual : ")); Serial.println(deltaMillis[i]);
 #endif
 }

 previousMillis = currMillis;
 }

 void setup()
 {
 pinMode(LED_BUILTIN, OUTPUT);

 Serial.begin(115200);
 while (!Serial && millis() < 5000);

 delay(100);

 Serial.print(F("\nStarting ISR_16_Timers_Array_Complex on ")); Serial.println(BOARD_NAME);
 Serial.println(SAMD_TIMER_INTERRUPT_VERSION);
 Serial.print(F("CPU Frequency = ")); Serial.print(F_CPU / 1000000); Serial.println(F(" MHz"));

 // Interval in microsecs
 if (ITimer.attachInterruptInterval(HW_TIMER_INTERVAL_US, TimerHandler))
 {
 startMillis = millis();
 Serial.print(F("Starting ITimer OK, millis() = ")); Serial.println(startMillis);
 }
 else
 Serial.println(F("Can't set ITimer. Select another freq. or timer"));

 startMillis = millis();

 // Just to demonstrate, don't use too many ISR Timers if not absolutely necessary
 // You can use up to 16 timer for each ISR_Timer
 for (uint16_t i = 0; i < NUMBER_ISR_TIMERS; i++)
 {
 #if USE_COMPLEX_STRUCT
 curISRTimerData[i].previousMillis = startMillis;
 ISR_Timer.setInterval(curISRTimerData[i].TimerInterval, curISRTimerData[i].irqCallbackFunc);
 #else
 previousMillis[i] = millis();
 ISR_Timer.setInterval(TimerInterval[i], irqCallbackFunc[i]);
 #endif
 }

 // You need this timer for non-critical tasks. Avoid abusing ISR if not absolutely necessary.
 simpleTimer.setInterval(SIMPLE_TIMER_MS, simpleTimerDoingSomething2s);
 }

 #define BLOCKING_TIME_MS 10000L

 void loop()
 {
 // This unadvised blocking task is used to demonstrate the blocking effects onto the execution and accuracy to Software timer
 // You see the time elapse of ISR_Timer still accurate, whereas very unaccurate for Software Timer
 // The time elapse for 2000ms software timer now becomes 3000ms (BLOCKING_TIME_MS)
 // While that of ISR_Timer is still prefect.
 delay(BLOCKING_TIME_MS);

 // You need this Software timer for non-critical tasks. Avoid abusing ISR if not absolutely necessary
 // You don't need to and never call ISR_Timer.run() here in the loop(). It's already handled by ISR timer.
 simpleTimer.run();
 }
Name		Name	Last commit message	Last commit date
Latest commit History 72 Commits
.github		.github
LibraryPatches		LibraryPatches
Packages_Patches		Packages_Patches
examples		examples
platformio		platformio
src		src
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
changelog.md		changelog.md
keywords.txt		keywords.txt
library.json		library.json
library.properties		library.properties
	#if !( defined(ARDUINO_SAMD_ZERO) \|\| defined(ARDUINO_SAMD_MKR1000) \|\| defined(ARDUINO_SAMD_MKRWIFI1010) \
	\|\| defined(ARDUINO_SAMD_NANO_33_IOT) \|\| defined(ARDUINO_SAMD_MKRFox1200) \|\| defined(ARDUINO_SAMD_MKRWAN1300) \|\| defined(ARDUINO_SAMD_MKRWAN1310) \
	\|\| defined(ARDUINO_SAMD_MKRGSM1400) \|\| defined(ARDUINO_SAMD_MKRNB1500) \|\| defined(ARDUINO_SAMD_MKRVIDOR4000) \
	\|\| defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS) \|\| defined(__SAMD51__) \|\| defined(__SAMD51J20A__) \
	\|\| defined(__SAMD51J19A__) \|\| defined(__SAMD51G19A__) \|\| defined(__SAMD51P19A__) \
	\|\| defined(__SAMD21E15A__) \|\| defined(__SAMD21E16A__) \|\| defined(__SAMD21E17A__) \|\| defined(__SAMD21E18A__) \
	\|\| defined(__SAMD21G15A__) \|\| defined(__SAMD21G16A__) \|\| defined(__SAMD21G17A__) \|\| defined(__SAMD21G18A__) \
	\|\| defined(__SAMD21J15A__) \|\| defined(__SAMD21J16A__) \|\| defined(__SAMD21J17A__) \|\| defined(__SAMD21J18A__) )
	#error This code is designed to run on SAMD21/SAMD51 platform! Please check your Tools->Board setting.
	#endif

	/////////////////////////////////////////////////////////////////

	// These define's must be placed at the beginning before #include "SAMDTimerInterrupt.h"
	// _TIMERINTERRUPT_LOGLEVEL_ from 0 to 4
	// Don't define _TIMERINTERRUPT_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system.
	// Don't define TIMER_INTERRUPT_DEBUG > 2. Only for special ISR debugging only. Can hang the system.
	#define TIMER_INTERRUPT_DEBUG 0
	#define _TIMERINTERRUPT_LOGLEVEL_ 0

	// Select only one to be true for SAMD21. Must must be placed at the beginning before #include "SAMDTimerInterrupt.h"
	#define USING_TIMER_TC3 true // Only TC3 can be used for SAMD51
	#define USING_TIMER_TC4 false // Not to use with Servo library
	#define USING_TIMER_TC5 false
	#define USING_TIMER_TCC false
	#define USING_TIMER_TCC1 false
	#define USING_TIMER_TCC2 false // Don't use this, can crash on some boards

	// Uncomment To test if conflict with Servo library
	//#include "Servo.h"

	/////////////////////////////////////////////////////////////////

	// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
	#include "SAMDTimerInterrupt.h"

	// To be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
	#include "SAMD_ISR_Timer.h"

	#include <SimpleTimer.h> // https://github.com/jfturcot/SimpleTimer

	#ifndef LED_BUILTIN
	#define LED_BUILTIN 13
	#endif

	#ifndef LED_BLUE
	#define LED_BLUE 2
	#endif

	#ifndef LED_RED
	#define LED_RED 3
	#endif

	// TC3, TC4, TC5 max permissible HW_TIMER_INTERVAL_US is 1398101 us, larger will overflow, therefore not permitted
	// Use TCC, TCC1, TCC2 for longer HW_TIMER_INTERVAL_US
	#define HW_TIMER_INTERVAL_US 10000L

	volatile uint32_t startMillis = 0;

	///////////////////////////////////////////////

	#if (TIMER_INTERRUPT_USING_SAMD21)

	#if USING_TIMER_TC3
	#define SELECTED_TIMER TIMER_TC3
	#elif USING_TIMER_TC4
	#define SELECTED_TIMER TIMER_TC4
	#elif USING_TIMER_TC5
	#define SELECTED_TIMER TIMER_TC5
	#elif USING_TIMER_TCC
	#define SELECTED_TIMER TIMER_TCC
	#elif USING_TIMER_TCC1
	#define SELECTED_TIMER TIMER_TCC1
	#elif USING_TIMER_TCC2
	#define SELECTED_TIMER TIMER_TCC
	#else
	#error You have to select 1 Timer
	#endif

	#else

	#if !(USING_TIMER_TC3)
	#error You must select TC3 for SAMD51
	#endif

	#define SELECTED_TIMER TIMER_TC3

	#endif

	// Init selected SAMD timer
	SAMDTimer ITimer(SELECTED_TIMER);

	////////////////////////////////////////////////

	// Init SAMD_ISR_Timer
	// Each SAMD_ISR_Timer can service 16 different ISR-based timers
	SAMD_ISR_Timer ISR_Timer;

	#define LED_TOGGLE_INTERVAL_MS 2000L

	void TimerHandler()
	{
	static bool toggle = false;
	static int timeRun = 0;

	ISR_Timer.run();

	// Toggle LED every LED_TOGGLE_INTERVAL_MS = 2000ms = 2s
	if (++timeRun == ((LED_TOGGLE_INTERVAL_MS * 1000) / HW_TIMER_INTERVAL_US) )
	{
	timeRun = 0;

	//timer interrupt toggles pin LED_BUILTIN
	digitalWrite(LED_BUILTIN, toggle);
	toggle = !toggle;
	}
	}

	/////////////////////////////////////////////////

	#define NUMBER_ISR_TIMERS 16

	typedef void (*irqCallback) ();

	/////////////////////////////////////////////////

	#define USE_COMPLEX_STRUCT true

	#if USE_COMPLEX_STRUCT

	typedef struct
	{
	irqCallback irqCallbackFunc;
	uint32_t TimerInterval;
	unsigned long deltaMillis;
	unsigned long previousMillis;
	} ISRTimerData;

	// In NRF52, avoid doing something fancy in ISR, for example Serial.print()
	// The pure simple Serial.prints here are just for demonstration and testing. Must be eliminate in working environment
	// Or you can get this run-time error / crash

	void doingSomething(int index);

	#else

	volatile unsigned long deltaMillis [NUMBER_ISR_TIMERS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	volatile unsigned long previousMillis [NUMBER_ISR_TIMERS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

	// You can assign any interval for any timer here, in milliseconds
	uint32_t TimerInterval[NUMBER_ISR_TIMERS] =
	{
	5000L, 10000L, 15000L, 20000L, 25000L, 30000L, 35000L, 40000L,
	45000L, 50000L, 55000L, 60000L, 65000L, 70000L, 75000L, 80000L
	};

	void doingSomething(int index)
	{
	unsigned long currentMillis = millis();

	deltaMillis[index] = currentMillis - previousMillis[index];
	previousMillis[index] = currentMillis;
	}

	#endif

	////////////////////////////////////
	// Shared
	////////////////////////////////////

	void doingSomething0()
	{
	doingSomething(0);
	}

	void doingSomething1()
	{
	doingSomething(1);
	}

	void doingSomething2()
	{
	doingSomething(2);
	}

	void doingSomething3()
	{
	doingSomething(3);
	}

	void doingSomething4()
	{
	doingSomething(4);
	}

	void doingSomething5()
	{
	doingSomething(5);
	}

	void doingSomething6()
	{
	doingSomething(6);
	}

	void doingSomething7()
	{
	doingSomething(7);
	}

	void doingSomething8()
	{
	doingSomething(8);
	}

	void doingSomething9()
	{
	doingSomething(9);
	}

	void doingSomething10()
	{
	doingSomething(10);
	}

	void doingSomething11()
	{
	doingSomething(11);
	}

	void doingSomething12()
	{
	doingSomething(12);
	}

	void doingSomething13()
	{
	doingSomething(13);
	}

	void doingSomething14()
	{
	doingSomething(14);
	}

	void doingSomething15()
	{
	doingSomething(15);
	}

	#if USE_COMPLEX_STRUCT

	ISRTimerData curISRTimerData[NUMBER_ISR_TIMERS] =
	{
	//irqCallbackFunc, TimerInterval, deltaMillis, previousMillis
	{ doingSomething0, 5000L, 0, 0 },
	{ doingSomething1, 10000L, 0, 0 },
	{ doingSomething2, 15000L, 0, 0 },
	{ doingSomething3, 20000L, 0, 0 },
	{ doingSomething4, 25000L, 0, 0 },
	{ doingSomething5, 30000L, 0, 0 },
	{ doingSomething6, 35000L, 0, 0 },
	{ doingSomething7, 40000L, 0, 0 },
	{ doingSomething8, 45000L, 0, 0 },
	{ doingSomething9, 50000L, 0, 0 },
	{ doingSomething10, 55000L, 0, 0 },
	{ doingSomething11, 60000L, 0, 0 },
	{ doingSomething12, 65000L, 0, 0 },
	{ doingSomething13, 70000L, 0, 0 },
	{ doingSomething14, 75000L, 0, 0 },
	{ doingSomething15, 80000L, 0, 0 }
	};

	void doingSomething(int index)
	{
	unsigned long currentMillis = millis();

	curISRTimerData[index].deltaMillis = currentMillis - curISRTimerData[index].previousMillis;
	curISRTimerData[index].previousMillis = currentMillis;
	}

	#else

	irqCallback irqCallbackFunc[NUMBER_ISR_TIMERS] =
	{
	doingSomething0, doingSomething1, doingSomething2, doingSomething3,
	doingSomething4, doingSomething5, doingSomething6, doingSomething7,
	doingSomething8, doingSomething9, doingSomething10, doingSomething11,
	doingSomething12, doingSomething13, doingSomething14, doingSomething15
	};

	#endif
	///////////////////////////////////////////

	#define SIMPLE_TIMER_MS 2000L

	// Init SimpleTimer
	SimpleTimer simpleTimer;

	// Here is software Timer, you can do somewhat fancy stuffs without many issues.
	// But always avoid
	// 1. Long delay() it just doing nothing and pain-without-gain wasting CPU power.Plan and design your code / strategy ahead
	// 2. Very long "do", "while", "for" loops without predetermined exit time.
	void simpleTimerDoingSomething2s()
	{
	static unsigned long previousMillis = startMillis;

	unsigned long currMillis = millis();

	Serial.print(F("SimpleTimer : ")); Serial.print(SIMPLE_TIMER_MS / 1000);
	Serial.print(F(", ms : ")); Serial.print(currMillis);
	Serial.print(F(", Dms : ")); Serial.println(currMillis - previousMillis);

	for (uint16_t i = 0; i < NUMBER_ISR_TIMERS; i++)
	{
	#if USE_COMPLEX_STRUCT
	Serial.print(F("Timer : ")); Serial.print(i);
	Serial.print(F(", programmed : ")); Serial.print(curISRTimerData[i].TimerInterval);
	Serial.print(F(", actual : ")); Serial.println(curISRTimerData[i].deltaMillis);
	#else
	Serial.print(F("Timer : ")); Serial.print(i);
	Serial.print(F(", programmed : ")); Serial.print(TimerInterval[i]);
	Serial.print(F(", actual : ")); Serial.println(deltaMillis[i]);
	#endif
	}

	previousMillis = currMillis;
	}

	void setup()
	{
	pinMode(LED_BUILTIN, OUTPUT);

	Serial.begin(115200);
	while (!Serial && millis() < 5000);

	delay(100);

	Serial.print(F("\nStarting ISR_16_Timers_Array_Complex on ")); Serial.println(BOARD_NAME);
	Serial.println(SAMD_TIMER_INTERRUPT_VERSION);
	Serial.print(F("CPU Frequency = ")); Serial.print(F_CPU / 1000000); Serial.println(F(" MHz"));

	// Interval in microsecs
	if (ITimer.attachInterruptInterval(HW_TIMER_INTERVAL_US, TimerHandler))
	{
	startMillis = millis();
	Serial.print(F("Starting ITimer OK, millis() = ")); Serial.println(startMillis);
	}
	else
	Serial.println(F("Can't set ITimer. Select another freq. or timer"));

	startMillis = millis();

	// Just to demonstrate, don't use too many ISR Timers if not absolutely necessary
	// You can use up to 16 timer for each ISR_Timer
	for (uint16_t i = 0; i < NUMBER_ISR_TIMERS; i++)
	{
	#if USE_COMPLEX_STRUCT
	curISRTimerData[i].previousMillis = startMillis;
	ISR_Timer.setInterval(curISRTimerData[i].TimerInterval, curISRTimerData[i].irqCallbackFunc);
	#else
	previousMillis[i] = millis();
	ISR_Timer.setInterval(TimerInterval[i], irqCallbackFunc[i]);
	#endif
	}

	// You need this timer for non-critical tasks. Avoid abusing ISR if not absolutely necessary.
	simpleTimer.setInterval(SIMPLE_TIMER_MS, simpleTimerDoingSomething2s);
	}

	#define BLOCKING_TIME_MS 10000L

	void loop()
	{
	// This unadvised blocking task is used to demonstrate the blocking effects onto the execution and accuracy to Software timer
	// You see the time elapse of ISR_Timer still accurate, whereas very unaccurate for Software Timer
	// The time elapse for 2000ms software timer now becomes 3000ms (BLOCKING_TIME_MS)
	// While that of ISR_Timer is still prefect.
	delay(BLOCKING_TIME_MS);

	// You need this Software timer for non-critical tasks. Avoid abusing ISR if not absolutely necessary
	// You don't need to and never call ISR_Timer.run() here in the loop(). It's already handled by ISR timer.
	simpleTimer.run();
	}
_{⭐️ Tamasa}	_{Dennis van Gils}	_{generationmake}	_{thiagothimotti}	_{generationmake}	_{Alexander Golovanov}
_{Will Powell}	_{Dave Hooper}	_{Rui Marinheiro}	_{sriccardi-invn}