Create TactilityFreertos subproject (#440)

TactilityFreeRtos/Include/Tactility/Semaphore.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "Lock.h"
+#include "freertoscompat/PortCompat.h"
+#include "freertoscompat/Semaphore.h"
+
+#include <cassert>
+#include <memory>
+
+#ifdef ESP_PLATFORM
+#include <esp_log.h>
+#endif
+
+namespace tt {
+
+/**
+ * Wrapper for xSemaphoreCreateBinary (max count == 1) and xSemaphoreCreateCounting (max count > 1)
+ * Can be used from ISR context, but cannot be created/destroyed from such a context.
+ */
+class Semaphore final : public Lock {
+
+    static QueueHandle_t createHandle(uint32_t maxCount, uint32_t initialAvailable) {
+        assert(maxCount > 0U);
+        assert(initialAvailable <= maxCount);
+
+        if (maxCount == 1U) {
+            auto result = xSemaphoreCreateBinary();
+            if (initialAvailable != 0U) {
+                auto give_result = xSemaphoreGive(result);
+                assert(give_result == pdPASS);
+            }
+            return result;
+        } else {
+            return xSemaphoreCreateCounting(maxCount, initialAvailable);
+        }
+    }
+
+    std::unique_ptr<std::remove_pointer_t<QueueHandle_t>, SemaphoreHandleDeleter> handle;
+
+public:
+
+    using Lock::lock;
+
+    /**
+     * Cannot be called from ISR context.
+     * @param[in] maxAvailable The maximum count
+     * @param[in] initialAvailable The initial count
+     */
+    Semaphore(uint32_t maxAvailable, uint32_t initialAvailable) : handle(createHandle(maxAvailable, initialAvailable)) {
+        assert(xPortInIsrContext() == pdFALSE);
+        assert(handle != nullptr);
+    }
+
+    /**
+     * Cannot be called from IRQ/ISR mode.
+     * @param[in] maxAvailable The maximum count
+     */
+    explicit Semaphore(uint32_t maxAvailable) : Semaphore(maxAvailable, maxAvailable) {}
+
+    /** Cannot be called from IRQ/ISR mode. */
+    ~Semaphore() override {
+        assert(xPortInIsrContext() == pdFALSE);
+    }
+
+    Semaphore(Semaphore& other) : handle(std::move(other.handle)) {}
+
+    /**
+     * Acquire the semaphore
+     * @param[in] timeout
+     * @return true on success
+     */
+    bool acquire(TickType_t timeout) const {
+        if (xPortInIsrContext() == pdTRUE) {
+            if (timeout != 0U) {
+                return false;
+            }
+
+            BaseType_t yield = pdFALSE;
+            if (xSemaphoreTakeFromISR(handle.get(), &yield) != pdPASS) {
+                return false;
+            }
+
+            portYIELD_FROM_ISR(yield);
+            return true;
+        } else {
+            return xSemaphoreTake(handle.get(), timeout) == pdPASS;
+        }
+    }
+
+    /**
+     * Release the semaphore
+     * @return true on success
+     */
+    bool release() const {
+        if (xPortInIsrContext() == pdTRUE) {
+            BaseType_t yield = pdFALSE;
+            if (xSemaphoreGiveFromISR(handle.get(), &yield) != pdTRUE) {
+                return false;
+            }
+
+            portYIELD_FROM_ISR(yield);
+            return true;
+        } else {
+            return xSemaphoreGive(handle.get()) == pdPASS;
+        }
+    }
+
+    /** @return the acquisition count */
+    uint32_t getAvailable() const {
+        if (xPortInIsrContext() == pdTRUE) {
+            return uxSemaphoreGetCountFromISR(handle.get());
+        } else {
+            return uxSemaphoreGetCount(handle.get());
+        }
+    }
+
+    // region Lock
+
+    /** Calls acquire() */
+    bool lock(TickType_t timeout) const override { return acquire(timeout); }
+
+    /** Calls release() */
+    void unlock() const override { release(); }
+
+    // endregion
+};
+
+} // namespace