port back from main libraries project

Author: davetcc

src/TaskManagerIO.cpp

@@ -7,6 +7,63 @@
 #include "TaskManagerIO.h"
 #include "ExecWithParameter.h"
 
+#ifdef BUILD_FOR_PICO_CMAKE
+critical_section_t* tm_internal::tmLock;
+
+void tm_internal::initPicoTmLock() {
+    tmLock = new critical_section_t;
+    critical_section_init(tmLock);
+}
+
+#include <cctype>
+
+void yield() {
+    sleep_us(1);
+}
+
+unsigned long millis() {
+    return to_ms_since_boot(get_absolute_time());
+}
+
+unsigned long micros() {
+    return to_us_since_boot(get_absolute_time());
+}
+
+#endif
+
+#ifdef IOA_USE_MBED
+
+volatile bool timingStarted = false;
+Timer ioaTimer;
+
+void yield() {
+
+# if !defined(PIO_NEEDS_RTOS_WORKAROUND)
+    ThisThread::yield();
+#else
+    wait(0.0000001);
+#endif
+}
+
+unsigned long millis() {
+    if(!timingStarted) {
+        timingStarted = true;
+        ioaTimer.start();
+    }
+    return ioaTimer.read_ms();
+}
+
+unsigned long micros() {
+    if(!timingStarted) {
+        timingStarted = true;
+        ioaTimer.start();
+    }
+    return (unsigned long) ioaTimer.read_high_resolution_us();
+}
+
+#endif
+
+
 TaskManager taskManager;
 
 namespace tm_internal {
@@ -47,6 +104,9 @@ ISR_ATTR void TaskManager::markInterrupted(pintype_t interruptNo) {
 }
 
 TaskManager::TaskManager() : taskBlocks {} {
+#ifdef BUILD_FOR_PICO_CMAKE
+    tm_internal::initPicoTmLock();
+#endif
 	interrupted = false;
 	tm_internal::atomicWritePtr(&first, nullptr);
 	interruptCallback = nullptr;
@@ -466,38 +526,6 @@ taskid_t TaskManager::schedule(const TimePeriod &when, Executable *execRef, bool
     }
 }
 
-#ifdef IOA_USE_MBED
-
-volatile bool timingStarted = false;
-Timer ioaTimer;
-
-void yield() {
-
-# if !defined(PIO_NEEDS_RTOS_WORKAROUND)
-    ThisThread::yield();
-#else
-    wait(0.0000001);
-#endif
-}
-
-unsigned long millis() {
-    if(!timingStarted) {
-        timingStarted = true;
-        ioaTimer.start();
-    }
-    return ioaTimer.read_ms();
-}
-
-unsigned long micros() {
-    if(!timingStarted) {
-        timingStarted = true;
-        ioaTimer.start();
-    }
-    return (unsigned long) ioaTimer.read_high_resolution_us();
-}
-
-#endif
-
 TimePeriod::TimePeriod() {
     amount = 0;
     unit = TIME_MILLIS;

src/TaskManagerIO.h

@@ -22,15 +22,19 @@ enum InterruptMode;
  * outside of task manager can add, remove and manage tasks even while task manager is running.
  */
 
-#ifdef IOA_USE_MBED
+#if defined(IOA_USE_MBED) || defined(BUILD_FOR_PICO_CMAKE)
 #include <cstdint>
-/** MBED ONLY: This defines the yield function for mbed boards, as per framework on Arduino */
+/** This defines the yield function for environments that don't have the function, as per framework on Arduino */
 void yield();
-/** MBED ONLY: This defines the millis function for mbed boards by using a timer, as per framework on Arduino */
+/** MBED ONLY: This defines the millis function for environments that don't have the function, as per framework on Arduino */
 uint32_t millis();
-/** MBED ONLY: This defines the micros function to use the standard mbed us timer, as per framework on Arduino */
+/** MBED ONLY: This defines the micros function as per framework on Arduino on environments that don't have it */
 uint32_t micros();
+#ifdef IOA_USE_MBED
 #define delayMicroseconds(x) wait_us(x)
+#else
+#define delayMicroseconds(x) sleep_us(x)
+#endif // DELAY Microseconds code
 #endif // IOA_USE_MBED
 
 /**
@@ -387,6 +391,13 @@ class TaskManager {
      */
     TimerTask* getRunningTask() { return runningTask; }
 
+#if defined(BUILD_FOR_PICO_CMAKE) || defined(ARDUINO_PICO_REVISION)
+    void rpiSleepingRunLoop() {
+        taskManager.runLoop();
+        auto toNextTime = taskManager.microsToNextTask();
+        sleep_us(toNextTime);
+    }
+#endif
     friend class TaskExecutionRecorder;
 private:
     /**

src/TaskPlatformDeps.h

@@ -24,7 +24,14 @@ class TimerTask;
 #endif // has include "io_local_definitions"
 
 // when not on mbed, we need to load Arduino.h to get the right defines for some boards.
-#ifndef __MBED__
+#if defined(BUILD_FOR_PICO_CMAKE)
+#include <pico/stdlib.h>
+#include <valarray>
+#ifndef min
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+#elif !defined(__MBED__)
 #include <Arduino.h>
 #endif
 
@@ -116,7 +123,6 @@ namespace tm_internal {
     }
 }
 #elif defined(ESP8266) || defined(ESP32) || defined(ARDUINO_PICO_REVISION)
-#include "Arduino.h"
 typedef uint8_t pintype_t;
 # define IOA_USE_ARDUINO
 #if defined(TM_ENABLE_CAPTURED_LAMBDAS)
@@ -244,7 +250,51 @@ namespace tm_internal {
     }
 }
 #endif
+#elif defined(BUILD_FOR_PICO_CMAKE)
+#include <pico/critical_section.h>
+#if defined(TM_ENABLE_CAPTURED_LAMBDAS)
+#define TM_ALLOW_CAPTURED_LAMBDA
+#endif
+typedef uint8_t pintype_t;
+namespace tm_internal {
+    typedef TimerTask *volatile TimerTaskAtomicPtr;
+    typedef volatile bool TmAtomicBool;
+    extern critical_section_t* tmLock;
+    void initPicoTmLock();
+
+    static bool atomicSwapBool(volatile bool *ptr, bool expected, bool newValue) {
+        bool ret = false;
+        critical_section_enter_blocking(tmLock);
+        if(*ptr == expected) {
+            *ptr = newValue;
+            ret = true;
+        }
+        critical_section_exit(tmLock);
+        return ret;
+    }
+
+    static void atomicWriteBool(volatile bool *ptr, bool val) {
+        critical_section_enter_blocking(tmLock);
+        *ptr = val;
+        critical_section_exit(tmLock);
+    }
+
+    inline bool atomicReadBool(volatile bool *ptr) {
+        bool ret = false;
+        critical_section_enter_blocking(tmLock);
+        ret = *ptr;
+        critical_section_exit(tmLock);
+        return ret;
+    }
+
+    inline void atomicWritePtr(TimerTaskAtomicPtr *ptr, TimerTask *newVal) {
+        *ptr = newVal;
+    }
 
+    inline TimerTask *atomicReadPtr(TimerTaskAtomicPtr *ptr) {
+        return *ptr;
+    }
+}
 #else
 // fall back to using Arduino regular logic, works for all single core boards. If we end up here for a multicore
 // board then there may be problems. Here we are in full arduino mode (AVR, MKR etc).