fixes for the posix port

src/concurrency/BinarySemaphoreFreeRTOS.cpp

@@ -0,0 +1,39 @@
+#include "concurrency/BinarySemaphoreFreeRTOS.h"
+#include "configuration.h"
+
+#ifdef HAS_FREE_RTOS
+
+namespace concurrency
+{
+
+BinarySemaphoreFreeRTOS::BinarySemaphoreFreeRTOS()
+{
+    semaphore = xSemaphoreCreateBinary();
+}
+
+BinarySemaphoreFreeRTOS::~BinarySemaphoreFreeRTOS()
+{
+    vSemaphoreDelete(semaphore);
+}
+
+/**
+ * Returns false if we were interrupted
+ */
+bool BinarySemaphoreFreeRTOS::take(uint32_t msec)
+{
+    return xSemaphoreTake(semaphore, pdMS_TO_TICKS(msec));
+}
+
+void BinarySemaphoreFreeRTOS::give()
+{
+    xSemaphoreGive(semaphore);
+}
+
+IRAM_ATTR void BinarySemaphoreFreeRTOS::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken)
+{
+    xSemaphoreGiveFromISR(semaphore, pxHigherPriorityTaskWoken);
+}
+
+} // namespace concurrency
+
+#endif

src/concurrency/BinarySemaphoreFreeRTOS.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "configuration.h"
+#include "../freertosinc.h"
+
+namespace concurrency
+{
+
+#ifdef HAS_FREE_RTOS
+
+class BinarySemaphoreFreeRTOS
+{
+    SemaphoreHandle_t semaphore;
+
+  public:
+    BinarySemaphoreFreeRTOS();
+    ~BinarySemaphoreFreeRTOS();
+
+    /**
+     * Returns false if we timed out
+     */
+    bool take(uint32_t msec);
+
+    void give();
+
+    void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
+};
+
+#endif
+
+} 

src/concurrency/BinarySemaphorePosix.cpp

@@ -0,0 +1,36 @@
+#include "concurrency/BinarySemaphorePosix.h"
+#include "configuration.h"
+
+#ifndef HAS_FREE_RTOS
+
+namespace concurrency
+{
+
+BinarySemaphorePosix::BinarySemaphorePosix()
+{
+}
+
+BinarySemaphorePosix::~BinarySemaphorePosix()
+{
+}
+
+/**
+ * Returns false if we timed out
+ */
+bool BinarySemaphorePosix::take(uint32_t msec)
+{
+    delay(msec); // FIXME
+    return false;
+}
+
+void BinarySemaphorePosix::give()
+{
+}
+
+IRAM_ATTR void BinarySemaphorePosix::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken)
+{
+}
+
+} // namespace concurrency
+
+#endif

src/concurrency/BinarySemaphorePosix.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "configuration.h"
+#include "../freertosinc.h"
+
+namespace concurrency
+{
+
+#ifndef HAS_FREE_RTOS
+
+class BinarySemaphorePosix
+{
+    // SemaphoreHandle_t semaphore;
+
+  public:
+    BinarySemaphorePosix();
+    ~BinarySemaphorePosix();
+
+    /**
+     * Returns false if we timed out
+     */
+    bool take(uint32_t msec);
+
+    void give();
+
+    void giveFromISR(BaseType_t *pxHigherPriorityTaskWoken);
+};
+
+#endif
+
+} 

src/concurrency/InterruptableDelay.cpp

@@ -6,12 +6,10 @@ namespace concurrency
 
 InterruptableDelay::InterruptableDelay()
 {
-    semaphore = xSemaphoreCreateBinary();
 }
 
 InterruptableDelay::~InterruptableDelay()
 {
-    vSemaphoreDelete(semaphore);
 }
 
 /**
@@ -23,7 +21,7 @@ bool InterruptableDelay::delay(uint32_t msec)
         // DEBUG_MSG("delay %u ", msec);
 
         // sem take will return false if we timed out (i.e. were not interrupted)
-        bool r = xSemaphoreTake(semaphore, pdMS_TO_TICKS(msec));
+        bool r = semaphore.take(msec);
 
         // DEBUG_MSG("interrupt=%d\n", r);
         return !r;
@@ -34,12 +32,12 @@ bool InterruptableDelay::delay(uint32_t msec)
 
 void InterruptableDelay::interrupt()
 {
-    xSemaphoreGive(semaphore);
+    semaphore.give();
 }
 
 IRAM_ATTR void InterruptableDelay::interruptFromISR(BaseType_t *pxHigherPriorityTaskWoken)
 {
-    xSemaphoreGiveFromISR(semaphore, pxHigherPriorityTaskWoken);
+    semaphore.giveFromISR(pxHigherPriorityTaskWoken);
 }
 
 } // namespace concurrency

src/concurrency/InterruptableDelay.h

@@ -2,6 +2,15 @@
 
 #include "../freertosinc.h"
 
+
+#ifdef HAS_FREE_RTOS
+#include "concurrency/BinarySemaphoreFreeRTOS.h"
+#define BinarySemaphore BinarySemaphoreFreeRTOS
+#else
+#include "concurrency/BinarySemaphorePosix.h"
+#define BinarySemaphore BinarySemaphorePosix
+#endif
+
 namespace concurrency
 {
 
@@ -14,7 +23,7 @@ namespace concurrency
  */
 class InterruptableDelay
 {
-    SemaphoreHandle_t semaphore;
+    BinarySemaphore semaphore;
 
   public:
     InterruptableDelay();