From 27152a2456e1eefd8ba91d0f445d0a927e9dfc61 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Wed, 17 Jul 2024 15:44:56 -0400 Subject: [PATCH 1/7] feat: Add task stats and optimize tasks --- src/RTOScppTask.h | 154 ++++++++++++++++++++++------------------------ 1 file changed, 73 insertions(+), 81 deletions(-) diff --git a/src/RTOScppTask.h b/src/RTOScppTask.h index 7565c2a..92c494d 100644 --- a/src/RTOScppTask.h +++ b/src/RTOScppTask.h @@ -1,148 +1,140 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_TASK_H -#define RTOS_CPP_TASK_H +#pragma once #include #include -class TaskBase { - private: - TaskBase(const TaskBase&) = delete; // Delete copy constructor - void operator=(const TaskBase&) = delete; // Delete copy assignment operator - +class TaskInterface { protected: - TaskBase(const char* name, TaskFunction_t function, uint8_t priority) + TaskInterface(const char* name, TaskFunction_t function, const uint8_t priority, + const uint32_t stack_size, const BaseType_t running_core) : _name(name) , _function(function) , _priority(priority) - , _handle(nullptr) {} - - virtual ~TaskBase() { - if (_handle) vTaskDelete(_handle); - } + , _stack_size(stack_size) + , _running_core(running_core) + , _handle(nullptr) + , _stack_used(0) + , _stack_min(0xffffffff) + , _stack_max(0) {} const char* _name; TaskFunction_t _function; uint8_t _priority; + const uint32_t _stack_size; + const BaseType_t _running_core; TaskHandle_t _handle; + uint32_t _stack_used; + uint32_t _stack_min; + uint32_t _stack_max; public: + virtual ~TaskInterface() { + if (_handle) vTaskDelete(_handle); + } + + TaskInterface(const TaskInterface&) = delete; + TaskInterface& operator=(const TaskInterface&) = delete; + TaskInterface(TaskInterface&&) noexcept = delete; + TaskInterface& operator=(TaskInterface&&) noexcept = delete; + virtual bool init() = 0; - void suspend() { vTaskSuspend(_handle); } - void resume() { vTaskResume(_handle); } - bool abortDelay() { return xTaskAbortDelay(_handle); } + void suspend() const { vTaskSuspend(_handle); } + void resume() const { vTaskResume(_handle); } + bool abortDelay() const { return xTaskAbortDelay(_handle); } - void setPriority(uint8_t priority) { + TaskHandle_t getHandle() const { return _handle; } + const char* getName() const { return _name; } + + void setPriority(const 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; } + uint8_t getPriority() const { return uxTaskPriorityGet(_handle); } + uint8_t getPriorityFromISR() const { return uxTaskPriorityGetFromISR(_handle); } + + uint32_t getStackSize() const { return _stack_size; } - bool notify(uint32_t value, eNotifyAction action) { return xTaskNotify(_handle, value, action); } + bool notify(const uint32_t value, const eNotifyAction action) { + return xTaskNotify(_handle, value, action); + } - bool notifyFromISR(uint32_t value, eNotifyAction action, BaseType_t& task_woken) { + bool notifyFromISR(const uint32_t value, const eNotifyAction action, + BaseType_t& task_woken) const { return xTaskNotifyFromISR(_handle, value, action, &task_woken); } - bool notifyAndQuery(uint32_t value, eNotifyAction action, uint32_t& old_value) { + bool notifyAndQuery(const uint32_t value, const eNotifyAction action, uint32_t& old_value) const { return xTaskNotifyAndQuery(_handle, value, action, &old_value); } - bool notifyAndQueryFromISR(uint32_t value, eNotifyAction action, uint32_t& old_value, - BaseType_t& task_woken) { + bool notifyAndQueryFromISR(const uint32_t value, const eNotifyAction action, uint32_t& old_value, + BaseType_t& task_woken) const { return xTaskNotifyAndQueryFromISR(_handle, value, action, &old_value, &task_woken); } - bool notifyWait(uint32_t clear_on_entry, uint32_t clear_on_exit, uint32_t* value, - TickType_t ticks_to_wait = portMAX_DELAY) { + bool notifyWait(const uint32_t clear_on_entry, const uint32_t clear_on_exit, + uint32_t* const value, const TickType_t ticks_to_wait = portMAX_DELAY) const { return xTaskNotifyWait(clear_on_entry, clear_on_exit, value, ticks_to_wait); } - bool notifyGive() { return xTaskNotifyGive(_handle); } - void notifyGiveFromISR(BaseType_t& task_woken) { vTaskNotifyGiveFromISR(_handle, &task_woken); } + bool notifyGive() const { return xTaskNotifyGive(_handle); } - uint32_t notifyTake(bool clear, TickType_t ticks_to_wait = portMAX_DELAY) { - return ulTaskNotifyTake(clear, ticks_to_wait); + void notifyGiveFromISR(BaseType_t& task_woken) const { + vTaskNotifyGiveFromISR(_handle, &task_woken); } - explicit operator bool() const { return _handle != nullptr; } -}; + uint32_t notifyTake(const bool clear, const TickType_t ticks_to_wait = portMAX_DELAY) const { + return ulTaskNotifyTake(clear, ticks_to_wait); + } -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) {} + void updateStackStats() { + _stack_used = _stack_size - uxTaskGetStackHighWaterMark(_handle); + _stack_min = min(_stack_min, _stack_used); + _stack_max = max(_stack_max, _stack_used); + } - bool init() { return xTaskCreate(_function, _name, _stack_size, nullptr, _priority, &_handle); } + uint32_t getStackUsed() const { return _stack_used; } + uint32_t getStackMinUsed() const { return _stack_min; } + uint32_t getStackMaxUsed() const { return _stack_max; } - private: - uint32_t _stack_size; + explicit operator bool() const { return _handle != nullptr; } }; -class TaskDynamicPinnedToCore : public TaskBase { +class TaskDynamic : public TaskInterface { 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) {} + TaskDynamic(const char* name, TaskFunction_t function, uint8_t priority, uint32_t stack_size, + BaseType_t running_core = ARDUINO_RUNNING_CORE) + : TaskInterface(name, function, priority, stack_size, running_core) {} bool init() { return xTaskCreatePinnedToCore( - _function, _name, _stack_size, nullptr, _priority, &_handle, _running_core); + _function, _name, _stack_size, nullptr, _priority, &_handle, _running_core) == pdPASS; } - - private: - uint32_t _stack_size; - BaseType_t _running_core; }; template -class TaskStatic : public TaskBase { +class TaskStatic : public TaskInterface { 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: - TaskStaticPinnedToCore(const char* name, TaskFunction_t function, uint8_t priority, - BaseType_t running_core) - : TaskBase(name, function, priority) - , _running_core(running_core) {} + TaskStatic(const char* name, TaskFunction_t function, uint8_t priority, + BaseType_t running_core = ARDUINO_RUNNING_CORE) + : TaskInterface(name, function, priority, STACK_SIZE, running_core) {} bool init() { _handle = xTaskCreateStaticPinnedToCore( - _function, _name, STACK_SIZE, nullptr, _priority, _stack, &_tcb, _running_core); + _function, _name, _stack_size, nullptr, _priority, _stack, &_tcb, _running_core); - return _handle != nullptr ? true : false; + return _handle != nullptr; } private: - BaseType_t _running_core; StaticTask_t _tcb; StackType_t _stack[STACK_SIZE]; -}; - -#endif // RTOS_CPP_TASK_H \ No newline at end of file +}; \ No newline at end of file From 14dea37b61ed369d59ef91f9a63c6affc013121d Mon Sep 17 00:00:00 2001 From: alkonosst Date: Wed, 17 Jul 2024 16:01:58 -0400 Subject: [PATCH 2/7] fix: Add constness to task function --- src/RTOScppTask.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/RTOScppTask.h b/src/RTOScppTask.h index 92c494d..8c791c6 100644 --- a/src/RTOScppTask.h +++ b/src/RTOScppTask.h @@ -11,7 +11,7 @@ class TaskInterface { protected: - TaskInterface(const char* name, TaskFunction_t function, const uint8_t priority, + TaskInterface(const char* name, const TaskFunction_t function, const uint8_t priority, const uint32_t stack_size, const BaseType_t running_core) : _name(name) , _function(function) @@ -24,7 +24,7 @@ class TaskInterface { , _stack_max(0) {} const char* _name; - TaskFunction_t _function; + const TaskFunction_t _function; uint8_t _priority; const uint32_t _stack_size; const BaseType_t _running_core; From 6aeb05af53f199f161073689b477dfb2092ee218 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Wed, 17 Jul 2024 16:02:51 -0400 Subject: [PATCH 3/7] feat: Change Timer base class name and add constness to methods --- src/RTOScppTimer.h | 102 +++++++++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 45 deletions(-) diff --git a/src/RTOScppTimer.h b/src/RTOScppTimer.h index 3257a23..f60a366 100644 --- a/src/RTOScppTimer.h +++ b/src/RTOScppTimer.h @@ -1,26 +1,18 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_TIMER_H -#define RTOS_CPP_TIMER_H +#pragma once #include #include -class TimerBase { - private: - TimerBase(const TimerBase&) = delete; // Delete copy constructor - void operator=(const TimerBase&) = delete; // Delete copy assignment operator - +class TimerInterface { protected: - TimerBase(TimerHandle_t handle) + TimerInterface(TimerHandle_t handle) : _handle(handle) {} - virtual ~TimerBase() { - if (_handle) xTimerDelete(_handle, portMAX_DELAY); - } TimerHandle_t _handle; const char* _name; @@ -31,8 +23,17 @@ class TimerBase { bool _start; public: - void setup(const char* name, TimerCallbackFunction_t callback, TickType_t period, void* id, - bool auto_reload, bool start) { + virtual ~TimerInterface() { + if (_handle) vTaskDelete(_handle); + } + + TimerInterface(const TimerInterface&) = delete; + TimerInterface& operator=(const TimerInterface&) = delete; + TimerInterface(TimerInterface&&) noexcept = delete; + TimerInterface& operator=(TimerInterface&&) noexcept = delete; + + void setup(const char* name, const TimerCallbackFunction_t callback, const TickType_t period, + void* id, const bool auto_reload, const bool start) { _name = name; _callback = callback; _period = period; @@ -43,53 +44,63 @@ class TimerBase { virtual bool create() = 0; - bool start(TickType_t ticks_to_wait = portMAX_DELAY) { + bool start(const TickType_t ticks_to_wait = portMAX_DELAY) const { return xTimerStart(_handle, ticks_to_wait); } - bool startFromISR(BaseType_t& task_woken) { return xTimerStartFromISR(_handle, &task_woken); } - 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 startFromISR(BaseType_t& task_woken) const { + return xTimerStartFromISR(_handle, &task_woken); + } + bool stop(const TickType_t ticks_to_wait = portMAX_DELAY) const { + return xTimerStop(_handle, ticks_to_wait); + } + bool stopFromISR(BaseType_t& task_woken) const { return xTimerStopFromISR(_handle, &task_woken); } + + bool isActive() const { return xTimerIsTimerActive(_handle); } - bool isActive() { return xTimerIsTimerActive(_handle); } - bool reset(TickType_t ticks_to_wait = portMAX_DELAY) { + bool reset(const TickType_t ticks_to_wait = portMAX_DELAY) const { return xTimerReset(_handle, ticks_to_wait); } - bool resetFromISR(BaseType_t& task_woken) { return xTimerResetFromISR(_handle, &task_woken); } + bool resetFromISR(BaseType_t& task_woken) const { + return xTimerResetFromISR(_handle, &task_woken); + } - const char* getName() { return pcTimerGetName(_handle); } - TickType_t getExpiryTime() { return xTimerGetExpiryTime(_handle); } + const char* getName() const { return pcTimerGetName(_handle); } + TickType_t getExpiryTime() const { return xTimerGetExpiryTime(_handle); } - bool setPeriod(TickType_t period, TickType_t ticks_to_wait = portMAX_DELAY) { + bool setPeriod(const TickType_t period, const TickType_t ticks_to_wait = portMAX_DELAY) const { return xTimerChangePeriod(_handle, period, ticks_to_wait); } - bool setPeriodFromISR(TickType_t period, BaseType_t& task_woken) { + bool setPeriodFromISR(const TickType_t period, BaseType_t& task_woken) const { return xTimerChangePeriodFromISR(_handle, period, &task_woken); } - TickType_t getPeriod() { return xTimerGetPeriod(_handle); } + TickType_t getPeriod() const { return xTimerGetPeriod(_handle); } - void setTimerID() { vTimerSetTimerID(_handle, _id); } - void* getTimerID() { return pvTimerGetTimerID(_handle); } + void setTimerID() const { vTimerSetTimerID(_handle, _id); } + void* getTimerID() const { return pvTimerGetTimerID(_handle); } - void setReloadMode(bool auto_reload) { vTimerSetReloadMode(_handle, auto_reload); } - bool getReloadMode() { return uxTimerGetReloadMode(_handle); } + void setReloadMode(const bool auto_reload) const { vTimerSetReloadMode(_handle, auto_reload); } + bool getReloadMode() const { return uxTimerGetReloadMode(_handle); } explicit operator bool() const { return _handle != nullptr; } }; -class TimerDynamic : public TimerBase { +class TimerDynamic : public TimerInterface { public: TimerDynamic() - : TimerBase(nullptr) {} + : TimerInterface(nullptr) {} - TimerDynamic(const char* name, TimerCallbackFunction_t callback, TickType_t period, void* id, - bool auto_reload, bool start) - : TimerBase(xTimerCreate(name, period, auto_reload, id, callback)) { + TimerDynamic(const char* name, const TimerCallbackFunction_t callback, const TickType_t period, + void* id, const bool auto_reload, const bool start) + : TimerInterface(xTimerCreate(name, period, auto_reload, id, callback)) { this->setup(name, callback, period, id, auto_reload, start); - if (start) this->start(); + + if ((_handle != nullptr) && start) { + this->start(); + } } bool create() { @@ -99,16 +110,19 @@ class TimerDynamic : public TimerBase { } }; -class TimerStatic : public TimerBase { +class TimerStatic : public TimerInterface { public: TimerStatic() - : TimerBase(nullptr) {} + : TimerInterface(nullptr) {} - TimerStatic(const char* name, TimerCallbackFunction_t callback, TickType_t period, void* id, - bool auto_reload, bool start) - : TimerBase(xTimerCreateStatic(name, period, auto_reload, id, callback, &_tcb)) { + TimerStatic(const char* name, const TimerCallbackFunction_t callback, const TickType_t period, + void* id, const bool auto_reload, const bool start) + : TimerInterface(xTimerCreateStatic(name, period, auto_reload, id, callback, &_tcb)) { this->setup(name, callback, period, id, auto_reload, start); - if (start) this->start(); + + if ((_handle != nullptr) && start) { + this->start(); + } } bool create() { @@ -119,6 +133,4 @@ class TimerStatic : public TimerBase { private: StaticTimer_t _tcb; -}; - -#endif // RTOS_CPP_TIMER_H \ No newline at end of file +}; \ No newline at end of file From 99e4c9234c04161756544ff00db5bba9c3aa662f Mon Sep 17 00:00:00 2001 From: alkonosst Date: Wed, 17 Jul 2024 17:58:35 -0400 Subject: [PATCH 4/7] feat: Add general methods to interface, add constness to methods, rename middle interface class --- src/RTOScppQueue.h | 87 +++++++++++++++++++++++----------------------- 1 file changed, 44 insertions(+), 43 deletions(-) diff --git a/src/RTOScppQueue.h b/src/RTOScppQueue.h index 054051f..ca9ebc7 100644 --- a/src/RTOScppQueue.h +++ b/src/RTOScppQueue.h @@ -1,11 +1,10 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_QUEUE_H -#define RTOS_CPP_QUEUE_H +#pragma once #include #include @@ -22,13 +21,31 @@ class QueueInterface { protected: QueueInterface(QueueHandle_t handle) : _handle(handle) {} - virtual ~QueueInterface() { - if (_handle) vQueueDelete(_handle); - } QueueHandle_t _handle; public: + virtual ~QueueInterface() { + if (_handle) vTaskDelete(_handle); + } + + QueueInterface(const QueueInterface&) = delete; + QueueInterface& operator=(const QueueInterface&) = delete; + QueueInterface(QueueInterface&&) noexcept = delete; + QueueInterface& operator=(QueueInterface&&) noexcept = delete; + + QueueHandle_t getHandle() const { return _handle; } + + uint32_t getAvailableMessages() const { return uxQueueMessagesWaiting(_handle); } + uint32_t getAvailableMessagesFromISR() const { return uxQueueMessagesWaitingFromISR(_handle); } + uint32_t getAvailableSpaces() const { return uxQueueSpacesAvailable(_handle); } + + void reset() const { xQueueReset(_handle); } + bool isFull() const { return uxQueueSpacesAvailable(_handle) == 0; } + bool isEmpty() const { return uxQueueMessagesWaiting(_handle) == 0; } + bool isFullFromISR() const { return xQueueIsQueueFullFromISR(_handle); } + bool isEmptyFromISR() const { return xQueueIsQueueEmptyFromISR(_handle); } + explicit operator bool() const { return _handle != nullptr; } }; @@ -38,69 +55,55 @@ inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, } template -class QueueBase : public QueueInterface { - private: - QueueBase(QueueBase const&) = delete; // Delete copy constructor - void operator=(QueueBase const&) = delete; // Delete copy assignment operator - +class _QueueBase : public QueueInterface { protected: - QueueBase(QueueHandle_t handle) + _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); } - void reset() { xQueueReset(_handle); } - bool isFull() { return uxQueueSpacesAvailable(_handle) == 0; } - bool isEmpty() { return uxQueueMessagesWaiting(_handle) == 0; } - bool isFullFromISR() { return xQueueIsQueueFullFromISR(_handle); } - bool isEmptyFromISR() { return xQueueIsQueueEmptyFromISR(_handle); } - - bool push(const T& item, TickType_t ticks_to_wait = portMAX_DELAY) { + bool push(const T& item, const TickType_t ticks_to_wait = portMAX_DELAY) const { return xQueueSendToFront(_handle, &item, ticks_to_wait); } - bool add(const T& item, TickType_t ticks_to_wait = portMAX_DELAY) { + bool add(const T& item, const TickType_t ticks_to_wait = portMAX_DELAY) const { return xQueueSendToBack(_handle, &item, ticks_to_wait); } - bool pop(T& var, TickType_t ticks_to_wait = portMAX_DELAY) { + bool pop(T& var, const TickType_t ticks_to_wait = portMAX_DELAY) const { return xQueueReceive(_handle, &var, ticks_to_wait); } - bool peek(T& var, TickType_t ticks_to_wait = 0) { + bool peek(T& var, const TickType_t ticks_to_wait = 0) const { return xQueuePeek(_handle, &var, ticks_to_wait); } - bool pushFromISR(const T& item, BaseType_t& task_woken) { + bool pushFromISR(const T& item, BaseType_t& task_woken) const { return xQueueSendToFrontFromISR(_handle, &item, &task_woken); } - bool addFromISR(const T& item, BaseType_t& task_woken) { + bool addFromISR(const T& item, BaseType_t& task_woken) const { return xQueueSendToBackFromISR(_handle, &item, &task_woken); } - bool popFromISR(T& var, BaseType_t& task_woken) { + bool popFromISR(T& var, BaseType_t& task_woken) const { return xQueueReceiveFromISR(_handle, &var, &task_woken); } - bool peekFromISR(T& var) { return xQueuePeekFromISR(_handle, &var); } + bool peekFromISR(T& var) const { return xQueuePeekFromISR(_handle, &var); } }; template -class QueueDynamic : public QueueBase { +class QueueDynamic : public _QueueBase { public: - QueueDynamic(uint32_t length) - : QueueBase(xQueueCreate(length, sizeof(T))) {} + QueueDynamic(const uint32_t length) + : _QueueBase(xQueueCreate(length, sizeof(T))) {} }; template -class QueueStatic : public QueueBase { +class QueueStatic : public _QueueBase { public: QueueStatic() - : QueueBase(xQueueCreateStatic(LENGTH, sizeof(T), _storage, &this->_tcb)) {} + : _QueueBase(xQueueCreateStatic(LENGTH, sizeof(T), _storage, &this->_tcb)) {} private: StaticQueue_t _tcb; @@ -108,18 +111,16 @@ class QueueStatic : public QueueBase { }; template -class QueueExternalStorage : public QueueBase { +class QueueExternalStorage : public _QueueBase { public: QueueExternalStorage() - : QueueBase(nullptr) {} + : _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; + bool init(uint8_t* const buffer, const uint32_t length) { + this->_handle = xQueueCreateStatic(length, sizeof(T), buffer, &this->_tcb); + return (this->_handle != nullptr); } private: StaticQueue_t _tcb; -}; - -#endif // RTOS_CPP_QUEUE_H \ No newline at end of file +}; \ No newline at end of file From a789608573ac004a3395b68a2259bee117a990ad Mon Sep 17 00:00:00 2001 From: alkonosst Date: Wed, 17 Jul 2024 18:02:19 -0400 Subject: [PATCH 5/7] feat: Remove all copy and move constructors, add constness to methods --- src/RTOScppQueueSet.h | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/src/RTOScppQueueSet.h b/src/RTOScppQueueSet.h index e0e2b5c..f112ef6 100644 --- a/src/RTOScppQueueSet.h +++ b/src/RTOScppQueueSet.h @@ -1,11 +1,10 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_QUEUE_SET_H -#define RTOS_CPP_QUEUE_SET_H +#pragma once #include "RTOScppLock.h" #include "RTOScppQueue.h" @@ -14,36 +13,37 @@ class QueueSet { public: - QueueSet(const uint8_t queue_length) + QueueSet(const uint32_t queue_length) : _handle(xQueueCreateSet(queue_length)) {} + ~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(RingBufferInterface& ring_buffer) { + QueueSet(const QueueSet&) = delete; + QueueSet& operator=(const QueueSet&) = delete; + QueueSet(QueueSet&&) noexcept = delete; + QueueSet& operator=(QueueSet&&) noexcept = delete; + + bool add(LockBase& lock) const { return xQueueAddToSet(lock._handle, _handle); } + bool add(QueueSet& queue) const { return xQueueAddToSet(queue._handle, _handle); } + bool add(RingBufferInterface& ring_buffer) const { 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(RingBufferInterface& ring_buffer) { + bool remove(LockBase& lock) const { return xQueueRemoveFromSet(lock._handle, _handle); } + bool remove(QueueSet& queue) const { return xQueueRemoveFromSet(queue._handle, _handle); } + bool remove(RingBufferInterface& ring_buffer) const { return xRingbufferRemoveFromQueueSetRead(ring_buffer._handle, _handle); } - QueueSetMemberHandle_t select(TickType_t ticks_to_wait = portMAX_DELAY) { + QueueSetMemberHandle_t select(const TickType_t ticks_to_wait = portMAX_DELAY) const { return xQueueSelectFromSet(_handle, ticks_to_wait); } - QueueSetMemberHandle_t selectFromISR() { return xQueueSelectFromSetFromISR(_handle); } + QueueSetMemberHandle_t selectFromISR() const { return xQueueSelectFromSetFromISR(_handle); } explicit operator bool() const { return _handle != nullptr; } private: QueueSetHandle_t _handle; - - 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 +}; \ No newline at end of file From eaeac2a0af0a5c4622d972e3e9a0322257e3e2c5 Mon Sep 17 00:00:00 2001 From: alkonosst Date: Thu, 18 Jul 2024 11:28:57 -0400 Subject: [PATCH 6/7] feat: Rename lock interface class and add constness to methods --- src/RTOScppLock.h | 76 +++++++++++++++++++++++-------------------- src/RTOScppQueueSet.h | 8 ++--- 2 files changed, 44 insertions(+), 40 deletions(-) diff --git a/src/RTOScppLock.h b/src/RTOScppLock.h index 9487683..765b040 100644 --- a/src/RTOScppLock.h +++ b/src/RTOScppLock.h @@ -1,11 +1,10 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_LOCK_H -#define RTOS_CPP_LOCK_H +#pragma once #include #include @@ -14,88 +13,95 @@ // Forward declaration of QueueSet class QueueSet; -class LockBase { +class LockInterface { private: - LockBase(LockBase const&) = delete; // Delete copy constructor - void operator=(LockBase const&) = delete; // Delete copy assignment operator - friend class QueueSet; - friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& lock); + friend bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockInterface& lock); protected: - LockBase(SemaphoreHandle_t handle) + LockInterface(SemaphoreHandle_t handle) : _handle(handle) {} - virtual ~LockBase() { - if (_handle) vSemaphoreDelete(_handle); - } SemaphoreHandle_t _handle; public: - virtual bool take(const TickType_t ticks_to_wait = portMAX_DELAY) { + virtual ~LockInterface() { + if (_handle) vSemaphoreDelete(_handle); + } + + LockInterface(const LockInterface&) = delete; + LockInterface& operator=(const LockInterface&) = delete; + LockInterface(LockInterface&&) noexcept = delete; + LockInterface& operator=(LockInterface&&) noexcept = delete; + + virtual bool take(const TickType_t ticks_to_wait = portMAX_DELAY) const { return xSemaphoreTake(_handle, ticks_to_wait); } - virtual bool give() { return xSemaphoreGive(_handle); } + virtual bool give() const { return xSemaphoreGive(_handle); } explicit operator bool() const { return _handle != nullptr; } }; -inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockBase& lock) { +inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, const LockInterface& lock) { return queue_set_member == lock._handle; } -class MutexDynamic : public LockBase { +class MutexDynamic : public LockInterface { public: MutexDynamic() - : LockBase(xSemaphoreCreateMutex()) {} + : LockInterface(xSemaphoreCreateMutex()) {} }; -class MutexStatic : public LockBase { +class MutexStatic : public LockInterface { public: MutexStatic() - : LockBase(xSemaphoreCreateMutexStatic(&_tcb)) {} + : LockInterface(xSemaphoreCreateMutexStatic(&_tcb)) {} private: StaticSemaphore_t _tcb; }; -class MutexRecursiveDynamic : public LockBase { +class MutexRecursiveDynamic : public LockInterface { public: MutexRecursiveDynamic() - : LockBase(xSemaphoreCreateRecursiveMutex()) {} + : LockInterface(xSemaphoreCreateRecursiveMutex()) {} - bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { + bool take(const TickType_t ticks_to_wait = portMAX_DELAY) const override { return xSemaphoreTakeRecursive(_handle, ticks_to_wait); } - bool give() override { return xSemaphoreGiveRecursive(_handle); } + bool give() const override { return xSemaphoreGiveRecursive(_handle); } }; -class MutexRecursiveStatic : public LockBase { +class MutexRecursiveStatic : public LockInterface { public: MutexRecursiveStatic() - : LockBase(xSemaphoreCreateRecursiveMutexStatic(&_tcb)) {} + : LockInterface(xSemaphoreCreateRecursiveMutexStatic(&_tcb)) {} - bool take(const TickType_t ticks_to_wait = portMAX_DELAY) override { + bool take(const TickType_t ticks_to_wait = portMAX_DELAY) const override { return xSemaphoreTakeRecursive(_handle, ticks_to_wait); } - bool give() override { return xSemaphoreGiveRecursive(_handle); } + bool give() const override { return xSemaphoreGiveRecursive(_handle); } private: StaticSemaphore_t _tcb; }; -class Semaphore : public LockBase { +class Semaphore : public LockInterface { protected: - Semaphore(SemaphoreHandle_t handle) - : LockBase(handle) {} + Semaphore(const SemaphoreHandle_t handle) + : LockInterface(handle) {} 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); } + bool takeFromISR(BaseType_t& task_woken) const { + return xSemaphoreTakeFromISR(_handle, &task_woken); + } + bool giveFromISR(BaseType_t& task_woken) const { + return xSemaphoreGiveFromISR(_handle, &task_woken); + } + uint8_t getCount() const { return uxSemaphoreGetCount(_handle); } }; class SemaphoreBinaryDynamic : public Semaphore { @@ -126,6 +132,4 @@ class SemaphoreCountingStatic : public Semaphore { private: StaticSemaphore_t _tcb; -}; - -#endif // RTOS_CPP_LOCK_H \ No newline at end of file +}; \ No newline at end of file diff --git a/src/RTOScppQueueSet.h b/src/RTOScppQueueSet.h index f112ef6..28c0883 100644 --- a/src/RTOScppQueueSet.h +++ b/src/RTOScppQueueSet.h @@ -25,14 +25,14 @@ class QueueSet { QueueSet(QueueSet&&) noexcept = delete; QueueSet& operator=(QueueSet&&) noexcept = delete; - bool add(LockBase& lock) const { return xQueueAddToSet(lock._handle, _handle); } - bool add(QueueSet& queue) const { return xQueueAddToSet(queue._handle, _handle); } + bool add(LockInterface& lock) const { return xQueueAddToSet(lock._handle, _handle); } + bool add(QueueInterface& queue) const { return xQueueAddToSet(queue._handle, _handle); } bool add(RingBufferInterface& ring_buffer) const { return xRingbufferAddToQueueSetRead(ring_buffer._handle, _handle); } - bool remove(LockBase& lock) const { return xQueueRemoveFromSet(lock._handle, _handle); } - bool remove(QueueSet& queue) const { return xQueueRemoveFromSet(queue._handle, _handle); } + bool remove(LockInterface& lock) const { return xQueueRemoveFromSet(lock._handle, _handle); } + bool remove(QueueInterface& queue) const { return xQueueRemoveFromSet(queue._handle, _handle); } bool remove(RingBufferInterface& ring_buffer) const { return xRingbufferRemoveFromQueueSetRead(ring_buffer._handle, _handle); } From 58b5d92959a8d50635690815d4e519dea9019b9b Mon Sep 17 00:00:00 2001 From: alkonosst Date: Thu, 18 Jul 2024 11:39:41 -0400 Subject: [PATCH 7/7] feat: Rename buffer interfaces and add constness to methods --- src/RTOScppBuffer.h | 85 +++++++++++++++++++++-------------------- src/RTOScppRingBuffer.h | 70 +++++++++++++++++---------------- 2 files changed, 82 insertions(+), 73 deletions(-) diff --git a/src/RTOScppBuffer.h b/src/RTOScppBuffer.h index ffbf2b5..df90cef 100644 --- a/src/RTOScppBuffer.h +++ b/src/RTOScppBuffer.h @@ -1,82 +1,87 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_BUFFER_H -#define RTOS_CPP_BUFFER_H +#pragma once #include #include #include -class DataBufferBase { - private: - DataBufferBase(const DataBufferBase&) = delete; // Delete copy constructor - void operator=(const DataBufferBase&) = delete; // Delete copy assignment operator - +class DataBufferInterface { protected: - DataBufferBase(StreamBufferHandle_t handle) + DataBufferInterface(const StreamBufferHandle_t handle) : _handle(handle) {} - virtual ~DataBufferBase() { vStreamBufferDelete(_handle); } StreamBufferHandle_t _handle; public: - uint32_t send(const void* tx_buffer, uint32_t bytes, TickType_t ticks_to_wait = portMAX_DELAY) { + virtual ~DataBufferInterface() { + if (_handle) vStreamBufferDelete(_handle); + } + + DataBufferInterface(const DataBufferInterface&) = delete; + DataBufferInterface& operator=(const DataBufferInterface&) = delete; + DataBufferInterface(DataBufferInterface&&) noexcept = delete; + DataBufferInterface& operator=(DataBufferInterface&&) noexcept = delete; + + uint32_t send(const void* tx_buffer, const uint32_t bytes, + const TickType_t ticks_to_wait = portMAX_DELAY) const { return xStreamBufferSend(_handle, tx_buffer, bytes, ticks_to_wait); } - uint32_t sendFromISR(const void* tx_buffer, uint32_t bytes, BaseType_t& task_woken) { + uint32_t sendFromISR(const void* tx_buffer, const uint32_t bytes, BaseType_t& task_woken) const { return xStreamBufferSendFromISR(_handle, tx_buffer, bytes, &task_woken); } - uint32_t receive(void* rx_buffer, uint32_t bytes, TickType_t ticks_to_wait = portMAX_DELAY) { + uint32_t receive(void* rx_buffer, const uint32_t bytes, + const TickType_t ticks_to_wait = portMAX_DELAY) const { return xStreamBufferReceive(_handle, rx_buffer, bytes, ticks_to_wait); } - uint32_t receiveFromISR(void* rx_buffer, uint32_t bytes, BaseType_t& task_woken) { + uint32_t receiveFromISR(void* rx_buffer, const uint32_t bytes, BaseType_t& task_woken) const { return xStreamBufferReceiveFromISR(_handle, rx_buffer, bytes, &task_woken); } - bool reset() { return xStreamBufferReset(_handle); } - bool isEmpty() { return xStreamBufferIsEmpty(_handle); } - bool isFull() { return xStreamBufferIsFull(_handle); } - uint32_t availableSpaces() { return xStreamBufferSpacesAvailable(_handle); } - uint32_t availableBytes() { return xStreamBufferBytesAvailable(_handle); } + bool reset() const { return xStreamBufferReset(_handle); } + bool isEmpty() const { return xStreamBufferIsEmpty(_handle); } + bool isFull() const { return xStreamBufferIsFull(_handle); } + uint32_t availableSpaces() const { return xStreamBufferSpacesAvailable(_handle); } + uint32_t availableBytes() const { return xStreamBufferBytesAvailable(_handle); } - bool setTriggerLevel(uint32_t trigger_bytes) { + bool setTriggerLevel(const uint32_t trigger_bytes) { return xStreamBufferSetTriggerLevel(_handle, trigger_bytes); } explicit operator bool() const { return _handle != nullptr; } }; -class StreamBufferDynamic : public DataBufferBase { +class StreamBufferDynamic : public DataBufferInterface { public: - StreamBufferDynamic(uint32_t buffer_size, uint32_t trigger_bytes) - : DataBufferBase(xStreamBufferGenericCreate(buffer_size + 1, trigger_bytes, false)) {} + StreamBufferDynamic(const uint32_t buffer_size, const uint32_t trigger_bytes) + : DataBufferInterface(xStreamBufferGenericCreate(buffer_size + 1, trigger_bytes, false)) {} }; template -class StreamBufferStatic : public DataBufferBase { +class StreamBufferStatic : public DataBufferInterface { public: - StreamBufferStatic(uint32_t trigger_bytes) - : DataBufferBase(xStreamBufferGenericCreateStatic(BUFFER_SIZE + 1, trigger_bytes, false, - _storage, &_tcb)) {} + StreamBufferStatic(const uint32_t trigger_bytes) + : DataBufferInterface(xStreamBufferGenericCreateStatic(BUFFER_SIZE + 1, trigger_bytes, false, + _storage, &_tcb)) {} private: StaticStreamBuffer_t _tcb; uint8_t _storage[BUFFER_SIZE + 1]; }; -class StreamBufferExternalStorage : public DataBufferBase { +class StreamBufferExternalStorage : public DataBufferInterface { public: - StreamBufferExternalStorage(uint32_t trigger_bytes) - : DataBufferBase(nullptr) {} + StreamBufferExternalStorage(const uint32_t trigger_bytes) + : DataBufferInterface(nullptr) {} - bool init(uint32_t trigger_bytes, uint8_t* buffer, uint32_t buffer_size) { + bool init(const uint32_t trigger_bytes, uint8_t* const buffer, const uint32_t buffer_size) { _handle = xStreamBufferGenericCreateStatic(buffer_size + 1, trigger_bytes, pdFALSE, buffer, &_tcb); return _handle != nullptr ? true : false; @@ -86,17 +91,17 @@ class StreamBufferExternalStorage : public DataBufferBase { StaticStreamBuffer_t _tcb; }; -class MessageBufferDynamic : public DataBufferBase { +class MessageBufferDynamic : public DataBufferInterface { public: - MessageBufferDynamic(uint32_t buffer_size) - : DataBufferBase(xStreamBufferGenericCreate(buffer_size + 1, 0, false)) {} + MessageBufferDynamic(const uint32_t buffer_size) + : DataBufferInterface(xStreamBufferGenericCreate(buffer_size + 1, 0, false)) {} }; template -class MessageBufferStatic : public DataBufferBase { +class MessageBufferStatic : public DataBufferInterface { public: MessageBufferStatic() - : DataBufferBase( + : DataBufferInterface( xStreamBufferGenericCreateStatic(BUFFER_SIZE + 1, 0, false, _storage, &_tcb)) {} private: @@ -104,12 +109,12 @@ class MessageBufferStatic : public DataBufferBase { uint8_t _storage[BUFFER_SIZE + 1]; }; -class MessageBufferExternalStorage : public DataBufferBase { +class MessageBufferExternalStorage : public DataBufferInterface { public: MessageBufferExternalStorage() - : DataBufferBase(nullptr) {} + : DataBufferInterface(nullptr) {} - bool init(uint32_t trigger_bytes, uint8_t* buffer, uint32_t buffer_size) { + bool init(const uint32_t trigger_bytes, uint8_t* const buffer, const uint32_t buffer_size) { _handle = xStreamBufferGenericCreateStatic(buffer_size + 1, 0, true, buffer, &_tcb); return _handle != nullptr ? true : false; } @@ -117,5 +122,3 @@ class MessageBufferExternalStorage : public DataBufferBase { private: StaticStreamBuffer_t _tcb; }; - -#endif // RTOS_CPP_BUFFER_H diff --git a/src/RTOScppRingBuffer.h b/src/RTOScppRingBuffer.h index 577055d..b43ce26 100644 --- a/src/RTOScppRingBuffer.h +++ b/src/RTOScppRingBuffer.h @@ -1,11 +1,10 @@ /** - * SPDX-FileCopyrightText: 2023 Maximiliano Ramirez + * SPDX-FileCopyrightText: 2024 Maximiliano Ramirez * * SPDX-License-Identifier: GPL-3.0-or-later */ -#ifndef RTOS_CPP_RINGBUFFER_H -#define RTOS_CPP_RINGBUFFER_H +#pragma once #include #include @@ -15,23 +14,26 @@ class QueueSet; class RingBufferInterface { private: - 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 RingBufferInterface& ring_buffer); protected: - RingBufferInterface(RingbufHandle_t handle) + RingBufferInterface(const RingbufHandle_t handle) : _handle(handle) {} + + RingbufHandle_t _handle; + + public: virtual ~RingBufferInterface() { if (_handle) vRingbufferDelete(_handle); } - RingbufHandle_t _handle; + RingBufferInterface(const RingBufferInterface&) = delete; + RingBufferInterface& operator=(const RingBufferInterface&) = delete; + RingBufferInterface(RingBufferInterface&&) noexcept = delete; + RingBufferInterface& operator=(RingBufferInterface&&) noexcept = delete; - public: explicit operator bool() const { return _handle != nullptr; } }; @@ -43,21 +45,24 @@ inline bool operator==(const QueueSetMemberHandle_t& queue_set_member, template class RingBufferBase : public RingBufferInterface { protected: - RingBufferBase(RingbufHandle_t handle) + RingBufferBase(const RingbufHandle_t handle) : RingBufferInterface(handle) {} virtual ~RingBufferBase() {} public: - bool send(const T* item, uint32_t item_size, TickType_t ticks_to_wait = portMAX_DELAY) { + bool send(const T* const item, const uint32_t item_size, + const TickType_t ticks_to_wait = portMAX_DELAY) const { 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) { + bool sendFromISR(const T* const item, const uint32_t item_size, + BaseType_t& higher_priority_task_woken) const { return xRingbufferSendFromISR(_handle, (void*)item, item_size, &higher_priority_task_woken); } - void returnItem(T* item) { vRingbufferReturnItem(_handle, (void*)item); } - void returnItemFromISR(T* item, BaseType_t& higher_priority_task_woken) { + void returnItem(const T* const item) const { vRingbufferReturnItem(_handle, (void*)item); } + + void returnItemFromISR(const T* const item, BaseType_t& higher_priority_task_woken) const { vRingbufferReturnItemFromISR(_handle, (void*)item, &higher_priority_task_woken); } }; @@ -65,12 +70,12 @@ class RingBufferBase : public RingBufferInterface { template class RingBufferNoSplitBase : public RingBufferBase { protected: - RingBufferNoSplitBase(RingbufHandle_t handle) + RingBufferNoSplitBase(const RingbufHandle_t handle) : RingBufferBase(handle) {} virtual ~RingBufferNoSplitBase() {} public: - T* receive(uint32_t& item_size, TickType_t ticks_to_wait = portMAX_DELAY) { + T* receive(uint32_t& item_size, const TickType_t ticks_to_wait = portMAX_DELAY) { return (T*)xRingbufferReceive(this->_handle, &item_size, ticks_to_wait); } @@ -85,7 +90,7 @@ class RingBufferNoSplitDynamic : public RingBufferNoSplitBase { // Size aligned to nearest 4 bytes + 8 bytes per item static constexpr uint32_t ALIGNED_SIZE = 4 * ((sizeof(T) + 3) / 4) + 8; - RingBufferNoSplitDynamic(uint32_t length) + RingBufferNoSplitDynamic(const uint32_t length) : RingBufferNoSplitBase(xRingbufferCreate(length * ALIGNED_SIZE, RINGBUF_TYPE_NOSPLIT)) {} }; @@ -113,7 +118,8 @@ class RingBufferNoSplitExternalStorage : public RingBufferNoSplitBase { RingBufferNoSplitExternalStorage() : RingBufferNoSplitBase(nullptr) {} - bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { + bool create(StaticRingbuffer_t* const tcb, uint8_t* const buffer_storage, + const uint32_t buffer_size) const { this->_handle = xRingbufferCreateStatic(buffer_size, RINGBUF_TYPE_NOSPLIT, buffer_storage, tcb); return this->_handle != nullptr ? true : false; } @@ -122,18 +128,19 @@ class RingBufferNoSplitExternalStorage : public RingBufferNoSplitBase { template class RingBufferSplitBase : public RingBufferBase { protected: - RingBufferSplitBase(RingbufHandle_t handle) + RingBufferSplitBase(const 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) { + const TickType_t ticks_to_wait = portMAX_DELAY) const { 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) { + bool receiveFromISR(T** head, T** tail, uint32_t& head_item_size, + uint32_t& tail_item_size) const { return xRingbufferReceiveSplitFromISR( this->_handle, head, tail, &head_item_size, &tail_item_size); } @@ -145,7 +152,7 @@ class RingBufferSplitDynamic : public RingBufferSplitBase { // Size aligned to nearest 4 bytes + 8 bytes per item static constexpr uint32_t ALIGNED_SIZE = 4 * ((sizeof(T) + 3) / 4) + 8; - RingBufferSplitDynamic(uint32_t length) + RingBufferSplitDynamic(const uint32_t length) : RingBufferSplitBase(xRingbufferCreate(length * ALIGNED_SIZE, RINGBUF_TYPE_ALLOWSPLIT)) {} }; @@ -173,7 +180,7 @@ class RingBufferSplitExternalStorage : public RingBufferSplitBase { RingBufferSplitExternalStorage() : RingBufferSplitBase(nullptr) {} - bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { + bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) const { this->_handle = xRingbufferCreateStatic(buffer_size, RINGBUF_TYPE_ALLOWSPLIT, buffer_storage, tcb); return this->_handle != nullptr ? true : false; @@ -183,17 +190,17 @@ class RingBufferSplitExternalStorage : public RingBufferSplitBase { template class RingBufferByteBase : public RingBufferBase { protected: - RingBufferByteBase(RingbufHandle_t handle) + RingBufferByteBase(const 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) { + T* receiveUpTo(const uint32_t max_item_size, uint32_t& item_size, + const TickType_t ticks_to_wait = portMAX_DELAY) const { return (T*)xRingbufferReceiveUpTo(this->_handle, &item_size, ticks_to_wait, max_item_size); } - T* receiveUpToFromISR(uint32_t max_item_size, uint32_t& item_size) { + T* receiveUpToFromISR(const uint32_t max_item_size, uint32_t& item_size) const { return (T*)xRingbufferReceiveUpToFromISR(this->_handle, &item_size, max_item_size); } }; @@ -201,7 +208,7 @@ class RingBufferByteBase : public RingBufferBase { template class RingBufferByteDynamic : public RingBufferByteBase { public: - RingBufferByteDynamic(uint32_t length) + RingBufferByteDynamic(const uint32_t length) : RingBufferByteBase(xRingbufferCreate(length, RINGBUF_TYPE_BYTEBUF)) {} }; @@ -223,10 +230,9 @@ class RingBufferByteExternalStorage : public RingBufferByteBase { RingBufferByteExternalStorage() : RingBufferByteBase(nullptr) {} - bool create(StaticRingbuffer_t* tcb, uint8_t* buffer_storage, uint32_t buffer_size) { + bool create(StaticRingbuffer_t* const tcb, uint8_t* const buffer_storage, + const uint32_t buffer_size) const { 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 +}; \ No newline at end of file