WIP

src/concurrency/BaseNotifiedWorkerThread.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "WorkerThread.h"
+
+namespace concurrency {
+
+/**
+ * @brief A worker thread that waits on a freertos notification
+ */
+class BaseNotifiedWorkerThread : public WorkerThread
+{
+  public:
+    /**
+     * Notify this thread so it can run
+     */
+    virtual void notify(uint32_t v = 0, eNotifyAction action = eNoAction) = 0;
+
+  protected:
+    /**
+     * The notification that was most recently used to wake the thread.  Read from loop()
+     */
+    uint32_t notification = 0;
+
+    /**
+     * What notification bits should be cleared just after we read and return them in notification?
+     *
+     * Defaults to clear all of them.
+     */
+    uint32_t clearOnRead = UINT32_MAX;
+
+    /**
+     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
+     */
+    virtual void block() = 0;
+};
+
+} // namespace concurrency

src/concurrency/FreeRtosNotifiedWorkerThread.cpp

@@ -1,19 +1,23 @@
 #include "NotifiedWorkerThread.h"
 
+#ifdef HAS_FREE_RTOS
+
 namespace concurrency {
 
 /**
  * Notify this thread so it can run
  */
-void NotifiedWorkerThread::notify(uint32_t v, eNotifyAction action)
+void FreeRtosNotifiedWorkerThread::notify(uint32_t v, eNotifyAction action)
 {
     xTaskNotify(taskHandle, v, action);
 }
 
-void NotifiedWorkerThread::block()
+void FreeRtosNotifiedWorkerThread::block()
 {
     xTaskNotifyWait(0,                                          // don't clear notification on entry
                     clearOnRead, &notification, portMAX_DELAY); // Wait forever
 }
 
 } // namespace concurrency
+
+#endif

src/concurrency/FreeRtosNotifiedWorkerThread.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "BaseNotifiedWorkerThread.h"
+
+#ifdef HAS_FREE_RTOS
+
+namespace concurrency {
+
+/**
+ * @brief A worker thread that waits on a freertos notification
+ */
+class FreeRtosNotifiedWorkerThread : public BaseNotifiedWorkerThread
+{
+  public:
+    /**
+     * Notify this thread so it can run
+     */
+    void notify(uint32_t v = 0, eNotifyAction action = eNoAction);
+
+    /**
+     * Notify from an ISR
+     *
+     * This must be inline or IRAM_ATTR on ESP32
+     */
+    inline void notifyFromISR(BaseType_t *highPriWoken, uint32_t v = 0, eNotifyAction action = eNoAction)
+    {
+        xTaskNotifyFromISR(taskHandle, v, action, highPriWoken);
+    }
+
+  protected:
+
+    /**
+     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
+     */
+    virtual void block();
+};
+
+} // namespace concurrency
+
+#endif

src/concurrency/NotifiedWorkerThread.h

@@ -1,47 +1,17 @@
 #pragma once
 
-#include "WorkerThread.h"
+#include "FreeRtosNotifiedWorkerThread.h"
+#include "PosixNotifiedWorkerThread.h"
 
-namespace concurrency {
-
-/**
- * @brief A worker thread that waits on a freertos notification
- */
-class NotifiedWorkerThread : public WorkerThread
+namespace concurrency
 {
-  public:
-    /**
-     * Notify this thread so it can run
-     */
-    void notify(uint32_t v = 0, eNotifyAction action = eNoAction);
 
-    /**
-     * Notify from an ISR
-     *
-     * This must be inline or IRAM_ATTR on ESP32
-     */
-    inline void notifyFromISR(BaseType_t *highPriWoken, uint32_t v = 0, eNotifyAction action = eNoAction)
-    {
-        xTaskNotifyFromISR(taskHandle, v, action, highPriWoken);
-    }
+#ifdef HAS_FREE_RTOS
+typedef FreeRtosNotifiedWorkerThread NotifiedWorkerThread;
+#endif
 
-  protected:
-    /**
-     * The notification that was most recently used to wake the thread.  Read from loop()
-     */
-    uint32_t notification = 0;
-
-    /**
-     * What notification bits should be cleared just after we read and return them in notification?
-     *
-     * Defaults to clear all of them.
-     */
-    uint32_t clearOnRead = UINT32_MAX;
-
-    /**
-     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
-     */
-    virtual void block();
-};
+#ifdef __unix__
+typedef PosixNotifiedWorkerThread NotifiedWorkerThread;
+#endif
 
 } // namespace concurrency

src/concurrency/PosixNotifiedWorkerThread.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "BaseNotifiedWorkerThread.h"
+
+namespace concurrency {
+
+/**
+ * @brief A worker thread that waits on a freertos notification
+ */
+class PosixNotifiedWorkerThread : public BaseNotifiedWorkerThread
+{
+  public:
+    /**
+     * Notify this thread so it can run
+     */
+    void notify(uint32_t v = 0, eNotifyAction action = eNoAction);
+
+  protected:
+
+    /**
+     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
+     */
+    virtual void block();
+};
+
+} // namespace concurrency