#30 small fix up on enable task #33 fix ESP8266 cache attribute

Author: dave

examples/mbedRtos/mbedExample.cpp

@@ -8,6 +8,9 @@
 
 #include <mbed.h>
 #include <TaskManagerIO.h>
+#include <TmLongSchedule.h>
+
+#define LOG_TASK_MANGER_DEBUG 0
 
 // Here we create a serial object to write log statements to.
 BufferedSerial console(USBTX, USBRX, 115200);
@@ -156,6 +159,12 @@ void setupTasks() {
     taskManager.scheduleFixedRate(2, [capturedValue]() {
         log("Execution with captured value = ", capturedValue);
     }, TIME_SECONDS);
+
+    // this shows how to create a long schedule event using the new operator, make sure the second parameter is true
+    // as this will delete the event when it completes.
+    taskManager.registerEvent(new TmLongSchedule(makeHourSchedule(0, 15), [] {
+        log("Fifteen minutes passed");
+    }), true);
 }
 
 bool exitThreads = false;
@@ -191,12 +200,14 @@ void anotherProc() {
 int main() {
     log("starting up taskmanager example");
 
+#if LOG_TASK_MANGER_DEBUG != 0
     // this is how we get diagnostic information from task manager
     // it will notify of significant events to the loggingDelegate.
     tm_internal::setLoggingDelegate([](tm_internal::TmErrorCode code, int task) {
         log("Taskmgr notification code: ", code);
         log("   -> Task num: ", task);
     });
+#endif //LOG_TASK_MANGER_DEBUG
 
     setupTasks();
 

src/TaskPlatformDeps.h

@@ -345,9 +345,7 @@ namespace tm_internal {
 // going to run on these boards should be marked with this attribute.
 //
 #undef ISR_ATTR
-#if defined(ESP8266)
-# define ISR_ATTR ICACHE_RAM_ATTR
-#elif defined(ESP32)
+#if defined(ESP8266) || defined(ESP32)
 # define ISR_ATTR IRAM_ATTR
 #else
 # define ISR_ATTR

src/TaskTypes.cpp

@@ -53,6 +53,7 @@ void TimerTask::handleScheduling(sched_t when, TimerUnit unit, bool repeating) {
     this->myTimingSchedule = when;
     this->timingInformation = repeating ? TimerUnit(unit | TM_TIME_REPEATING)  : unit;
     this->scheduledAt = (isMicrosSchedule()) ? micros() : millis();
+    taskEnabled = true;
 }
 
 void TimerTask::initialise(uint32_t when, TimerUnit unit, Executable* execCallback, bool deleteWhenDone, bool repeating) {
@@ -135,13 +136,6 @@ void TimerTask::processEvent() {
     scheduledAt = micros();
 }
 
-void TimerTask::setEnabled(bool ena) {
-    // We really don't want to do bit-masking directly on a volatile field. Copy to local first.
-    uint8_t execTy = executeMode;
-    bitWrite(execTy, EXECMODE_BIT_DISABLED, (!ena));
-    executeMode = static_cast<ExecutionType>(execTy);
-}
-
 bool TimerTask::isRepeating() const {
     if(ExecutionType(executeMode & EXECTYPE_MASK) == EXECTYPE_EVENT) {
         // if it's an event it repeats until the event is considered "complete"

src/TaskTypes.h

@@ -138,8 +138,6 @@ enum TimerUnit : uint8_t {
     TM_TIME_RUNNING = 0x20,
 };
 
-#define EXECMODE_BIT_DISABLED 4
-
 /**
  * Internal class.
  * The execution types stored internally in a task, records what kind of task is in use, and if it needs deleting
@@ -152,7 +150,6 @@ enum ExecutionType : uint8_t {
 
     EXECTYPE_MASK = 0x03,
     EXECTYPE_DELETE_ON_DONE = 0x08,
-    EXECTYPE_TASK_DISABLED = 0x10,
 
     EXECTYPE_DEL_EXECUTABLE = EXECTYPE_EXECUTABLE | EXECTYPE_DELETE_ON_DONE,
     EXECTYPE_DEL_EVENT = EXECTYPE_EVENT | EXECTYPE_DELETE_ON_DONE
@@ -198,6 +195,8 @@ class TimerTask {
     tm_internal::TmAtomicBool taskInUse;
     /** the mode in which the task executes, IE call a function, call an event or executable. Also if memory is owned */
     volatile ExecutionType executeMode;
+    /** Stores a flag to indicate if the task is enabled */
+    tm_internal::TmAtomicBool taskEnabled;
 public:
     TimerTask();
 
@@ -323,13 +322,13 @@ class TimerTask {
     /**
      * @return if the task is presently enabled - IE it is being scheduled.
      */
-    bool isEnabled() { return !bitRead(executeMode, EXECMODE_BIT_DISABLED) != 0; }
+    bool isEnabled() { return tm_internal::atomicReadBool(&taskEnabled); }
 
     /**
      * Set the task aspi either enabled or disabled. When enabled it is scheduled, otherwise it is not scheduled.
      * @param ena the enablement status
      */
-    void setEnabled(bool ena);
+    void setEnabled(bool ena) { tm_internal::atomicWriteBool(&taskEnabled, ena); }
 };
 
 #endif //TASKMANAGER_IO_TASKTYPES_H

src/TmLongSchedule.cpp

@@ -18,23 +18,24 @@ uint32_t makeDaySchedule(int days, int hours) {
 }
 
 TmLongSchedule::TmLongSchedule(uint32_t milliScheduleNext, Executable* toExecute) : milliSchedule(milliScheduleNext),
-        theExecutable(toExecute), lastScheduleTime(0), isTimerFn(false) { }
+        fnCallback(nullptr), theExecutable(toExecute), lastScheduleTime(0) { }
 
 TmLongSchedule::TmLongSchedule(uint32_t milliScheduleNext, TimerFn toExecute) : milliSchedule(milliScheduleNext),
-        fnCallback(toExecute), lastScheduleTime(0), isTimerFn(true) { }
+        fnCallback(toExecute), theExecutable(nullptr), lastScheduleTime(0) { }
 
 void TmLongSchedule::exec() {
     lastScheduleTime = millis();
 
     // never set last schedule time as 0. It is an invalid state.
     if(lastScheduleTime == 0) lastScheduleTime = 1;
 
-    if(isTimerFn && theExecutable != nullptr) {
-        fnCallback();
-    }
-    else {
+    if(theExecutable != nullptr) {
         theExecutable->exec();
     }
+    else if(fnCallback != nullptr) {
+        fnCallback();
+    }
+
 }
 
 uint32_t TmLongSchedule::timeOfNextCheck() {

src/TmLongSchedule.h

@@ -15,14 +15,20 @@
 class TmLongSchedule : public BaseEvent {
 private:
     const uint32_t milliSchedule;
-    union {
-        const TimerFn fnCallback;
-        Executable *const theExecutable;
-    };
+    const TimerFn fnCallback;
+    Executable *const theExecutable;
     uint32_t lastScheduleTime;
-    const bool isTimerFn;
 public:
+    /** Create a schedule that will call back a TimerFn functional callback.
+     * @param milliSchedule the schedule to call back on
+     * @param callee the functional callback
+     */
     TmLongSchedule(uint32_t milliSchedule, TimerFn callee);
+    /**
+     * Create schedule that will call the exec() method on an Executable
+     * @param milliSchedule the schedule to call back on
+     * @param callee the object extending from Executable
+     */
     TmLongSchedule(uint32_t milliSchedule, Executable* callee);
 
     void exec() override;