From c5969eff03a23fd612693b172fa4fc3dff0e3a75 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 18:08:57 -0300 Subject: [PATCH 01/11] feat: Add dynamic Tasks and more methods --- src/RTOScppTask.h | 81 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 70 insertions(+), 11 deletions(-) diff --git a/src/RTOScppTask.h b/src/RTOScppTask.h index 910d444..a2a8651 100644 --- a/src/RTOScppTask.h +++ b/src/RTOScppTask.h @@ -12,8 +12,8 @@ class TaskBase { private: - TaskBase(const TaskBase&) = delete; - void operator=(const TaskBase&) = delete; + TaskBase(const TaskBase&) = delete; // Delete copy constructor + void operator=(const TaskBase&) = delete; // Delete copy assignment operator protected: TaskBase(const char* name, TaskFunction_t function, uint8_t priority) @@ -21,7 +21,12 @@ class TaskBase { , _function(function) , _priority(priority) , _handle(nullptr) {} - ~TaskBase() { vTaskDelete(_handle); } + + virtual ~TaskBase() { + if (_handle) { + vTaskDelete(_handle); + } + } const char* _name; TaskFunction_t _function; @@ -31,6 +36,20 @@ class TaskBase { public: virtual bool init() = 0; + void suspend() { vTaskSuspend(_handle); } + void resume() { vTaskResume(_handle); } + bool abortDelay() { return xTaskAbortDelay(_handle); } + + void setPriority(uint8_t priority) { + _priority = priority; + vTaskPrioritySet(_handle, _priority); + } + + uint8_t getPriority() { return uxTaskPriorityGet(_handle); } + uint8_t getPriorityFromISR() { return uxTaskPriorityGetFromISR(_handle); } + const char* getName() { return _name; } + TaskHandle_t getHandle() { return _handle; } + bool notify(uint32_t value, eNotifyAction action) { return xTaskNotify(_handle, value, action); } bool notifyFromISR(uint32_t value, eNotifyAction action, BaseType_t& task_woken) { @@ -59,6 +78,52 @@ class TaskBase { } }; +class TaskDynamic : public TaskBase { + public: + TaskDynamic(const char* name, TaskFunction_t function, uint8_t priority, uint32_t stack_size) + : TaskBase(name, function, priority) + , _stack_size(stack_size) {} + + bool init() { return xTaskCreate(_function, _name, _stack_size, nullptr, _priority, &_handle); } + + private: + uint32_t _stack_size; +}; + +class TaskDynamicPinnedToCore : public TaskBase { + public: + TaskDynamicPinnedToCore(const char* name, TaskFunction_t function, uint8_t priority, + uint32_t stack_size, BaseType_t running_core) + : TaskBase(name, function, priority) + , _stack_size(stack_size) + , _running_core(running_core) {} + + bool init() { + return xTaskCreatePinnedToCore( + _function, _name, _stack_size, nullptr, _priority, &_handle, _running_core); + } + + private: + uint32_t _stack_size; + BaseType_t _running_core; +}; + +template +class TaskStatic : public TaskBase { + public: + TaskStatic(const char* name, TaskFunction_t function, uint8_t priority) + : TaskBase(name, function, priority) {} + + bool init() { + _handle = xTaskCreateStatic(_function, _name, STACK_SIZE, nullptr, _priority, _stack, &_tcb); + return _handle != nullptr ? true : false; + } + + private: + StaticTask_t _tcb; + StackType_t _stack[STACK_SIZE]; +}; + template class TaskStaticPinnedToCore : public TaskBase { public: @@ -68,14 +133,8 @@ class TaskStaticPinnedToCore : public TaskBase { , _running_core(running_core) {} bool init() { - _handle = xTaskCreateStaticPinnedToCore(_function, // Función - _name, // Nombre - STACK_SIZE, // Tamaño stack - NULL, // Parámetros - _priority, // Prioridad - _stack, // Buffer stack - &_tcb, // Buffer tarea - _running_core); // Core + _handle = xTaskCreateStaticPinnedToCore( + _function, _name, STACK_SIZE, nullptr, _priority, _stack, &_tcb, _running_core); return _handle != nullptr ? true : false; } From 5e6160cb95e03c39f05842b3faa1113041019131 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 22:09:44 -0300 Subject: [PATCH 02/11] style: Update .clang-format with short if statements --- .clang-format | 1 + 1 file changed, 1 insertion(+) diff --git a/.clang-format b/.clang-format index 9bed2bc..38e8a64 100644 --- a/.clang-format +++ b/.clang-format @@ -7,6 +7,7 @@ AlignConsecutiveBitFields: Consecutive AlignConsecutiveMacros: Consecutive AlignEscapedNewlines: Left AllowShortCaseLabelsOnASingleLine: true +AllowShortIfStatementsOnASingleLine: WithoutElse AlwaysBreakTemplateDeclarations: Yes BreakBeforeBraces: Custom BreakConstructorInitializers: BeforeComma From f4acc033a3f75f016484a2bdde8be4414f67bbef Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 22:10:14 -0300 Subject: [PATCH 03/11] feat: Add dynamic timers and some methods --- src/RTOScppTask.h | 4 +--- src/RTOScppTimer.h | 34 +++++++++++++++++++++++----------- 2 files changed, 24 insertions(+), 14 deletions(-) diff --git a/src/RTOScppTask.h b/src/RTOScppTask.h index a2a8651..4f34270 100644 --- a/src/RTOScppTask.h +++ b/src/RTOScppTask.h @@ -23,9 +23,7 @@ class TaskBase { , _handle(nullptr) {} virtual ~TaskBase() { - if (_handle) { - vTaskDelete(_handle); - } + if (_handle) vTaskDelete(_handle); } const char* _name; diff --git a/src/RTOScppTimer.h b/src/RTOScppTimer.h index d98e46c..68abcd2 100644 --- a/src/RTOScppTimer.h +++ b/src/RTOScppTimer.h @@ -12,13 +12,13 @@ class TimerBase { private: - TimerBase(const TimerBase&) = delete; - void operator=(const TimerBase&) = delete; + TimerBase(const TimerBase&) = delete; // Delete copy constructor + void operator=(const TimerBase&) = delete; // Delete copy assignment operator protected: TimerBase(TimerHandle_t handle) : _handle(handle) {} - ~TimerBase() { xTimerDelete(_handle, portMAX_DELAY); } + virtual ~TimerBase() { xTimerDelete(_handle, portMAX_DELAY); } TimerHandle_t _handle; @@ -31,16 +31,15 @@ class TimerBase { bool stop(TickType_t ticks_to_wait = portMAX_DELAY) { return xTimerStop(_handle, ticks_to_wait); } bool stopFromISR(BaseType_t& task_woken) { return xTimerStopFromISR(_handle, &task_woken); } + bool isActive() { return xTimerIsTimerActive(_handle); } bool reset(TickType_t ticks_to_wait = portMAX_DELAY) { return xTimerReset(_handle, ticks_to_wait); } bool resetFromISR(BaseType_t& task_woken) { return xTimerResetFromISR(_handle, &task_woken); } - bool isActive() { return xTimerIsTimerActive(_handle); } const char* getName() { return pcTimerGetName(_handle); } TickType_t getExpiryTime() { return xTimerGetExpiryTime(_handle); } - TickType_t getPeriod() { return xTimerGetPeriod(_handle); } bool setPeriod(TickType_t period, TickType_t ticks_to_wait = portMAX_DELAY) { return xTimerChangePeriod(_handle, period, ticks_to_wait); @@ -49,15 +48,28 @@ class TimerBase { bool setPeriodFromISR(TickType_t period, BaseType_t& task_woken) { return xTimerChangePeriodFromISR(_handle, period, &task_woken); } + + TickType_t getPeriod() { return xTimerGetPeriod(_handle); } + + void setReloadMode(bool auto_reload) { vTimerSetReloadMode(_handle, auto_reload); } + bool getReloadMode() { return uxTimerGetReloadMode(_handle); } +}; + +class TimerDynamic : public TimerBase { + public: + TimerDynamic(const char* name, TimerCallbackFunction_t callback, TickType_t period, + bool auto_reload, bool start) + : TimerBase(xTimerCreate(name, period, auto_reload, 0, callback)) { + if (start) this->start(); + } }; -class Timer : public TimerBase { +class TimerStatic : public TimerBase { public: - Timer(const char* name, TimerCallbackFunction_t callback, TickType_t period, bool auto_reload, - bool start) - : TimerBase(xTimerCreateStatic(name, period, auto_reload, this, callback, &_tcb)) { - if (start) - this->start(); + TimerStatic(const char* name, TimerCallbackFunction_t callback, TickType_t period, + bool auto_reload, bool start) + : TimerBase(xTimerCreateStatic(name, period, auto_reload, 0, callback, &_tcb)) { + if (start) this->start(); } private: From 1d03db2f47f2d9c81f6d8ee258e34a3dae3dbc50 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 22:40:42 -0300 Subject: [PATCH 04/11] feat: Add lock classes and add dynamic/static options --- src/RTOScppLock.h | 68 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 55 insertions(+), 13 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index 083dfe4..cf2904b 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -12,21 +12,20 @@ class Lock { private: - Lock(Lock const&) = delete; - void operator=(Lock const&) = delete; + Lock(Lock const&) = delete; // Delete copy constructor + void operator=(Lock const&) = delete; // Delete copy assignment operator friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const Lock& semaphore); protected: Lock(SemaphoreHandle_t handle) : _handle(handle) {} - ~Lock() { vSemaphoreDelete(_handle); } + virtual ~Lock() { vSemaphoreDelete(_handle); } SemaphoreHandle_t _handle; - StaticSemaphore_t _tcb; public: - SemaphoreHandle_t getHandle() { return _handle; } + // SemaphoreHandle_t getHandle() { return _handle; } virtual bool take(const TickType_t ticks_to_wait = portMAX_DELAY) { return xSemaphoreTake(_handle, ticks_to_wait); @@ -39,15 +38,36 @@ inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const Loc return queue_set_member == semaphore._handle; } -class Mutex : public Lock { +class MutexDynamic : public Lock { + public: + MutexDynamic() + : Lock(xSemaphoreCreateMutex()) {} +}; + +class MutexStatic : public Lock { public: - Mutex() + MutexStatic() : Lock(xSemaphoreCreateMutexStatic(&_tcb)) {} + + private: + StaticSemaphore_t _tcb; +}; + +class MutexRecursiveDynamic : public Lock { + public: + MutexRecursiveDynamic() + : Lock(xSemaphoreCreateRecursiveMutex()) {} + + bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { + return xSemaphoreTakeRecursive(_handle, ticks_to_wait); + } + + bool give() override { return xSemaphoreGiveRecursive(_handle); } }; -class MutexRecursive : public Lock { +class MutexRecursiveStatic : public Lock { public: - MutexRecursive() + MutexRecursiveStatic() : Lock(xSemaphoreCreateRecursiveMutexStatic(&_tcb)) {} bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { @@ -55,6 +75,9 @@ class MutexRecursive : public Lock { } bool give() override { return xSemaphoreGiveRecursive(_handle); } + + private: + StaticSemaphore_t _tcb; }; class Semaphore : public Lock { @@ -65,18 +88,37 @@ class Semaphore : public Lock { public: bool takeFromISR(BaseType_t& task_woken) { return xSemaphoreTakeFromISR(_handle, &task_woken); } bool giveFromISR(BaseType_t& task_woken) { return xSemaphoreGiveFromISR(_handle, &task_woken); } + uint8_t getCount() { return uxSemaphoreGetCount(_handle); } +}; + +class SemaphoreBinaryDynamic : public Semaphore { + public: + SemaphoreBinaryDynamic() + : Semaphore(xSemaphoreCreateBinary()) {} }; -class SemaphoreBinary : public Semaphore { +class SemaphoreBinaryStatic : public Semaphore { public: - SemaphoreBinary() + SemaphoreBinaryStatic() : Semaphore(xSemaphoreCreateBinaryStatic(&_tcb)) {} + + private: + StaticSemaphore_t _tcb; +}; + +class SemaphoreCountingDynamic : public Semaphore { + public: + SemaphoreCountingDynamic(const uint8_t max_count, const uint8_t initial_count = 0) + : Semaphore(xSemaphoreCreateCounting(max_count, initial_count)) {} }; -class SemaphoreCounting : public Semaphore { +class SemaphoreCountingStatic : public Semaphore { public: - SemaphoreCounting(const uint8_t max_count, const uint8_t initial_count = 0) + SemaphoreCountingStatic(const uint8_t max_count, const uint8_t initial_count = 0) : Semaphore(xSemaphoreCreateCountingStatic(max_count, initial_count, &_tcb)) {} + + private: + StaticSemaphore_t _tcb; }; #endif // RTOS_CPP_LOCK_H \ No newline at end of file From ff3926eb8964ba78e61d397971eddb573a1a0880 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 23:06:47 -0300 Subject: [PATCH 05/11] feat: Add queue dynamic/static classes --- src/RTOScppLock.h | 4 +++- src/RTOScppQueue.h | 34 +++++++++++++++++++++++----------- src/RTOScppTimer.h | 4 +++- 3 files changed, 29 insertions(+), 13 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index cf2904b..ce452f9 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -20,7 +20,9 @@ class Lock { protected: Lock(SemaphoreHandle_t handle) : _handle(handle) {} - virtual ~Lock() { vSemaphoreDelete(_handle); } + virtual ~Lock() { + if (_handle) vSemaphoreDelete(_handle); + } SemaphoreHandle_t _handle; diff --git a/src/RTOScppQueue.h b/src/RTOScppQueue.h index 045f5a1..e080edd 100644 --- a/src/RTOScppQueue.h +++ b/src/RTOScppQueue.h @@ -21,8 +21,8 @@ bool operator==(const QueueSetMemberHandle_t& queue_set_member, const QueueBase< template class QueueBase { private: - QueueBase(QueueBase const&) = delete; - void operator=(QueueBase const&) = delete; + QueueBase(QueueBase const&) = delete; // Delete copy constructor + void operator=(QueueBase const&) = delete; // Delete copy assignment operator friend bool operator== <>(const QueueSetMemberHandle_t& queue_set_member, const QueueBase& queue); @@ -30,17 +30,18 @@ class QueueBase { protected: QueueBase(QueueHandle_t handle) : _handle(handle) {} - ~QueueBase() { vQueueDelete(_handle); } + virtual ~QueueBase() { + if (_handle) vQueueDelete(_handle); + } - StaticQueue_t _tcb; QueueHandle_t _handle; public: QueueHandle_t getHandle() { return _handle; } - uint32_t availableMessages() { return uxQueueMessagesWaiting(_handle); } - uint32_t availableMessagesFromISR() { return uxQueueMessagesWaitingFromISR(_handle); } - uint32_t availableSpaces() { return uxQueueSpacesAvailable(_handle); } + uint32_t getAvailableMessages() { return uxQueueMessagesWaiting(_handle); } + uint32_t getAvailableMessagesFromISR() { return uxQueueMessagesWaitingFromISR(_handle); } + uint32_t getAvailableSpaces() { return uxQueueSpacesAvailable(_handle); } void reset() { xQueueReset(_handle); } bool isFull() { return uxQueueSpacesAvailable(_handle) == 0; } bool isEmpty() { return uxQueueMessagesWaiting(_handle) == 0; } @@ -83,26 +84,37 @@ bool operator==(const QueueSetMemberHandle_t& queue_set_member, const QueueBase< return queue_set_member == queue._handle; } +template +class QueueDynamic : public QueueBase { + public: + QueueDynamic(uint32_t length) + : QueueBase(xQueueCreate(length, sizeof(T))) {} +}; + template -class Queue : public QueueBase { +class QueueStatic : public QueueBase { public: - Queue() + QueueStatic() : QueueBase(xQueueCreateStatic(LENGTH, sizeof(T), _storage, &this->_tcb)) {} private: + StaticQueue_t _tcb; uint8_t _storage[LENGTH * sizeof(T)]; }; template -class QueueExternalStorage : public QueueBase { +class QueueStaticExternalStorage : public QueueBase { public: - QueueExternalStorage() + QueueStaticExternalStorage() : QueueBase(nullptr) {} bool init(uint8_t* buffer, uint32_t buffer_size) { this->_handle = xQueueCreateStatic(buffer_size, sizeof(T), buffer, &this->_tcb); return this->_handle != nullptr ? true : false; } + + private: + StaticQueue_t _tcb; }; #endif // RTOS_CPP_QUEUE_H \ No newline at end of file diff --git a/src/RTOScppTimer.h b/src/RTOScppTimer.h index 68abcd2..feeae81 100644 --- a/src/RTOScppTimer.h +++ b/src/RTOScppTimer.h @@ -18,7 +18,9 @@ class TimerBase { protected: TimerBase(TimerHandle_t handle) : _handle(handle) {} - virtual ~TimerBase() { xTimerDelete(_handle, portMAX_DELAY); } + virtual ~TimerBase() { + if (_handle) xTimerDelete(_handle, portMAX_DELAY); + } TimerHandle_t _handle; From 0753edaf7f8bc9a6e4c7eeb4ffa912919290cbdf Mon Sep 17 00:00:00 2001 From: alkonosst Date: Fri, 8 Mar 2024 23:10:06 -0300 Subject: [PATCH 06/11] refactor: Rename class Lock for LockBase --- src/RTOScppLock.h | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index ce452f9..990f906 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -10,17 +10,17 @@ #include #include -class Lock { +class LockBase { private: - Lock(Lock const&) = delete; // Delete copy constructor - void operator=(Lock const&) = delete; // Delete copy assignment operator + LockBase(LockBase const&) = delete; // Delete copy constructor + void operator=(LockBase const&) = delete; // Delete copy assignment operator - friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const Lock& semaphore); + friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& semaphore); protected: - Lock(SemaphoreHandle_t handle) + LockBase(SemaphoreHandle_t handle) : _handle(handle) {} - virtual ~Lock() { + virtual ~LockBase() { if (_handle) vSemaphoreDelete(_handle); } @@ -36,29 +36,29 @@ class Lock { virtual bool give() { return xSemaphoreGive(_handle); } }; -inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const Lock& semaphore) { +inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& semaphore) { return queue_set_member == semaphore._handle; } -class MutexDynamic : public Lock { +class MutexDynamic : public LockBase { public: MutexDynamic() - : Lock(xSemaphoreCreateMutex()) {} + : LockBase(xSemaphoreCreateMutex()) {} }; -class MutexStatic : public Lock { +class MutexStatic : public LockBase { public: MutexStatic() - : Lock(xSemaphoreCreateMutexStatic(&_tcb)) {} + : LockBase(xSemaphoreCreateMutexStatic(&_tcb)) {} private: StaticSemaphore_t _tcb; }; -class MutexRecursiveDynamic : public Lock { +class MutexRecursiveDynamic : public LockBase { public: MutexRecursiveDynamic() - : Lock(xSemaphoreCreateRecursiveMutex()) {} + : LockBase(xSemaphoreCreateRecursiveMutex()) {} bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { return xSemaphoreTakeRecursive(_handle, ticks_to_wait); @@ -67,10 +67,10 @@ class MutexRecursiveDynamic : public Lock { bool give() override { return xSemaphoreGiveRecursive(_handle); } }; -class MutexRecursiveStatic : public Lock { +class MutexRecursiveStatic : public LockBase { public: MutexRecursiveStatic() - : Lock(xSemaphoreCreateRecursiveMutexStatic(&_tcb)) {} + : LockBase(xSemaphoreCreateRecursiveMutexStatic(&_tcb)) {} bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { return xSemaphoreTakeRecursive(_handle, ticks_to_wait); @@ -82,10 +82,10 @@ class MutexRecursiveStatic : public Lock { StaticSemaphore_t _tcb; }; -class Semaphore : public Lock { +class Semaphore : public LockBase { protected: Semaphore(SemaphoreHandle_t handle) - : Lock(handle) {} + : LockBase(handle) {} public: bool takeFromISR(BaseType_t& task_woken) { return xSemaphoreTakeFromISR(_handle, &task_woken); } From 22a0fc5eaa473f79ecc6de38409438bacb2bb645 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Sat, 9 Mar 2024 01:25:44 -0300 Subject: [PATCH 07/11] feat: Use objects to interface with Queue Sets --- src/RTOScppLock.h | 12 ++++++----- src/RTOScppQueue.h | 48 ++++++++++++++++++++++--------------------- src/RTOScppQueueSet.h | 9 ++++---- 3 files changed, 37 insertions(+), 32 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index 990f906..ed50dea 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -10,12 +10,16 @@ #include #include +// Forward declaration of QueueSet +class QueueSet; + class LockBase { private: LockBase(LockBase const&) = delete; // Delete copy constructor void operator=(LockBase const&) = delete; // Delete copy assignment operator - friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& semaphore); + friend class QueueSet; + friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& lock); protected: LockBase(SemaphoreHandle_t handle) @@ -27,8 +31,6 @@ class LockBase { SemaphoreHandle_t _handle; public: - // SemaphoreHandle_t getHandle() { return _handle; } - virtual bool take(const TickType_t ticks_to_wait = portMAX_DELAY) { return xSemaphoreTake(_handle, ticks_to_wait); } @@ -36,8 +38,8 @@ class LockBase { virtual bool give() { return xSemaphoreGive(_handle); } }; -inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& semaphore) { - return queue_set_member == semaphore._handle; +inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& lock) { + return queue_set_member == lock._handle; } class MutexDynamic : public LockBase { diff --git a/src/RTOScppQueue.h b/src/RTOScppQueue.h index e080edd..9b3febd 100644 --- a/src/RTOScppQueue.h +++ b/src/RTOScppQueue.h @@ -10,35 +10,42 @@ #include #include -// QueueBase forward declaration -template -class QueueBase; - -// operator== forward declaration -template -bool operator==(const QueueSetMemberHandle_t& queue_set_member, const QueueBase& queue); +// Forward declaration of QueueSet +class QueueSet; -template -class QueueBase { +class QueueInterface { private: - QueueBase(QueueBase const&) = delete; // Delete copy constructor - void operator=(QueueBase const&) = delete; // Delete copy assignment operator - - friend bool operator== - <>(const QueueSetMemberHandle_t& queue_set_member, const QueueBase& queue); + friend class QueueSet; + friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, + const QueueInterface& queue); protected: - QueueBase(QueueHandle_t handle) + QueueInterface(QueueHandle_t handle) : _handle(handle) {} - virtual ~QueueBase() { + virtual ~QueueInterface() { if (_handle) vQueueDelete(_handle); } QueueHandle_t _handle; +}; - public: - QueueHandle_t getHandle() { return _handle; } +inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, + const QueueInterface& queue) { + return queue_set_member == queue._handle; +} +template +class QueueBase : public QueueInterface { + private: + QueueBase(QueueBase const&) = delete; // Delete copy constructor + void operator=(QueueBase const&) = delete; // Delete copy assignment operator + + protected: + QueueBase(QueueHandle_t handle) + : QueueInterface(handle) {} + virtual ~QueueBase() {} + + public: uint32_t getAvailableMessages() { return uxQueueMessagesWaiting(_handle); } uint32_t getAvailableMessagesFromISR() { return uxQueueMessagesWaitingFromISR(_handle); } uint32_t getAvailableSpaces() { return uxQueueSpacesAvailable(_handle); } @@ -79,11 +86,6 @@ class QueueBase { bool peekFromISR(T& var) { return xQueuePeekFromISR(_handle, &var); } }; -template -bool operator==(const QueueSetMemberHandle_t& queue_set_member, const QueueBase& queue) { - return queue_set_member == queue._handle; -} - template class QueueDynamic : public QueueBase { public: diff --git a/src/RTOScppQueueSet.h b/src/RTOScppQueueSet.h index 9b83f2e..315d980 100644 --- a/src/RTOScppQueueSet.h +++ b/src/RTOScppQueueSet.h @@ -16,12 +16,13 @@ class QueueSet { public: QueueSet(const uint8_t queue_length) : _handle(xQueueCreateSet(queue_length)) {} - ~QueueSet() { vQueueDelete(_handle); } - - bool add(QueueSetMemberHandle_t queue_or_semaphore) { - return xQueueAddToSet(queue_or_semaphore, _handle); + ~QueueSet() { + if (_handle) vQueueDelete(_handle); } + bool add(LockBase& lock) { return xQueueAddToSet(lock._handle, _handle); } + bool add(QueueInterface& queue) { return xQueueAddToSet(queue._handle, _handle); } + bool add(RingbufHandle_t ring_buffer) { return xRingbufferAddToQueueSetRead(ring_buffer, _handle); } From 86a74ff985040f2b60026e4cff60071bbcb90a01 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Sat, 9 Mar 2024 14:31:26 -0300 Subject: [PATCH 08/11] feat: Use RingBufferBase class to interface with QueueSet, add RingBufferNoSplit dynamic/static classes --- src/RTOScppBuffer.h | 4 +-- src/RTOScppQueueSet.h | 14 +++++++--- src/RTOScppRingBuffer.h | 60 +++++++++++++++++++++++++++-------------- 3 files changed, 52 insertions(+), 26 deletions(-) diff --git a/src/RTOScppBuffer.h b/src/RTOScppBuffer.h index bfbc948..9dd13c0 100644 --- a/src/RTOScppBuffer.h +++ b/src/RTOScppBuffer.h @@ -13,8 +13,8 @@ class DataBuffer { private: - DataBuffer(const DataBuffer&) = delete; - void operator=(const DataBuffer&) = delete; + DataBuffer(const DataBuffer&) = delete; // Delete copy constructor + void operator=(const DataBuffer&) = delete; // Delete copy assignment operator protected: DataBuffer(StreamBufferHandle_t handle) diff --git a/src/RTOScppQueueSet.h b/src/RTOScppQueueSet.h index 315d980..8c73a13 100644 --- a/src/RTOScppQueueSet.h +++ b/src/RTOScppQueueSet.h @@ -22,20 +22,26 @@ class QueueSet { bool add(LockBase& lock) { return xQueueAddToSet(lock._handle, _handle); } bool add(QueueInterface& queue) { return xQueueAddToSet(queue._handle, _handle); } + bool add(RingBufferBase& ring_buffer) { + return xRingbufferAddToQueueSetRead(ring_buffer._handle, _handle); + } - bool add(RingbufHandle_t ring_buffer) { - return xRingbufferAddToQueueSetRead(ring_buffer, _handle); + bool remove(LockBase& lock) { return xQueueRemoveFromSet(lock._handle, _handle); } + bool remove(QueueInterface& queue) { return xQueueRemoveFromSet(queue._handle, _handle); } + bool remove(RingBufferBase& ring_buffer) { + return xRingbufferRemoveFromQueueSetRead(ring_buffer._handle, _handle); } QueueSetMemberHandle_t select(TickType_t ticks_to_wait = portMAX_DELAY) { return xQueueSelectFromSet(_handle, ticks_to_wait); } + QueueSetMemberHandle_t selectFromISR() { return xQueueSelectFromSetFromISR(_handle); } private: QueueSetHandle_t _handle; - QueueSet(const QueueSet&) = delete; - QueueSet& operator=(const QueueSet&) = delete; + QueueSet(const QueueSet&) = delete; // Delete copy constructor + void operator=(const QueueSet&) = delete; // Delete copy assignment operator }; #endif // RTOS_CPP_QUEUE_SET_H \ No newline at end of file diff --git a/src/RTOScppRingBuffer.h b/src/RTOScppRingBuffer.h index bbd90b8..ff492fd 100644 --- a/src/RTOScppRingBuffer.h +++ b/src/RTOScppRingBuffer.h @@ -10,53 +10,74 @@ #include #include -class RingBufBase { +// Forward declaration of QueueSet +class QueueSet; + +class RingBufferBase { private: - RingBufBase(const RingBufBase&) = delete; - RingBufBase& operator=(const RingBufBase&) = delete; + RingBufferBase(const RingBufferBase&) = delete; // Delete copy constructor + RingBufferBase& operator=(const RingBufferBase&) = delete; // Delete copy assignment operator + friend class QueueSet; friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, - const RingBufBase& ring_buffer); + const RingBufferBase& ring_buffer); protected: - RingBufBase(RingbufHandle_t handle) + RingBufferBase(RingbufHandle_t handle) : _handle(handle) {} - ~RingBufBase() { vRingbufferDelete(_handle); } + virtual ~RingBufferBase() { + if (_handle) vRingbufferDelete(_handle); + } RingbufHandle_t _handle; - - public: - RingbufHandle_t getHandle() { return _handle; } }; inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, - const RingBufBase& ring_buffer) { + const RingBufferBase& ring_buffer) { return xRingbufferCanRead(ring_buffer._handle, queue_set_member); } template -class RingBufNoSplitBase : public RingBufBase { +class RingBufferNoSplitBase : public RingBufferBase { protected: - RingBufNoSplitBase(RingbufHandle_t handle) - : RingBufBase(handle) {} + RingBufferNoSplitBase(RingbufHandle_t handle) + : RingBufferBase(handle) {} public: bool send(const T* item, uint32_t item_size, TickType_t ticks_to_wait = portMAX_DELAY) { return xRingbufferSend(_handle, (void*)item, item_size, ticks_to_wait); } + bool sendFromISR(const T* item, uint32_t item_size, BaseType_t& higher_priority_task_woken) { + return xRingbufferSendFromISR(_handle, (void*)item, item_size, &higher_priority_task_woken); + } + T* receive(uint32_t& item_size, TickType_t ticks_to_wait = portMAX_DELAY) { return (T*)xRingbufferReceive(_handle, &item_size, ticks_to_wait); } + T* receiveFromISR(uint32_t& item_size) { + return (T*)xRingbufferReceiveFromISR(_handle, &item_size); + } + void returnItem(T* item) { vRingbufferReturnItem(_handle, (void*)item); } + void returnItemFromISR(T* item, BaseType_t& higher_priority_task_woken) { + vRingbufferReturnItemFromISR(_handle, (void*)item, &higher_priority_task_woken); + } +}; + +template +class RingBufferNoSplitDynamic : public RingBufferNoSplitBase { + public: + RingBufferNoSplitDynamic(uint32_t buffer_size) + : RingBufferNoSplitBase(xRingbufferCreate(buffer_size, RINGBUF_TYPE_NOSPLIT)) {} }; template -class RingBufNoSplit : public RingBufNoSplitBase { +class RingBufferNoSplitStatic : public RingBufferNoSplitBase { public: - RingBufNoSplit() - : RingBufNoSplitBase( + RingBufferNoSplitStatic() + : RingBufferNoSplitBase( xRingbufferCreateStatic(BUFFER_SIZE, RINGBUF_TYPE_NOSPLIT, _storage, &_tcb)) {} private: @@ -65,14 +86,13 @@ class RingBufNoSplit : public RingBufNoSplitBase { }; template -class RingBufNoSplitExtStorage : public RingBufNoSplitBase { +class RingBufferNoSplitExternalStorage : public RingBufferNoSplitBase { public: - RingBufNoSplitExtStorage() - : RingBufNoSplitBase(nullptr) {} + RingBufferNoSplitExternalStorage() + : RingBufferNoSplitBase(nullptr) {} bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { this->_handle = xRingbufferCreateStatic(buffer_size, RINGBUF_TYPE_NOSPLIT, buffer_storage, tcb); - return this->_handle != nullptr ? true : false; } }; From a07b0e745f5e18b7e8f5e225d319b026a83a4987 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Sun, 10 Mar 2024 20:06:01 -0300 Subject: [PATCH 09/11] feat: Add dynamic/static classes for RingBuffers and add them to QueueSet --- src/RTOScppQueueSet.h | 6 +- src/RTOScppRingBuffer.h | 148 +++++++++++++++++++++++++++++++++++----- 2 files changed, 135 insertions(+), 19 deletions(-) diff --git a/src/RTOScppQueueSet.h b/src/RTOScppQueueSet.h index 8c73a13..e0e2b5c 100644 --- a/src/RTOScppQueueSet.h +++ b/src/RTOScppQueueSet.h @@ -22,13 +22,13 @@ class QueueSet { bool add(LockBase& lock) { return xQueueAddToSet(lock._handle, _handle); } bool add(QueueInterface& queue) { return xQueueAddToSet(queue._handle, _handle); } - bool add(RingBufferBase& ring_buffer) { + bool add(RingBufferInterface& ring_buffer) { return xRingbufferAddToQueueSetRead(ring_buffer._handle, _handle); } bool remove(LockBase& lock) { return xQueueRemoveFromSet(lock._handle, _handle); } bool remove(QueueInterface& queue) { return xQueueRemoveFromSet(queue._handle, _handle); } - bool remove(RingBufferBase& ring_buffer) { + bool remove(RingBufferInterface& ring_buffer) { return xRingbufferRemoveFromQueueSetRead(ring_buffer._handle, _handle); } @@ -37,6 +37,8 @@ class QueueSet { } QueueSetMemberHandle_t selectFromISR() { return xQueueSelectFromSetFromISR(_handle); } + explicit operator bool() const { return _handle != nullptr; } + private: QueueSetHandle_t _handle; diff --git a/src/RTOScppRingBuffer.h b/src/RTOScppRingBuffer.h index ff492fd..973fd1d 100644 --- a/src/RTOScppRingBuffer.h +++ b/src/RTOScppRingBuffer.h @@ -13,35 +13,39 @@ // Forward declaration of QueueSet class QueueSet; -class RingBufferBase { +class RingBufferInterface { private: - RingBufferBase(const RingBufferBase&) = delete; // Delete copy constructor - RingBufferBase& operator=(const RingBufferBase&) = delete; // Delete copy assignment operator + RingBufferInterface(const RingBufferInterface&) = delete; // Delete copy constructor + RingBufferInterface& operator=(const RingBufferInterface&) = delete; // Delete copy assignment op. friend class QueueSet; friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, - const RingBufferBase& ring_buffer); + const RingBufferInterface& ring_buffer); protected: - RingBufferBase(RingbufHandle_t handle) + RingBufferInterface(RingbufHandle_t handle) : _handle(handle) {} - virtual ~RingBufferBase() { + virtual ~RingBufferInterface() { if (_handle) vRingbufferDelete(_handle); } RingbufHandle_t _handle; + + public: + explicit operator bool() const { return _handle != nullptr; } }; inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, - const RingBufferBase& ring_buffer) { + const RingBufferInterface& ring_buffer) { return xRingbufferCanRead(ring_buffer._handle, queue_set_member); } template -class RingBufferNoSplitBase : public RingBufferBase { +class RingBufferBase : public RingBufferInterface { protected: - RingBufferNoSplitBase(RingbufHandle_t handle) - : RingBufferBase(handle) {} + RingBufferBase(RingbufHandle_t handle) + : RingBufferInterface(handle) {} + virtual ~RingBufferBase() {} public: bool send(const T* item, uint32_t item_size, TickType_t ticks_to_wait = portMAX_DELAY) { @@ -52,17 +56,26 @@ class RingBufferNoSplitBase : public RingBufferBase { return xRingbufferSendFromISR(_handle, (void*)item, item_size, &higher_priority_task_woken); } - T* receive(uint32_t& item_size, TickType_t ticks_to_wait = portMAX_DELAY) { - return (T*)xRingbufferReceive(_handle, &item_size, ticks_to_wait); + void returnItem(T* item) { vRingbufferReturnItem(_handle, (void*)item); } + void returnItemFromISR(T* item, BaseType_t& higher_priority_task_woken) { + vRingbufferReturnItemFromISR(_handle, (void*)item, &higher_priority_task_woken); } +}; - T* receiveFromISR(uint32_t& item_size) { - return (T*)xRingbufferReceiveFromISR(_handle, &item_size); +template +class RingBufferNoSplitBase : public RingBufferBase { + protected: + RingBufferNoSplitBase(RingbufHandle_t handle) + : RingBufferBase(handle) {} + virtual ~RingBufferNoSplitBase() {} + + public: + T* receive(uint32_t& item_size, TickType_t ticks_to_wait = portMAX_DELAY) { + return (T*)xRingbufferReceive(this->_handle, &item_size, ticks_to_wait); } - void returnItem(T* item) { vRingbufferReturnItem(_handle, (void*)item); } - void returnItemFromISR(T* item, BaseType_t& higher_priority_task_woken) { - vRingbufferReturnItemFromISR(_handle, (void*)item, &higher_priority_task_woken); + T* receiveFromISR(uint32_t& item_size) { + return (T*)xRingbufferReceiveFromISR(this->_handle, &item_size); } }; @@ -97,4 +110,105 @@ class RingBufferNoSplitExternalStorage : public RingBufferNoSplitBase { } }; +template +class RingBufferSplitBase : public RingBufferBase { + protected: + RingBufferSplitBase(RingbufHandle_t handle) + : RingBufferBase(handle) {} + virtual ~RingBufferSplitBase() {} + + public: + bool receive(T** head, T** tail, uint32_t& head_item_size, uint32_t& tail_item_size, + TickType_t ticks_to_wait = portMAX_DELAY) { + return xRingbufferReceiveSplit( + this->_handle, head, tail, &head_item_size, &tail_item_size, ticks_to_wait); + } + + bool receiveFromISR(T** head, T** tail, uint32_t& head_item_size, uint32_t& tail_item_size) { + return xRingbufferReceiveSplitFromISR( + this->_handle, head, tail, &head_item_size, &tail_item_size); + } +}; + +template +class RingBufferSplitDynamic : public RingBufferSplitBase { + public: + RingBufferSplitDynamic(uint32_t buffer_size) + : RingBufferSplitBase(xRingbufferCreate(buffer_size, RINGBUF_TYPE_ALLOWSPLIT)) {} +}; + +template +class RingBufferSplitStatic : public RingBufferSplitBase { + public: + RingBufferSplitStatic() + : RingBufferSplitBase( + xRingbufferCreateStatic(BUFFER_SIZE, RINGBUF_TYPE_ALLOWSPLIT, _storage, &_tcb)) {} + + private: + StaticRingbuffer_t _tcb; + uint8_t _storage[BUFFER_SIZE]; +}; + +template +class RingBufferSplitExternalStorage : public RingBufferSplitBase { + public: + RingBufferSplitExternalStorage() + : RingBufferSplitBase(nullptr) {} + + bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { + this->_handle = + xRingbufferCreateStatic(buffer_size, RINGBUF_TYPE_ALLOWSPLIT, buffer_storage, tcb); + return this->_handle != nullptr ? true : false; + } +}; + +template +class RingBufferByteBase : public RingBufferBase { + protected: + RingBufferByteBase(RingbufHandle_t handle) + : RingBufferBase(handle) {} + virtual ~RingBufferByteBase() {} + + public: + T* receiveUpTo(uint32_t max_item_size, uint32_t& item_size, + TickType_t ticks_to_wait = portMAX_DELAY) { + return (T*)xRingbufferReceiveUpTo(this->_handle, &item_size, ticks_to_wait, max_item_size); + } + + T* receiveUpToFromISR(uint32_t max_item_size, uint32_t& item_size) { + return (T*)xRingbufferReceiveUpToFromISR(this->_handle, &item_size, max_item_size); + } +}; + +template +class RingBufferByteDynamic : public RingBufferByteBase { + public: + RingBufferByteDynamic(uint32_t buffer_size) + : RingBufferByteBase(xRingbufferCreate(buffer_size, RINGBUF_TYPE_BYTEBUF)) {} +}; + +template +class RingBufferByteStatic : public RingBufferByteBase { + public: + RingBufferByteStatic() + : RingBufferByteBase( + xRingbufferCreateStatic(BUFFER_SIZE, RINGBUF_TYPE_BYTEBUF, _storage, &_tcb)) {} + + private: + StaticRingbuffer_t _tcb; + uint8_t _storage[BUFFER_SIZE]; +}; + +template +class RingBufferByteExternalStorage : public RingBufferByteBase { + public: + RingBufferByteExternalStorage() + : RingBufferByteBase(nullptr) {} + + bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { + this->_handle = xRingbufferCreateStatic(buffer_size, RINGBUF_TYPE_BYTEBUF, buffer_storage, tcb); + return this->_handle != nullptr ? true : false; + } +}; + #endif // RTOS_CPP_RINGBUFFER_H \ No newline at end of file From 9bf1f09826da6344c5bbb256a0c8fadd9a37ad32 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Sun, 10 Mar 2024 20:06:26 -0300 Subject: [PATCH 10/11] feat: Add missing classes for Data Buffers --- src/RTOScppBuffer.h | 79 +++++++++++++++++++++++++++------------------ 1 file changed, 47 insertions(+), 32 deletions(-) diff --git a/src/RTOScppBuffer.h b/src/RTOScppBuffer.h index 9dd13c0..ffbf2b5 100644 --- a/src/RTOScppBuffer.h +++ b/src/RTOScppBuffer.h @@ -11,18 +11,17 @@ #include #include -class DataBuffer { +class DataBufferBase { private: - DataBuffer(const DataBuffer&) = delete; // Delete copy constructor - void operator=(const DataBuffer&) = delete; // Delete copy assignment operator + DataBufferBase(const DataBufferBase&) = delete; // Delete copy constructor + void operator=(const DataBufferBase&) = delete; // Delete copy assignment operator protected: - DataBuffer(StreamBufferHandle_t handle) + DataBufferBase(StreamBufferHandle_t handle) : _handle(handle) {} - ~DataBuffer() { vStreamBufferDelete(_handle); } + virtual ~DataBufferBase() { vStreamBufferDelete(_handle); } StreamBufferHandle_t _handle; - StaticStreamBuffer_t _tcb; public: uint32_t send(const void* tx_buffer, uint32_t bytes, TickType_t ticks_to_wait = portMAX_DELAY) { @@ -45,29 +44,37 @@ class DataBuffer { bool isEmpty() { return xStreamBufferIsEmpty(_handle); } bool isFull() { return xStreamBufferIsFull(_handle); } uint32_t availableSpaces() { return xStreamBufferSpacesAvailable(_handle); } -}; - -template -class StreamBuffer : public DataBuffer { - public: - StreamBuffer(uint32_t trigger_bytes) - : DataBuffer( - xStreamBufferGenericCreateStatic(LENGTH + 1, trigger_bytes, pdFALSE, _storage, &_tcb)) {} - uint32_t availableBytes() { return xStreamBufferBytesAvailable(_handle); } bool setTriggerLevel(uint32_t trigger_bytes) { return xStreamBufferSetTriggerLevel(_handle, trigger_bytes); } + explicit operator bool() const { return _handle != nullptr; } +}; + +class StreamBufferDynamic : public DataBufferBase { + public: + StreamBufferDynamic(uint32_t buffer_size, uint32_t trigger_bytes) + : DataBufferBase(xStreamBufferGenericCreate(buffer_size + 1, trigger_bytes, false)) {} +}; + +template +class StreamBufferStatic : public DataBufferBase { + public: + StreamBufferStatic(uint32_t trigger_bytes) + : DataBufferBase(xStreamBufferGenericCreateStatic(BUFFER_SIZE + 1, trigger_bytes, false, + _storage, &_tcb)) {} + private: - uint8_t _storage[LENGTH + 1]; + StaticStreamBuffer_t _tcb; + uint8_t _storage[BUFFER_SIZE + 1]; }; -class StreamBufferExternalStorage : public DataBuffer { +class StreamBufferExternalStorage : public DataBufferBase { public: - StreamBufferExternalStorage() - : DataBuffer(nullptr) {} + StreamBufferExternalStorage(uint32_t trigger_bytes) + : DataBufferBase(nullptr) {} bool init(uint32_t trigger_bytes, uint8_t* buffer, uint32_t buffer_size) { _handle = @@ -75,32 +82,40 @@ class StreamBufferExternalStorage : public DataBuffer { return _handle != nullptr ? true : false; } - uint32_t availableBytes() { return xStreamBufferBytesAvailable(_handle); } + private: + StaticStreamBuffer_t _tcb; +}; - bool setTriggerLevel(uint32_t trigger_bytes) { - return xStreamBufferSetTriggerLevel(_handle, trigger_bytes); - } +class MessageBufferDynamic : public DataBufferBase { + public: + MessageBufferDynamic(uint32_t buffer_size) + : DataBufferBase(xStreamBufferGenericCreate(buffer_size + 1, 0, false)) {} }; -template -class MessageBuffer : public DataBuffer { +template +class MessageBufferStatic : public DataBufferBase { public: - MessageBuffer() - : DataBuffer(xStreamBufferGenericCreateStatic(LENGTH + 1, 0, pdTRUE, _storage, &_tcb)) {} + MessageBufferStatic() + : DataBufferBase( + xStreamBufferGenericCreateStatic(BUFFER_SIZE + 1, 0, false, _storage, &_tcb)) {} private: - uint8_t _storage[LENGTH + 1]; + StaticStreamBuffer_t _tcb; + uint8_t _storage[BUFFER_SIZE + 1]; }; -class MessageBufferExternalStorage : public DataBuffer { +class MessageBufferExternalStorage : public DataBufferBase { public: MessageBufferExternalStorage() - : DataBuffer(nullptr) {} + : DataBufferBase(nullptr) {} - bool init(uint8_t* buffer, uint32_t buffer_size) { - _handle = xStreamBufferGenericCreateStatic(buffer_size + 1, 0, pdTRUE, buffer, &_tcb); + bool init(uint32_t trigger_bytes, uint8_t* buffer, uint32_t buffer_size) { + _handle = xStreamBufferGenericCreateStatic(buffer_size + 1, 0, true, buffer, &_tcb); return _handle != nullptr ? true : false; } + + private: + StaticStreamBuffer_t _tcb; }; #endif // RTOS_CPP_BUFFER_H From c9b62bc0a965c0d8ad7610333094f9277d9d7640 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Sun, 10 Mar 2024 20:07:04 -0300 Subject: [PATCH 11/11] feat: Add bool() operator to classes to ask if handle is not null --- src/RTOScppLock.h | 3 +++ src/RTOScppQueue.h | 7 +++++-- src/RTOScppTask.h | 2 ++ src/RTOScppTimer.h | 2 ++ 4 files changed, 12 insertions(+), 2 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index ed50dea..9487683 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -8,6 +8,7 @@ #define RTOS_CPP_LOCK_H #include +#include #include // Forward declaration of QueueSet @@ -36,6 +37,8 @@ class LockBase { } virtual bool give() { return xSemaphoreGive(_handle); } + + explicit operator bool() const { return _handle != nullptr; } }; inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& lock) { diff --git a/src/RTOScppQueue.h b/src/RTOScppQueue.h index 9b3febd..054051f 100644 --- a/src/RTOScppQueue.h +++ b/src/RTOScppQueue.h @@ -27,6 +27,9 @@ class QueueInterface { } QueueHandle_t _handle; + + public: + explicit operator bool() const { return _handle != nullptr; } }; inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, @@ -105,9 +108,9 @@ class QueueStatic : public QueueBase { }; template -class QueueStaticExternalStorage : public QueueBase { +class QueueExternalStorage : public QueueBase { public: - QueueStaticExternalStorage() + QueueExternalStorage() : QueueBase(nullptr) {} bool init(uint8_t* buffer, uint32_t buffer_size) { diff --git a/src/RTOScppTask.h b/src/RTOScppTask.h index 4f34270..7565c2a 100644 --- a/src/RTOScppTask.h +++ b/src/RTOScppTask.h @@ -74,6 +74,8 @@ class TaskBase { uint32_t notifyTake(bool clear, TickType_t ticks_to_wait = portMAX_DELAY) { return ulTaskNotifyTake(clear, ticks_to_wait); } + + explicit operator bool() const { return _handle != nullptr; } }; class TaskDynamic : public TaskBase { diff --git a/src/RTOScppTimer.h b/src/RTOScppTimer.h index feeae81..b4599b4 100644 --- a/src/RTOScppTimer.h +++ b/src/RTOScppTimer.h @@ -55,6 +55,8 @@ class TimerBase { void setReloadMode(bool auto_reload) { vTimerSetReloadMode(_handle, auto_reload); } bool getReloadMode() { return uxTimerGetReloadMode(_handle); } + + explicit operator bool() const { return _handle != nullptr; } }; class TimerDynamic : public TimerBase {