Support for taask IDs and Control Points

 * Automatically and manually assigned task IDs
 * Manually assigned Control Points within task's callback function
 * Updated existing examples
 * New example sketches

Author: arkhipenko

README

@@ -1,5 +1,5 @@
 Task Scheduler – cooperative multitasking for Arduino microcontrollers
-Version 1.8.0: 2015-10-15
+Version 1.8.1: 2015-10-22
 
 
 OVERVIEW:
@@ -10,6 +10,7 @@ A lightweight implementation of cooperative multitasking (task scheduling) suppo
 4. Dynamic change of task execution parameters (frequency, number of iterations, callback function)
 5. Power saving via entering IDLE sleep mode between tasks are scheduled to run
 6. Support for task invocation via Status Request object
+7. Support for task IDs and Control Points for error handling and watchdog timer
 
 
 Changelog:
@@ -49,6 +50,9 @@ v1.7.0:
     2015-10-12 - new Task method: forceNextIteration() - makes next iteration happen immediately during the next pass regardless how much time is left
 
 v1.8.0:
-	2015-10-13 - support for status request objects allowing tasks waiting on requests
-	2015-10-13 - moved to a single header file to allow compilation control via #defines from the main sketch
-	
+    2015-10-13 - support for status request objects allowing tasks waiting on requests
+    2015-10-13 - moved to a single header file to allow compilation control via #defines from the main sketch
+
+v1.8.1:
+    2015-10-22 - implement Task id and control points to support identification of failure points for watchdog timer logging
+	

examples/Scheduler_example/Scheduler_example.ino

@@ -1,22 +1,23 @@
+/** 
+ *  TaskScheduler Test
+ *
+ *  Initially only tasks 1 and 2 are enabled
+ *  Task1 runs every 2 seconds 10 times and then stops
+ *  Task2 runs every 3 seconds indefinitely
+ *  Task1 enables Task3 at its first run
+ *  Task3 run every 5 seconds
+ *  Task1 disables Task3 on its last iteration and changed Task2 to run every 1/2 seconds
+ *  At the end Task2 is the only task running every 1/2 seconds
+ */
+ 
+ 
 #include <TaskScheduler.h>
 
 Task t4();
 Task t1(2000, 10, &t1Callback);
 Task t2(3000, -1, &t2Callback);
 Task t3(5000, -1, &t3Callback);
 
-// Test
-// Initially only tasks 1 and 2 are enabled
-// Task1 runs every 2 seconds 10 times and then stops
-// Task2 runs every 3 seconds indefinitely
-// Task1 enables Task3 at its first run
-// Task3 run every 5 seconds
-// loop() runs every 1 second (a default scheduler delay, if no shorter tasks' interval is detected)
-// Task1 disables Task3 on its last iteration and changed Task2 to run every 1/2 seconds
-// Because Task2 interval is shorter than Scheduler default tick, loop() executes ecery 1/2 seconds now
-// At the end Task2 is the only task running every 1/2 seconds
-
-
 Scheduler runner;
 
 
@@ -74,9 +75,5 @@ void setup () {
 
 
 void loop () {
-  
   runner.execute();
-  
-  Serial.println("Loop ticks at: ");
-  Serial.println(millis());
 }

examples/Scheduler_example3/Scheduler_example3.ino

@@ -1,3 +1,12 @@
+/**
+ * TaskScheduler Test of OnEnable and OnDisable methods and illustration of using wrapper tasks for timout purposes
+ *
+ * 	A wrapper task runs every 30 seconds and initiates the test case
+ * 	Another task is run once for 5 seconds, and serves as a LED blinking timeout - 5 seconds
+ * 	Finally, a dedicated task which controls LED is running periodically until stopped, and makes the LED blink with 0.5 to 1 second interval. 
+ *
+ */
+
 #define _TASK_SLEEP_ON_IDLE_RUN
 #include <TaskScheduler.h>
 

examples/Scheduler_example4_StatusRequest/Scheduler_example4_StatusRequest.ino

@@ -1,81 +1,80 @@
-/** This test demonstrates interaction between three simple tasks via StatusRequest object.
- *  Task T1 runs every 5 seconds and signals completion of a status request st.
- *  Tasks T2 and T3 are waiting on the same request (st)
- *  Task T3 does not renew its interest in status request st, so it is only invoked once (first iteration)
- *  Task T2 is invoked every time st completes, because it renews its interest in status of status request object st every iteration of T1
- */
- 
-#define _TASK_SLEEP_ON_IDLE_RUN
-#define _TASK_STATUS_REQUEST
-
-#include <TaskScheduler.h>
-
-StatusRequest st;
-
-Scheduler ts; 
-
-Task t1(5000, 1, &Callback1, &ts, true, NULL, &Disable1);
-Task t2(&Callback2, &ts);
-Task t3(&Callback3, &ts);
-
-/** T1 callback
- *  T1 just signals completion of st every 5 seconds
- */
-void Callback1() {
-  Serial.println("T1: Signaling completion of ST");
-  st.signalComplete();
-}
-
-/** T1 On Disable callback
- *  This callback renews the status request and restarts T1 delayed to run again in 5 seconds
- */
-void Disable1() {
-  PrepareStatus();
-  t1.restartDelayed();
-}
-
-/** T2 callback
- *  Invoked when status request st completes
- */
-void Callback2() {
-  Serial.println("T2: Invoked due to completion of ST");  
-}
-
-
-/** T3 callback
- *  Invoked when status request st completes.
- *  This is only run once since T3 does not renew its interest in the status request st after first iteration
- */
- void Callback3() {
-  Serial.println("T3: Invoked due to completion of ST");  
-  
-}
-
-/** Prepare Status request st for another iteration
- *  
- */
-void PrepareStatus() {
-  st.setWaiting();         // set the statusrequest object for waiting 
-  t2.waitFor(&st);  // request tasks 1 & 2 to wait on the object st
-}
-
-
-/** Main Arduino code
- *  Not much to do here. Just init Serial and set the initial status request
- */
-void setup() {
-
-  Serial.begin(115200);
-  Serial.println("TaskScheduler: Status Request Test 1. Simple Test.");  
-  // put your setup code here, to run once:
-  PrepareStatus();
-  t3.waitFor(&st);
-
-  t1.delay();
-}
-
-void loop() {
-  // put your main code here, to run repeatedly:
-  ts.execute();
-
+/** This test demonstrates interaction between three simple tasks via StatusRequest object.
+ *  Task T1 runs every 5 seconds and signals completion of a status request st.
+ *  Tasks T2 and T3 are waiting on the same request (st)
+ *  Task T3 does not renew its interest in status request st, so it is only invoked once (first iteration)
+ *  Task T2 is invoked every time st completes, because it renews its interest in status of status request object st every iteration of T1
+ */
+ 
+#define _TASK_SLEEP_ON_IDLE_RUN
+#define _TASK_STATUS_REQUEST
+#include <TaskScheduler.h>
+
+StatusRequest st;
+
+Scheduler ts; 
+
+Task t1(5000, 1, &Callback1, &ts, true, NULL, &Disable1);
+Task t2(&Callback2, &ts);
+Task t3(&Callback3, &ts);
+
+/** T1 callback
+ *  T1 just signals completion of st every 5 seconds
+ */
+void Callback1() {
+  Serial.println("T1: Signaling completion of ST");
+  st.signalComplete();
+}
+
+/** T1 On Disable callback
+ *  This callback renews the status request and restarts T1 delayed to run again in 5 seconds
+ */
+void Disable1() {
+  PrepareStatus();
+  t1.restartDelayed();
+}
+
+/** T2 callback
+ *  Invoked when status request st completes
+ */
+void Callback2() {
+  Serial.println("T2: Invoked due to completion of ST");  
+}
+
+
+/** T3 callback
+ *  Invoked when status request st completes.
+ *  This is only run once since T3 does not renew its interest in the status request st after first iteration
+ */
+ void Callback3() {
+  Serial.println("T3: Invoked due to completion of ST");  
+  
+}
+
+/** Prepare Status request st for another iteration
+ *  
+ */
+void PrepareStatus() {
+  st.setWaiting();         // set the statusrequest object for waiting 
+  t2.waitFor(&st);  // request tasks 1 & 2 to wait on the object st
+}
+
+
+/** Main Arduino code
+ *  Not much to do here. Just init Serial and set the initial status request
+ */
+void setup() {
+
+  Serial.begin(115200);
+  Serial.println("TaskScheduler: Status Request Test 1. Simple Test.");  
+
+  PrepareStatus();
+  t3.waitFor(&st);
+
+  t1.delay();
+}
+
+void loop() {
+
+  ts.execute();
+
 }

examples/Scheduler_example6_IDLE/Scheduler_example6_IDLE.ino

@@ -0,0 +1,77 @@
+
+/**
+ * This is a test to prove that processor really goes into IDLE sleep.
+ * For this setup:
+ * 
+ *
+ 
+Task c(10, -1, &Count, &ts);
+Task t(10000, 1, NULL, &ts, true, &tOn, &tOff);
+
+The result are:
+
+1): With #define _TASK_SLEEP_ON_IDLE_RUN enabled
+Start
+c1=10771
+c2=1001
+
+
+and
+
+2): With #define _TASK_SLEEP_ON_IDLE_RUN disabled (commented out)
+Start
+c1=529783
+c2=1001
+
+C1 is scenario 2) is much higher than in scenario 1) because processor is put to sleep for 1), but not for 2)
+
+ */
+
+
+/**
+ * Compile and run once with _TASK_SLEEP_ON_IDLE_RUN enabled, then with _TASK_SLEEP_ON_IDLE_RUN disabled.
+ * Compare the results.
+ */
+ 
+//#define _TASK_SLEEP_ON_IDLE_RUN
+#include <TaskScheduler.h>
+
+Scheduler ts;
+
+Task c(10, -1, &Count, &ts);
+Task t(10000, 1, NULL, &ts, true, &tOn, &tOff);
+
+
+volatile unsigned long c1, c2;
+bool tOn() {
+  c1 = 0;
+  c2 = 0;
+  c.enable(); 
+  
+  return true;
+}
+
+void tOff() {
+  c.disable();
+  Serial.print("c1=");Serial.println(c1);
+  Serial.print("c2=");Serial.println(c2);
+}
+
+void setup() {
+  // put your setup code here, to run once:
+  Serial.begin(115200);
+  Serial.println("Start");
+  t.delay();
+ // ts.allowSleep(false);
+}
+
+void Count() {
+  c2++;
+}
+
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  ts.execute();
+  c1++;
+}