From bb20df9c654cbed77bb5007814ae06f20f08ec36 Mon Sep 17 00:00:00 2001 From: Anatoli Arkhipenko Date: Thu, 15 Oct 2015 23:33:31 -0400 Subject: TaskScheduler version 1.8.0 - added support for event completion signalling * Introduced option to compile with support for Status Rquests - ability to wait for and signal event completion * Moved all code to one header file allowing control at compile time via #define statments. --- README | 17 +- .../Scheduler_example4_StatusRequest.ino | 81 +++ .../Scheduler_example5_StatusRequest.ino | 165 +++++ extras/TaskScheduler.doc | Bin 121856 -> 129536 bytes extras/TaskScheduler.html | 670 ++++++++++++++++++++- keywords.txt | 9 + library.properties | 4 +- src/TaskScheduler.cpp | 323 ---------- src/TaskScheduler.h | 404 ++++++++++++- 9 files changed, 1310 insertions(+), 363 deletions(-) create mode 100644 examples/Scheduler_example4_StatusRequest/Scheduler_example4_StatusRequest.ino create mode 100644 examples/Scheduler_example5_StatusRequest/Scheduler_example5_StatusRequest.ino delete mode 100644 src/TaskScheduler.cpp diff --git a/README b/README index e6b12bd..2d395fa 100644 --- a/README +++ b/README @@ -1,5 +1,5 @@ Task Scheduler – cooperative multitasking for Arduino microcontrollers -Version 1.7.0: 2015-10-12 +Version 1.8.0: 2015-10-15 OVERVIEW: @@ -9,9 +9,11 @@ A lightweight implementation of cooperative multitasking (task scheduling) suppo 3. Execution of tasks in predefined sequence 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 + + Changelog: +v1.0.0: 2015-02-24 - Initial release 2015-02-28 - added delay() and disableOnLastIteration() functions 2015-03-25 - changed scheduler execute() function for a more precise delay calculation: @@ -20,16 +22,20 @@ Changelog: 3. Delay is based on the min anticipated wait until next task _AND_ the runtime of execute function itself. 2015-05-11 - added restart() and restartDelayed() functions to restart tasks which are on hold after running all iterations 2015-05-19 - completely removed delay from the scheduler since there are no power saving there. using 1 ms sleep instead + v1.4.1: 2015-09-15 - more careful placement of AVR-specific includes for sleep functions (compatibility with DUE) sleep on idle run is no longer a default and should be explicitly compiled with _TASK_SLEEP_ON_IDLE_RUN defined + v1.5.0: 2015-09-20 - access to currently executing task (for callback functions) 2015-09-20 - pass scheduler as a parameter to the task constructor to append the task to the end of the chain 2015-09-20 - option to create a task already enabled + v1.5.1: 2015-09-21 - bug fix: incorrect handling of active tasks via set() and setIterations(). Thanks to Hannes Morgenstern for catching this one + v1.6.0: 2015-09-22 - revert back to having all tasks disable on last iteration. 2015-09-22 - deprecated disableOnLastIteration method as a result @@ -41,3 +47,8 @@ v1.7.0: 2015-10-11 - disable() returns previous enable state (true if was enabled, false if was already disabled) 2015-10-11 - introduced callback functions "on enable" and "on disable". On enable runs every time enable is called, on disable runs only if task was enabled 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 + \ No newline at end of file diff --git a/examples/Scheduler_example4_StatusRequest/Scheduler_example4_StatusRequest.ino b/examples/Scheduler_example4_StatusRequest/Scheduler_example4_StatusRequest.ino new file mode 100644 index 0000000..ffe4e3a --- /dev/null +++ b/examples/Scheduler_example4_StatusRequest/Scheduler_example4_StatusRequest.ino @@ -0,0 +1,81 @@ +/** 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 + +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(); + +} diff --git a/examples/Scheduler_example5_StatusRequest/Scheduler_example5_StatusRequest.ino b/examples/Scheduler_example5_StatusRequest/Scheduler_example5_StatusRequest.ino new file mode 100644 index 0000000..d1f2e5c --- /dev/null +++ b/examples/Scheduler_example5_StatusRequest/Scheduler_example5_StatusRequest.ino @@ -0,0 +1,165 @@ +/** This test emulates querying 3 sensors once every 10 seconds, each could respond with a different delay + * (ultrasonic sensors for instance) and printing a min value of the three when all three have reported their values. + * The overall timeout of 1 second is setup as well. + * An error message needs to be printed if a timeout occurred instead of a value. + */ + + +#define _TASK_SLEEP_ON_IDLE_RUN +#define _TASK_STATUS_REQUEST + +#include + + + + +StatusRequest measure; + +Scheduler ts; + +Task tCycle(10000, -1, &CycleCallback, &ts, true); +Task tMeasure(1000, 1, &MeasureCallback, &ts, false, &MeasureEnable, &MeasureDisable); +Task tCalculate(&CalcCallback, &ts); +Task tSensor1(0, 1, &S1Callback, &ts, false, &S1Enable); +Task tSensor2(0, 1, &S2Callback, &ts, false, &S2Enable); +Task tSensor3(0, 1, &S3Callback, &ts, false, &S3Enable); + + +long distance, d1, d2, d3; + +void CycleCallback() { + Serial.println("CycleCallback: Initiating measurement cycle every 10 seconds"); + + tMeasure.restartDelayed(); +} + + + +bool MeasureEnable() { + Serial.println("MeasureEnable: Activating sensors"); + + distance = 0; + measure.setWaiting(3); // Set the StatusRequest to wait for 3 signals. + tCalculate.waitFor(&measure); + + tSensor1.restart(); + tSensor2.restart(); + tSensor3.restart(); + + return true; +} + +void MeasureCallback() { + Serial.println("MeasureCallback: Invoked by calculate task or one second later"); + + if (measure.pending()) { + tCalculate.disable(); + measure.signalComplete(-1); // signal error + Serial.println("MeasureCallback: Timeout!"); + } + else { + Serial.print("MeasureCallback: Min distance=");Serial.println(distance); + } +} + +void MeasureDisable() { + Serial.println("MeasureDisable: Cleaning up"); + + tSensor1.disable(); + tSensor2.disable(); + tSensor3.disable(); +} + + +void CalcCallback() { + Serial.println("CalcCallback: calculating"); + distance = -1; + if ( measure.getStatus() >= 0) { // only calculate if statusrequest ended successfully + distance = d1 < d2 ? d1 : d2; + distance = d3 < distance ? d3 : distance; + tMeasure.forceNextIteration(); + } +} + + +/** Simulation code for sensor 1 + * ---------------------------- + */ +bool S1Enable() { + Serial.print("S1Enable: Triggering sensor1. Delay="); + + tSensor1.setInterval( random(1200) ); // Simulating sensor delay, which could go over 1 second and cause timeout + d1 = 0; + + Serial.println( tSensor1.getInterval() ); + return true; +} + +void S1Callback() { + Serial.print("S1Callback: Emulating measurement. d1="); + d1 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement + measure.signal(); + + Serial.println(d1); +} + + +/** Simulation code for sensor 2 + * ---------------------------- + */ +bool S2Enable() { + Serial.print("S2Enable: Triggering sensor2. Delay="); + + tSensor2.setInterval( random(1200) ); // Simulating sensor delay, which could go over 1 second and cause timeout + d2 = 0; + + Serial.println( tSensor2.getInterval() ); + return true; +} + +void S2Callback() { + Serial.print("S2Callback: Emulating measurement. d2="); + d2 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement + measure.signal(); + + Serial.println(d2); +} + + +/** Simulation code for sensor 3 + * ---------------------------- + */ +bool S3Enable() { + Serial.print("S3Enable: Triggering sensor3. Delay="); + + tSensor3.setInterval( random(1200) ); // Simulating sensor delay, which could go over 1 second and cause timeout + d3 = 0; + + Serial.println( tSensor3.getInterval() ); + return true; +} + +void S3Callback() { + Serial.print("S3Callback: Emulating measurement. d3="); + d3 = random(501); // pick a value from 0 to 500 "centimeters" simulating a measurement + measure.signal(); + + Serial.println(d3); +} + + +/** Main Arduino code + * Not much is left here - everything is taken care of by the framework + */ +void setup() { + + Serial.begin(115200); + Serial.println("TaskScheduler StatusRequest Sensor Emulation Test. Complex Test."); + randomSeed(analogRead(A1)+millis()); +} + +void loop() { + + ts.execute(); + +} diff --git a/extras/TaskScheduler.doc b/extras/TaskScheduler.doc index a40aea7..fca10c0 100644 Binary files a/extras/TaskScheduler.doc and b/extras/TaskScheduler.doc differ diff --git a/extras/TaskScheduler.html b/extras/TaskScheduler.html index 96a605e..e227965 100644 --- a/extras/TaskScheduler.html +++ b/extras/TaskScheduler.html @@ -6,7 +6,7 @@ - + @@ -24,8 +24,8 @@

Task Scheduler – cooperative multitasking for Arduino microcontrollers

-

Version 1.7.0: -2015-10-12

+

Version 1.8.0: +2015-10-15


OVERVIEW:

@@ -44,6 +44,8 @@ supporting:

function)

  • Power saving via entering IDLE sleep mode between tasks are scheduled to run

    +

  • Support for task + invocation via Status Request object


    @@ -52,6 +54,8 @@ supporting:

    container concept that links together:

    1. Execution interval

      +

    2. Execution event + (Status Request)

    3. Number of execution iterations

    4. Piece of code @@ -104,7 +108,7 @@ tasks in the chain always requires immediate execution (aInterval =

      Below is the flowchart of a Task lifecycle:

      -

      +


      Note: Task @@ -124,6 +128,28 @@ to run in a truly periodical manner (in absolute time terms).


      +

      In addition to +time-only invocation, tasks can be scheduled to wait on an event +employing StatusRequest objects (more about Status Requests later).

      +

      Consider a scenario +when one task (t1) is performing a function which affects execution +of many tasks (t2, t3). In this case the task t1 will “signal” +completion of its function via Status Request object. Tasks t2 and t3 +are “waiting” on the same Status Request object. As soon as +status request completes, t2 and t3 are activated.

      +


      +

      +

      Alternative scenario is +the ne task (t1) and waiting for the completion of a number of tasks +(t2, t3). When done, t2 and t3 signal completion of their functions, +t1 is invoked. +

      +


      +

      +

      Please see the examples +at the end of this document.

      +


      +

      COMPILE PARAMETERS:

      This library could be compiled with several options. @@ -163,6 +189,15 @@ conserve power. Device in SLEEP_MODE_IDLE wakes up to all hardware and timer interrupts, so scheduling is kept current.


      +

      #define +_TASK_STATUS_REQUEST

      +

      …will compile +TaskScheduler with support for StatusRequest object. Status Requests +are objects allowing tasks to wait on an event, and signal event +completion to each other. +

      +

      +

      NOTE: above parameters are DISABLED by default, and need to be explicitly enabled.

      @@ -175,7 +210,8 @@ enabled.

      API DOCUMENTATION:


      -

      TASKS:

      +

      +TASKS:


      CREATION:

      @@ -197,7 +233,7 @@ tasks are created disabled by default.

      Task(unsigned long aInterval, long aIterations, void (*aCallback)(), Scheduler* aScheduler, bool aEnable, bool -(*aOnEnable)(), void (*aOnDisable)(),);

      +(*aOnEnable)(), void (*aOnDisable)())


      Constructor @@ -249,6 +285,18 @@ task is scheduled for execution immediately. Enable tasks with delay to defer first run of the task.


      +

      +Task(void (*aCallback)(), Scheduler* aScheduler, bool +(*aOnEnable)(), void (*aOnDisable)())

      +


      +

      +

      If +compiled with support for Status Request objects, this constructor +creates a Task for activation on event (since such tasks must run +waitFor() method, their interval, iteration and +enabled status will be set by that method.

      +


      +

      INFORMATION

      The following 3 “getter” functions return task status @@ -329,7 +377,8 @@ current pass is the last iteration.

      CONTROL:

      -


      +

      +

      void enable();


      @@ -496,16 +545,49 @@ ran through all their allocated iterations are disabled.


      +

      +void waitFor(StatusRequest* aStatusRequest);

      +

      +
      +

      +

      If +compiled with support for Status Requests, this method makes task +wait for the completion of aStatusRequest event. +

      +

      waitFor() +sets tasks interval to 0 (zero) for immediate execution +when event happens, and also sets the number of iterations to 1.

      +

      Note: +aStatusRequest should be “activated” by calling setWaiting() +method before making a task wait on it. Otherwise, the task will +execute immediately. +



      -

      TASK SCHEDULER:

      +

      StatusRequest* +getStatusRequest()

      +

      Returns +a StatusReqeust object this Task was waiting on. +

      +


      +

      +


      +

      +


      +


      -

      CREATION:

      +

      +TASK SCHEDULER:


      +

      +CREATION:

      +

      +
      +

      Scheduler()

      Default @@ -614,6 +696,97 @@ statements after execute inside the loop()


      +


      +

      +

      +STATUS REQUEST:

      +

      +
      +

      +

      +CREATION:

      +

      +
      +

      +

      StatusRequest()

      +

      +

      Default +constructor. +

      +

      Takes +no parameters. Creates Status Request object, which is assigned a +status of “completed” on creation. +

      +


      +

      +

      void +setWaiting(unsigned int aCount)

      +

      Activates +Status Request object. By default each object is set to wait on one +event only, however, if aCount is supplied, Status Request can +wait on multiple events. For instance, setWaiting(3) will wait +on three signals. An example could be waiting for completion of +measurements from 3 sensors. +

      +


      +

      +

      bool signal(int +aStatus)

      +

      Signals +completion of the event to the Status Request object, and passes a +completion code, which could be interrogated later. +

      +

      Note: + passing a negative status code to the status request +object is considered reporting an error condition, and will complete +the status request regardless of how many outstanding signals it is +still waiting for. +

      +

      Note: +only the latest status code is kept.

      +


      +

      +

      bool signalComplete +(int aStatus)

      +

      Signals +completion of ALL events to the Status Request object, and +passes a completion code, which could be interrogated later. The +status request completes regardless of how many events it is still +waiting on. +

      +


      +

      +

      bool pending() +

      +

      Returns +true if status request is still waiting for event or events to +happen.

      +


      +

      +

      bool completed () +

      +

      Returns +true if status has completed.

      +


      +

      +

      int getStatus()

      +

      Returns +the status code passed to the status request object by the signal() +and signalComplete() methods. +

      +

      Any +positive number is considered a successful completion status.

      +

      A +0 (zero) is considered a default successful completion status.

      +

      Any +negative number is considered an error code and unsuccessful +completion of a request.

      +


      +

      +


      +

      +


      +

      IMPLEMENTATION SCENARIOS AND IDEAS:


      @@ -971,12 +1144,26 @@ is the implementation using TaskScheduler


      -


      #include -<TaskScheduler.h>

      #define LEDPIN 13


      Scheduler -ts;

      +



      +

      +

      #define +_TASK_SLEEP_ON_IDLE_RUN

      +

      #include +<TaskScheduler.h>

      +


      +

      +

      #define + LEDPIN 13

      +


      +

      +


      +

      +

      Scheduler +ts;

      +


      Task -tWrapper(30000L, -1, &WrapperCallback, &ts, true);

      +tWrapper(30000, -1, &WrapperCallback, &ts, true);

      Task tBlink(5000, 1, NULL, &ts, false, &BlinkOnEnable, &BlinkOnDisable);

      @@ -986,12 +1173,16 @@ tLED(0, -1, NULL, &ts, false, NULL, &LEDOff);

      void WrapperCallback() {

      -

      tBlink.restartDelayed(); +

      +Serial.println("In +WrapperCallback");

      +

      +tBlink.restartDelayed(); // LED blinking is initiated

      - //every 30 -seconds for 5 seconds

      + //every +30 seconds for 5 seconds

      }


      @@ -1005,15 +1196,22 @@ and enable LED blinking task, which actually controls

      the hardware (LED in this example)

      bool BlinkOnEnable() {

      -

      tLED.setInterval( +

      +Serial.println("In +BlinkOnEnable");

      +

      +tLED.setInterval( 500 + random(501) );

      -

      tLED.setCallback( +

      +tLED.setCallback( &LEDOn);

      -

      tLED.enable();

      +

      +tLED.enable();


      -

      return -true; // Task should be enabled

      +

      +return true; // +Task should be enabled

      }


      @@ -1033,24 +1231,38 @@ thus executing its OnDisable method below.

      void BlinkOnDisable() {

      -

      tLED.disable();

      +

      +Serial.println("In +BlinkOnDisable");

      +

      +tLED.disable();

      }


      void LEDOn () {

      -

      digitalWrite(LEDPIN, +

      +Serial.println("In +LEDOn");

      +

      +digitalWrite(LEDPIN, HIGH);

      -

      tLED.setCallback( +

      +tLED.setCallback( &LEDOff);

      }


      void LEDOff () {

      -

      digitalWrite(LEDPIN, +

      +Serial.println("In +LEDOff");

      +

      +digitalWrite(LEDPIN, LOW);

      -

      tLED.setCallback( +

      +tLED.setCallback( &LEDOn);

      }


      @@ -1064,12 +1276,412 @@ task finishes (or disabled ahead of time)


      void -setup() {
      // put your setup code here, to run once:
      }

      void -loop() {
      // put your main code here, to run repeatedly:
      -ts.execute();
      }

      +setup() {

      +


      +

      +

      +Serial.begin(115200); + +

      +

      +pinMode(LEDPIN, +OUTPUT); +

      +

      }

      +


      +

      +

      void +loop() {

      +

      +// put your main +code here, to run repeatedly:

      +


      +

      +

      +ts.execute();

      +

      }

      +


      +

      +


      +

      +


      +

      +
        +

      1. USING + STATUS REQUEST OBJECTS +

        +
      +


      +

      +

      This +test emulates querying 3 sensors once every 10 seconds, each could +respond with a different delay (ultrasonic sensors for instance) and +printing a min value of the three when all three have reported their +values.

      +


      +

      +

      The +overall timeout of 1 second is setup as well.

      +

      An +error message needs to be printed if a timeout occurred instead of a +value.

      +

      +

      +


      +

      +


      +

      +

      #define +_TASK_SLEEP_ON_IDLE_RUN

      +

      #define +_TASK_STATUS_REQUEST

      +


      +

      +

      #include +<TaskScheduler.h>

      +


      +

      +

      StatusRequest +measure;

      +


      +

      +

      Scheduler +ts; +

      +


      +

      +

      Task +tCycle(10000, -1, &CycleCallback, &ts, true);

      +

      Task +tMeasure(1000, 1, &MeasureCallback, &ts, false, +&MeasureEnable, &MeasureDisable);

      +

      Task +tCalculate(&CalcCallback, &ts);

      +

      Task +tSensor1(0, 1, &S1Callback, &ts, false, &S1Enable);

      +

      Task +tSensor2(0, 1, &S2Callback, &ts, false, &S2Enable);

      +

      Task +tSensor3(0, 1, &S3Callback, &ts, false, &S3Enable);

      +


      +

      +


      +

      +

      long +distance, d1, d2, d3;

      +


      +

      +

      void +CycleCallback() {

      +

      +Serial.println("CycleCallback: +Initiating measurement cycle every 10 seconds");


      +

      +tMeasure.restartDelayed();

      +

      }


      +


      +

      +


      +

      +

      bool +MeasureEnable() {

      +

      +Serial.println("MeasureEnable: +Activating sensors"); +

      +


      +

      +

      +distance = 0;

      +

      +measure.setWaiting(3); +// Set the StatusRequest to wait for 3 signals. +

      +

      +tCalculate.waitFor(&measure);

      +


      +

      +

      +tSensor1.restart();

      +

      +tSensor2.restart();

      +

      +tSensor3.restart();

      +


      +

      +

      +return true;

      +

      }

      +


      +

      +

      void +MeasureCallback() {

      +

      +Serial.println("MeasureCallback: +Invoked by calculate task or one second later"); +

      +


      +

      +

      +if +(measure.pending()) {

      +

      + tCalculate.disable();

      +

      + measure.signalComplete(-1); + // signal error

      +

      + Serial.println("MeasureCallback: +Timeout!");

      +

      +}

      +

      +else {

      +

      + Serial.print("MeasureCallback: +Min distance=");Serial.println(distance);

      +

      +}

      +

      }

      +


      +

      +

      void +MeasureDisable() {

      +

      +Serial.println("MeasureDisable: +Cleaning up"); +

      +

      +

      +

      +tSensor1.disable();

      +

      +tSensor2.disable();

      +

      +tSensor3.disable();

      +

      }

      +


      +

      +


      +

      +

      void +CalcCallback() {

      +

      +Serial.println("CalcCallback: +calculating"); +

      +

      +distance = -1;

      +

      +if ( +measure.getStatus() >= 0) { // only calculate if statusrequest +ended successfully

      +

      + distance = d1 < +d2 ? d1 : d2;

      +

      + distance = d3 < +distance ? d3 : distance;

      +

      + tMeasure.forceNextIteration();

      +

      +}

      +

      }

      +


      +

      +


      +

      +

      /** +Simulation code for sensor 1

      +

      * + ----------------------------

      +

      +*/

      +

      bool +S1Enable() {

      +

      +Serial.print("S1Enable: +Triggering sensor1. Delay="); +

      +


      +

      +

      +tSensor1.setInterval( +random(1200) ); // Simulating sensor delay, which could go over 1 +second and cause timeout

      +

      +d1 = 0;

      +

      +

      +

      +Serial.println( +tSensor1.getInterval() );

      +

      +return true;

      +

      }

      +


      +

      +

      void +S1Callback() {

      +

      +Serial.print("S1Callback: +Emulating measurement. d1="); +

      +

      +d1 = random(501); // +pick a value from 0 to 500 "centimeters" simulating a +measurement +

      +

      +measure.signal();

      +

      +

      +

      +Serial.println(d1); +

      +

      }

      +


      +

      +


      +

      +

      /** +Simulation code for sensor 2

      +

      * + ----------------------------

      +

      +*/

      +

      bool +S2Enable() {

      +

      +Serial.print("S2Enable: +Triggering sensor2. Delay="); +

      +


      +

      +

      +tSensor2.setInterval( +random(1200) ); // Simulating sensor delay, which could go over 1 +second and cause timeout

      +

      +d2 = 0;

      +


      +

      +

      +Serial.println( +tSensor2.getInterval() );

      +

      +return true;

      +

      }

      +


      +

      +

      void +S2Callback() {

      +

      +Serial.print("S2Callback: +Emulating measurement. d2="); +

      +

      +d2 = random(501); // +pick a value from 0 to 500 "centimeters" simulating a +measurement

      +

      +measure.signal();

      +


      +

      +

      +Serial.println(d2); + +

      +

      }

      +


      +

      +


      +

      +

      /** +Simulation code for sensor 3

      +

      * + ----------------------------

      +

      +*/

      +

      bool +S3Enable() {

      +

      +Serial.print("S3Enable: +Triggering sensor3. Delay="); +

      +


      +

      +

      +tSensor3.setInterval( +random(1200) ); // Simulating sensor delay, which could go over 1 +second and cause timeout

      +

      +d3 = 0;

      +


      +

      +

      +Serial.println( +tSensor3.getInterval() );

      +

      +return true;

      +

      }

      +


      +

      +

      void +S3Callback() {

      +

      +Serial.print("S3Callback: +Emulating measurement. d3="); +

      +

      +d3 = random(501); // +pick a value from 0 to 500 "centimeters" simulating a +measurement

      +

      +measure.signal();

      +

      +

      +

      +Serial.println(d3); +

      +

      }

      +


      +

      +


      +

      +

      /** +Main Arduino code

      +

      * + Not much is left here - everything is taken care of by the framework

      +

      +*/

      +

      void +setup() {

      +


      +

      +

      +Serial.begin(115200);

      +

      +Serial.println("TaskScheduler +StatusRequest Sensor Emulation Test. Complex Test."); +

      +

      +randomSeed(analogRead(A1)+millis());

      +

      }

      +


      +

      +

      void +loop() {

      +

      +

      +

      +ts.execute();

      +


      +

      +

      }

      \ No newline at end of file diff --git a/keywords.txt b/keywords.txt index 0e5d354..588cd98 100644 --- a/keywords.txt +++ b/keywords.txt @@ -8,6 +8,7 @@ Task KEYWORD1 Scheduler KEYWORD1 +StatusRequest KEYWORD1 ####################################### # Methods and Functions (KEYWORD2) @@ -43,6 +44,14 @@ disableOnLastIteration KEYWORD2 getOverrun KEYWORD2 isFirstIteration KEYWORD2 isLastIteration KEYWORD2 +setWaiting KEYWORD2 +signal KEYWORD2 +signalComplete KEYWORD2 +pending KEYWORD2 +completed KEYWORD2 +getStatus KEYWORD2 +waitFor KEYWORD2 +getStatusRequest KEYWORD2 ####################################### # Constants (LITERAL1) diff --git a/library.properties b/library.properties index 7623ac5..4c6b4ba 100644 --- a/library.properties +++ b/library.properties @@ -1,9 +1,9 @@ name=TaskScheduler -version=1.7.0 +version=1.8.0 author=Anatoli Arkhipenko maintainer=Anatoli Arkhipenko sentence=A light-weight cooperative multitasking library for arduino microcontrollers. -paragraph=Enables developers to achieve pseudo multi-tasking. The library is NOT pre-emptive, and as such requires cooperative programming to be used; does NOT use any of the timers therefore does not affect PWM pins. +paragraph=Enables developers to achieve pseudo multi-tasking. The library is NOT pre-emptive, and as such requires cooperative programming to be used; does NOT use any of the timers therefore does not affect PWM pins. Includes support for status request objects, allowing tasks to wait on and signal event completion between each other. category=Schedulers url=https://github.com/arkhipenko/TaskScheduler.git architectures=* diff --git a/src/TaskScheduler.cpp b/src/TaskScheduler.cpp deleted file mode 100644 index 5cdf2f4..0000000 --- a/src/TaskScheduler.cpp +++ /dev/null @@ -1,323 +0,0 @@ -// Cooperative multitasking library for Arduino version 1.7.0 -// Copyright (c) 2015 Anatoli Arkhipenko -// - -/* ============================================ -Cooperative multitasking library code is placed under the MIT license -Copyright (c) 2015 Anatoli Arkhipenko - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -=============================================== -*/ - -#include "TaskScheduler.h" - -// ------------------ Task implementation -------------------- - -/** Constructor, uses default default values for the parameters - * so could be called with no parameters. - */ -Task::Task( unsigned long aInterval, long aIterations, void (*aCallback)(), Scheduler* aScheduler, bool aEnable, bool (*aOnEnable)(), void (*aOnDisable)() ) { - reset(); - set(aInterval, aIterations, aCallback); - setOnEnable(aOnEnable); - setOnDisable(aOnDisable); - if (aScheduler) aScheduler->addTask(*this); - if (aEnable) enable(); -} - -/** Resets (initializes) the task/ - * Task is not enabled and is taken out - * out of the execution chain as a result - */ -void Task::reset() { - iEnabled = false; - iPreviousMillis = 0; - iPrev = NULL; - iNext = NULL; - iScheduler = NULL; - iRunCounter = 0; -#ifdef _TASK_TIMECRITICAL - iOverrun = 0; -#endif -} - -/** Explicitly set Task execution parameters - * @param aInterval - execution interval in ms - * @param aIterations - number of iterations, use -1 for no limit - * @param aCallback - pointer to the callback function which executes the task actions - * @param aOnEnable - pointer to the callback function which is called on enable() - * @param aOnDisable - pointer to the callback function which is called on disable() - */ -void Task::set(unsigned long aInterval, long aIterations, void (*aCallback)(),bool (*aOnEnable)(), void (*aOnDisable)()) { - iInterval = aInterval; - iSetIterations = iIterations = aIterations; - iCallback = aCallback; - iOnEnable = aOnEnable; - iOnDisable = aOnDisable; -} - -/** Sets number of iterations for the task - * if task is enabled, schedule for immediate execution - * @param aIterations - number of iterations, use -1 for no limit - */ -void Task::setIterations(long aIterations) { - iSetIterations = iIterations = aIterations; -} - -/** Enables the task - * schedules it for execution as soon as possible, - * and resets the RunCounter back to zero - */ -void Task::enable() { - iEnabled = iOnEnable ? (*iOnEnable)() : true; - iRunCounter = 0; - iPreviousMillis = millis() - iInterval; -} - -/** Enables the task only if it was not enabled already - * Returns previous state (true if was already enabled, false if was not) - */ -bool Task::enableIfNot() { - bool previousEnabled = iEnabled; - if (!iEnabled) enable(); - return (previousEnabled); -} - -/** Enables the task - * and schedules it for execution after a delay = aInterval - */ -void Task::enableDelayed(unsigned long aDelay) { - enable(); - delay(aDelay); -} - -/** Delays Task for execution after a delay = aInterval (if task is enabled). - * leaves task enabled or disabled - * if aDelay is zero, delays for the original scheduling interval from now - */ -void Task::delay(unsigned long aDelay) { - if (!aDelay) aDelay = iInterval; - iPreviousMillis = millis() - iInterval + aDelay; -} - -/** Schedules next iteration of Task for execution immediately (if enabled) - * leaves task enabled or disabled - * Task's original schedule is shifted, and all subsequent iterations will continue from this point in time - */ -void Task::forceNextIteration() { - iPreviousMillis = millis() - iInterval; -} - -/** Sets the execution interval. - * Task execution is delayed for aInterval - * Use enable() to schedule execution ASAP - * @param aInterval - new execution interval - */ -void Task::setInterval (unsigned long aInterval) { - iInterval = aInterval; - delay(); -} - -/** Disables task - * Task will no longer be executed by the scheduler - * Returns status of the task before disable was called (i.e., if the task was already disabled) - */ -bool Task::disable() { - bool previousEnabled = iEnabled; - if (iEnabled && iOnDisable) (*iOnDisable)(); - iEnabled = false; - return (previousEnabled); -} - -/** Restarts task - * Task will run number of iterations again - */ -void Task::restart() { - iIterations = iSetIterations; - enable(); -} - -/** Restarts task delayed - * Task will run number of iterations again - */ -void Task::restartDelayed(unsigned long aDelay) { - iIterations = iSetIterations; - enableDelayed(aDelay); -} - -// ------------------ Scheduler implementation -------------------- - -/** Default constructor. - * Creates a scheduler with an empty execution chain. - */ -Scheduler::Scheduler() { - init(); -#ifdef _TASK_SLEEP_ON_IDLE_RUN - iAllowSleep = true; -#endif -} - -/** Appends task aTask to the tail of the execution chain. - * @param &aTask - reference to the Task to be appended. - * @note Task can only be part of the chain once. - */ - void Scheduler::addTask(Task& aTask) { - - aTask.iScheduler = this; -// First task situation: - if (iFirst == NULL) { - iFirst = &aTask; - aTask.iPrev = NULL; - } - else { -// This task gets linked back to the previous last one - aTask.iPrev = iLast; - iLast->iNext = &aTask; - } -// "Previous" last task gets linked to this one - as this one becomes the last one - aTask.iNext = NULL; - iLast = &aTask; -} - -/** Deletes specific Task from the execution chain - * @param &aTask - reference to the task to be deleted from the chain - */ -void Scheduler::deleteTask(Task& aTask) { - if (aTask.iPrev == NULL) { - if (aTask.iNext == NULL) { - iFirst = NULL; - iLast = NULL; - return; - } - else { - aTask.iNext->iPrev = NULL; - iFirst = aTask.iNext; - aTask.iNext = NULL; - return; - } - } - - if (aTask.iNext == NULL) { - aTask.iPrev->iNext = NULL; - iLast = aTask.iPrev; - aTask.iPrev = NULL; - return; - } - - aTask.iPrev->iNext = aTask.iNext; - aTask.iNext->iPrev = aTask.iPrev; - aTask.iPrev = NULL; - aTask.iNext = NULL; -} - -/** Disables all tasks in the execution chain - * Convenient for error situations, when the only - * task remaining active is an error processing task - */ -void Scheduler::disableAll() { - Task *current = iFirst; - while (current) { - current->disable(); - current = current->iNext; - } -} - - -/** Enables all the tasks in the execution chain - */ - void Scheduler::enableAll() { - Task *current = iFirst; - while (current) { - current->enable(); - current = current->iNext; - } -} - -/** Makes one pass through the execution chain. - * Tasks are executed in the order they were added to the chain - * There is no concept of priority - * Different pseudo "priority" could be achieved - * by running task more frequently - */ -void Scheduler::execute() { -#ifdef _TASK_SLEEP_ON_IDLE_RUN - bool idleRun = true; -#endif - - iCurrent = iFirst; - - while (iCurrent) { - do { - if (iCurrent->iEnabled) { - if (iCurrent->iIterations == 0) { - iCurrent->disable(); - break; - } - if (iCurrent->iInterval > 0) { - unsigned long targetMillis = iCurrent->iPreviousMillis + iCurrent->iInterval; - if (targetMillis <= millis()) { - if (iCurrent->iIterations > 0) iCurrent->iIterations--; // do not decrement (-1) being a signal of eternal task - iCurrent->iRunCounter++; - iCurrent->iPreviousMillis += iCurrent->iInterval; - - #ifdef _TASK_TIMECRITICAL - // Updated_previous+current should put us into the future, so iOverrun should be positive or zero. - // If negative - the task is behind (next execution time is already in the past) - iCurrent->iOverrun = (long) (iCurrent->iPreviousMillis + iCurrent->iInterval - millis()); - #endif - - if (iCurrent->iCallback) { - (*(iCurrent->iCallback))(); - #ifdef _TASK_SLEEP_ON_IDLE_RUN - idleRun = false; - #endif - } - break; - } - } - else { - if (iCurrent->iIterations > 0) iCurrent->iIterations--; // do not decrement (-1) being a signal of eternal task - iCurrent->iRunCounter++; - if (iCurrent->iCallback) { - (*(iCurrent->iCallback))(); - #ifdef _TASK_SLEEP_ON_IDLE_RUN - idleRun = false; - #endif - } - } - } - } while (0); //guaranteed single run - allows use of "break" to exit - iCurrent = iCurrent->iNext; - } - -#ifdef _TASK_SLEEP_ON_IDLE_RUN - if (idleRun && iAllowSleep) { - set_sleep_mode(SLEEP_MODE_IDLE); - sleep_enable(); - /* Now enter sleep mode. */ - sleep_mode(); - - /* The program will continue from here after the timer timeout ~1 ms */ - sleep_disable(); /* First thing to do is disable sleep. */ - } -#endif -} - - diff --git a/src/TaskScheduler.h b/src/TaskScheduler.h index c09be2f..2828bd2 100644 --- a/src/TaskScheduler.h +++ b/src/TaskScheduler.h @@ -1,7 +1,8 @@ -// Cooperative multitasking library for Arduino version 1.7.0 +// Cooperative multitasking library for Arduino version 1.8.0 // Copyright (c) 2015 Anatoli Arkhipenko // // Changelog: +// v1.0.0: // 2015-02-24 - Initial release // 2015-02-28 - added delay() and disableOnLastIteration() functions // 2015-03-25 - changed scheduler execute() function for a more precise delay calculation: @@ -10,16 +11,20 @@ // 3. Delay is based on the min anticipated wait until next task _AND_ the runtime of execute function itself. // 2015-05-11 - added restart() and restartDelayed() functions to restart tasks which are on hold after running all iterations // 2015-05-19 - completely removed delay from the scheduler since there are no power saving there. using 1 ms sleep instead +// // v1.4.1: // 2015-09-15 - more careful placement of AVR-specific includes for sleep functions (compatibility with DUE) // sleep on idle run is no longer a default and should be explicitly compiled with _TASK_SLEEP_ON_IDLE_RUN defined +// // v1.5.0: // 2015-09-20 - access to currently executing task (for callback functions) // 2015-09-20 - pass scheduler as a parameter to the task constructor to append the task to the end of the chain // 2015-09-20 - option to create a task already enabled +// // v1.5.1: // 2015-09-21 - bug fix: incorrect handling of active tasks via set() and setIterations(). // Thanks to Hannes Morgenstern for catching this one +// // v1.6.0: // 2015-09-22 - revert back to having all tasks disable on last iteration. // 2015-09-22 - deprecated disableOnLastIteration method as a result @@ -32,6 +37,11 @@ // 2015-10-11 - disable() returns previous enable state (true if was enabled, false if was already disabled) // 2015-10-11 - introduced callback functions "on enable" and "on disable". On enable runs every time enable is called, on disable runs only if task was enabled // 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 + /* ============================================ Cooperative multitasking library code is placed under the MIT license @@ -64,9 +74,14 @@ THE SOFTWARE. #ifndef _TASKSCHEDULER_H_ #define _TASKSCHEDULER_H_ -//#define _TASK_DEBUG -//#define _TASK_TIMECRITICAL -//#define _TASK_SLEEP_ON_IDLE_RUN +/** ---------------------------------------- + * The following "defines" control library functionality at compile time, + * and should be used in the main sketch depending on the functionality required + * + * #define _TASK_TIMECRITICAL // Enable monitoring scheduling overruns + * #define _TASK_SLEEP_ON_IDLE_RUN // Enable 1 ms SLEEP_IDLE powerdowns between tasks if no callback functions were invoked during the pass + * #define _TASK_STATUS_REQUEST // Compile with support for StatusRequest functionality - triggering tasks on status change events in addition to time only + */ #ifdef _TASK_SLEEP_ON_IDLE_RUN #include @@ -74,6 +89,24 @@ THE SOFTWARE. #endif +#ifdef _TASK_STATUS_REQUEST +class StatusRequest { + public: + StatusRequest() {iCount = 0; iStatus = 0; } + inline void setWaiting(unsigned int aCount = 1) { iCount = aCount; iStatus = 0; } + bool signal(int aStatus = 0); + void signalComplete(int aStatus = 0); + inline bool pending() { return (iCount != 0); } + inline bool completed() { return (iCount == 0); } + inline int getStatus() { return iStatus; } + + private: + unsigned int iCount; + int iStatus; // negative = error; zero = OK; >positive = OK with a specific status +}; +#endif + + class Task; class Scheduler { @@ -87,7 +120,7 @@ class Scheduler { void execute(); inline Task& currentTask() {return *iCurrent; } #ifdef _TASK_SLEEP_ON_IDLE_RUN - void allowSleep(bool aState) { iAllowSleep = aState; } + void allowSleep(bool aState = true) { iAllowSleep = aState; } #endif private: @@ -101,6 +134,9 @@ class Task { friend class Scheduler; public: Task(unsigned long aInterval=0, long aIterations=0, void (*aCallback)()=NULL, Scheduler* aScheduler=NULL, boolean aEnable=false, bool (*aOnEnable)()=NULL, void (*aOnDisable)()=NULL); +#ifdef _TASK_STATUS_REQUEST + Task(void (*aCallback)()=NULL, Scheduler* aScheduler=NULL, bool (*aOnEnable)()=NULL, void (*aOnDisable)()=NULL); +#endif void enable(); bool enableIfNot(); @@ -125,7 +161,12 @@ class Task { #endif inline bool isFirstIteration() { return (iRunCounter <= 1); } inline bool isLastIteration() { return (iIterations == 0); } - +#ifdef _TASK_STATUS_REQUEST + void waitFor(StatusRequest* aStatusRequest); + inline StatusRequest* getStatusRequest() {return iStatusRequest; } +#endif + + private: void reset(); @@ -143,7 +184,358 @@ class Task { void (*iOnDisable)(); Task *iPrev, *iNext; Scheduler *iScheduler; +#ifdef _TASK_STATUS_REQUEST + StatusRequest *iStatusRequest; +#endif }; +// ------------------ TaskScheduler implementation -------------------- + +/** Constructor, uses default values for the parameters + * so could be called with no parameters. + */ +Task::Task( unsigned long aInterval, long aIterations, void (*aCallback)(), Scheduler* aScheduler, bool aEnable, bool (*aOnEnable)(), void (*aOnDisable)() ) { + reset(); + set(aInterval, aIterations, aCallback, aOnEnable, aOnDisable); + if (aScheduler) aScheduler->addTask(*this); + if (aEnable) enable(); +#ifdef _TASK_STATUS_REQUEST + iStatusRequest = NULL; +#endif +} + + +#ifdef _TASK_STATUS_REQUEST + +/** Constructor with reduced parameter list for tasks created for + * StatusRequest only triggering (always immediate and only 1 iteration) + */ +Task::Task( void (*aCallback)(), Scheduler* aScheduler, bool (*aOnEnable)(), void (*aOnDisable)() ) { + reset(); + set(0, 1, aCallback, aOnEnable, aOnDisable); + if (aScheduler) aScheduler->addTask(*this); + iStatusRequest = NULL; +} + +/** Signals completion of the StatusRequest by one of the participating events + * @param: aStatus - if provided, sets the return code of the StatusRequest: negative = error, 0 (default) = OK, positive = OK with a specific status code + * Negative status will complete Status Request fully (since an error occured). + * @return: true, if StatusRequest is complete, false otherwise (still waiting for other events) + */ +bool StatusRequest::signal(int aStatus) { + if ( iCount) { // do not update the status request if it was already completed + if (iCount > 0) --iCount; + if ( (iStatus = aStatus) < 0 ) iCount = 0; // if an error is reported, the status is requested to be completed immediately + } + return (iCount == 0); +} + +void StatusRequest::signalComplete(int aStatus) { + if (iCount) { // do not update the status request if it was already completed + iCount = 0; + iStatus = aStatus; + } +} + +/** Sets a Task to wait until a particular event completes + * @param: aStatusRequest - a pointer for the StatusRequest to wait for. + * If aStatusRequest is NULL, request for waiting is ignored, and the waiting task is not enabled. + */ +void Task::waitFor(StatusRequest* aStatusRequest) { + if ( ( iStatusRequest = aStatusRequest) ) { // assign internal StatusRequest var and check if it is not NULL + setIterations(1); + setInterval(0); + enable(); + } +} + +#endif + +/** Resets (initializes) the task/ + * Task is not enabled and is taken out + * out of the execution chain as a result + */ +void Task::reset() { + iEnabled = false; + iPreviousMillis = 0; + iPrev = NULL; + iNext = NULL; + iScheduler = NULL; + iRunCounter = 0; +#ifdef _TASK_TIMECRITICAL + iOverrun = 0; +#endif +} + +/** Explicitly set Task execution parameters + * @param aInterval - execution interval in ms + * @param aIterations - number of iterations, use -1 for no limit + * @param aCallback - pointer to the callback function which executes the task actions + * @param aOnEnable - pointer to the callback function which is called on enable() + * @param aOnDisable - pointer to the callback function which is called on disable() + */ +void Task::set(unsigned long aInterval, long aIterations, void (*aCallback)(),bool (*aOnEnable)(), void (*aOnDisable)()) { + iInterval = aInterval; + iSetIterations = iIterations = aIterations; + iCallback = aCallback; + iOnEnable = aOnEnable; + iOnDisable = aOnDisable; +} + +/** Sets number of iterations for the task + * if task is enabled, schedule for immediate execution + * @param aIterations - number of iterations, use -1 for no limit + */ +void Task::setIterations(long aIterations) { + iSetIterations = iIterations = aIterations; +} + +/** Enables the task + * schedules it for execution as soon as possible, + * and resets the RunCounter back to zero + */ +void Task::enable() { + iRunCounter = 0; + iPreviousMillis = millis() - iInterval; + iEnabled = iOnEnable ? (*iOnEnable)() : true; +} + +/** Enables the task only if it was not enabled already + * Returns previous state (true if was already enabled, false if was not) + */ +bool Task::enableIfNot() { + bool previousEnabled = iEnabled; + if (!iEnabled) enable(); + return (previousEnabled); +} + +/** Enables the task + * and schedules it for execution after a delay = aInterval + */ +void Task::enableDelayed(unsigned long aDelay) { + enable(); + delay(aDelay); +} + +/** Delays Task for execution after a delay = aInterval (if task is enabled). + * leaves task enabled or disabled + * if aDelay is zero, delays for the original scheduling interval from now + */ +void Task::delay(unsigned long aDelay) { + if (!aDelay) aDelay = iInterval; + iPreviousMillis = millis() - iInterval + aDelay; +} + +/** Schedules next iteration of Task for execution immediately (if enabled) + * leaves task enabled or disabled + * Task's original schedule is shifted, and all subsequent iterations will continue from this point in time + */ +void Task::forceNextIteration() { + iPreviousMillis = millis() - iInterval; +} + +/** Sets the execution interval. + * Task execution is delayed for aInterval + * Use enable() to schedule execution ASAP + * @param aInterval - new execution interval + */ +void Task::setInterval (unsigned long aInterval) { + iInterval = aInterval; + delay(); +} + +/** Disables task + * Task will no longer be executed by the scheduler + * Returns status of the task before disable was called (i.e., if the task was already disabled) + */ +bool Task::disable() { + bool previousEnabled = iEnabled; + iEnabled = false; + if (previousEnabled && iOnDisable) (*iOnDisable)(); + return (previousEnabled); +} + +/** Restarts task + * Task will run number of iterations again + */ +void Task::restart() { + iIterations = iSetIterations; + enable(); +} + +/** Restarts task delayed + * Task will run number of iterations again + */ +void Task::restartDelayed(unsigned long aDelay) { + iIterations = iSetIterations; + enableDelayed(aDelay); +} + +// ------------------ Scheduler implementation -------------------- + +/** Default constructor. + * Creates a scheduler with an empty execution chain. + */ +Scheduler::Scheduler() { + init(); +#ifdef _TASK_SLEEP_ON_IDLE_RUN + iAllowSleep = true; +#endif +} + +/** Appends task aTask to the tail of the execution chain. + * @param &aTask - reference to the Task to be appended. + * @note Task can only be part of the chain once. + */ + void Scheduler::addTask(Task& aTask) { + + aTask.iScheduler = this; +// First task situation: + if (iFirst == NULL) { + iFirst = &aTask; + aTask.iPrev = NULL; + } + else { +// This task gets linked back to the previous last one + aTask.iPrev = iLast; + iLast->iNext = &aTask; + } +// "Previous" last task gets linked to this one - as this one becomes the last one + aTask.iNext = NULL; + iLast = &aTask; +} + +/** Deletes specific Task from the execution chain + * @param &aTask - reference to the task to be deleted from the chain + */ +void Scheduler::deleteTask(Task& aTask) { + if (aTask.iPrev == NULL) { + if (aTask.iNext == NULL) { + iFirst = NULL; + iLast = NULL; + return; + } + else { + aTask.iNext->iPrev = NULL; + iFirst = aTask.iNext; + aTask.iNext = NULL; + return; + } + } + + if (aTask.iNext == NULL) { + aTask.iPrev->iNext = NULL; + iLast = aTask.iPrev; + aTask.iPrev = NULL; + return; + } + + aTask.iPrev->iNext = aTask.iNext; + aTask.iNext->iPrev = aTask.iPrev; + aTask.iPrev = NULL; + aTask.iNext = NULL; +} + +/** Disables all tasks in the execution chain + * Convenient for error situations, when the only + * task remaining active is an error processing task + */ +void Scheduler::disableAll() { + Task *current = iFirst; + while (current) { + current->disable(); + current = current->iNext; + } +} + + +/** Enables all the tasks in the execution chain + */ + void Scheduler::enableAll() { + Task *current = iFirst; + while (current) { + current->enable(); + current = current->iNext; + } +} + +/** Makes one pass through the execution chain. + * Tasks are executed in the order they were added to the chain + * There is no concept of priority + * Different pseudo "priority" could be achieved + * by running task more frequently + */ +void Scheduler::execute() { +#ifdef _TASK_SLEEP_ON_IDLE_RUN + bool idleRun = true; +#endif + + iCurrent = iFirst; + + while (iCurrent) { + do { + if (iCurrent->iEnabled) { + if (iCurrent->iIterations == 0) { + iCurrent->disable(); + break; + } + #ifdef _TASK_STATUS_REQUEST + // If StatusRequest object was provided (not NULL) and it is still bending, this task should not run + // Otherwise, continue with execution as usual. Tasks waiting to StatusRequest usually have interval = 0, and iterations = 1 + // so they will run once immediately. + if ( iCurrent->iStatusRequest && (iCurrent->iStatusRequest)->pending() ) break; + #endif + if ( iCurrent->iInterval > 0 ) { + unsigned long targetMillis = iCurrent->iPreviousMillis + iCurrent->iInterval; + if ( targetMillis <= millis() ) { + if ( iCurrent->iIterations > 0 ) iCurrent->iIterations--; // do not decrement (-1) being a signal of eternal task + iCurrent->iRunCounter++; + iCurrent->iPreviousMillis += iCurrent->iInterval; + + #ifdef _TASK_TIMECRITICAL + // Updated_previous+current should put us into the future, so iOverrun should be positive or zero. + // If negative - the task is behind (next execution time is already in the past) + iCurrent->iOverrun = (long) (iCurrent->iPreviousMillis + iCurrent->iInterval - millis()); + #endif + + if ( iCurrent->iCallback ) { + ( *(iCurrent->iCallback) )(); + #ifdef _TASK_SLEEP_ON_IDLE_RUN + idleRun = false; + #endif + } + break; + } + } + else { + if ( iCurrent->iIterations > 0 ) iCurrent->iIterations--; // do not decrement (-1) being a signal of eternal task + iCurrent->iRunCounter++; + if ( iCurrent->iCallback ) { + ( *(iCurrent->iCallback) )(); + #ifdef _TASK_SLEEP_ON_IDLE_RUN + idleRun = false; + #endif + } + } + } + } while (0); //guaranteed single run - allows use of "break" to exit + iCurrent = iCurrent->iNext; + } + +#ifdef _TASK_SLEEP_ON_IDLE_RUN + if (idleRun && iAllowSleep) { + set_sleep_mode(SLEEP_MODE_IDLE); + sleep_enable(); + /* Now enter sleep mode. */ + sleep_mode(); + + /* The program will continue from here after the timer timeout ~1 ms */ + sleep_disable(); /* First thing to do is disable sleep. */ + } +#endif +} + + + #endif /* _TASKSCHEDULER_H_ */ -- cgit v1.2.3