From 066930b110730c8c781f0b680e1f7b99f1dbe920 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Mon, 18 May 2020 20:39:48 +0200 Subject: [PATCH] improvements --- osal/FreeRTOS/BinarySemaphore.cpp | 42 +++++++++++++++--------------- osal/FreeRTOS/BinarySemaphore.h | 20 +++++++------- osal/FreeRTOS/CountingSemaphore.h | 10 ++++++- osal/FreeRTOS/SemaphoreFactory.cpp | 2 +- 4 files changed, 41 insertions(+), 33 deletions(-) diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp index 11e48153..f08e3b81 100644 --- a/osal/FreeRTOS/BinarySemaphore.cpp +++ b/osal/FreeRTOS/BinarySemaphore.cpp @@ -3,7 +3,7 @@ #include -Semaphore::Semaphore() { +BinarySemaphore::BinarySemaphore() { handle = xSemaphoreCreateBinary(); if(handle == nullptr) { sif::error << "Semaphore: Binary semaph creation failure" << std::endl; @@ -11,13 +11,13 @@ Semaphore::Semaphore() { xSemaphoreGive(handle); } -Semaphore::~Semaphore() { +BinarySemaphore::~BinarySemaphore() { vSemaphoreDelete(handle); } // This copy ctor is important as it prevents the assignment to a ressource // (other.handle) variable which is later deleted! -Semaphore::Semaphore(const Semaphore& other) { +BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) { handle = xSemaphoreCreateBinary(); if(handle == nullptr) { sif::error << "Binary semaphore creation failure" << std::endl; @@ -25,7 +25,7 @@ Semaphore::Semaphore(const Semaphore& other) { xSemaphoreGive(handle); } -Semaphore& Semaphore::operator =(const Semaphore& s) { +BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) { if(this != &s) { handle = xSemaphoreCreateBinary(); if(handle == nullptr) { @@ -36,7 +36,7 @@ Semaphore& Semaphore::operator =(const Semaphore& s) { return *this; } -Semaphore::Semaphore(Semaphore&& s) { +BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) { handle = xSemaphoreCreateBinary(); if(handle == nullptr) { sif::error << "Binary semaphore creation failure" << std::endl; @@ -44,8 +44,8 @@ Semaphore::Semaphore(Semaphore&& s) { xSemaphoreGive(handle); } -Semaphore& Semaphore::operator =( - Semaphore&& s) { +BinarySemaphore& BinarySemaphore::operator =( + BinarySemaphore&& s) { if(&s != this) { handle = xSemaphoreCreateBinary(); if(handle == nullptr) { @@ -56,15 +56,15 @@ Semaphore& Semaphore::operator =( return *this; } -ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) { +ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) { if(handle == nullptr) { return SEMAPHORE_NULLPOINTER; } - TickType_t timeout = Semaphore::NO_BLOCK_TICKS; - if(timeoutMs == Semaphore::BLOCK_TIMEOUT) { - timeout = Semaphore::BLOCK_TIMEOUT_TICKS; + TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS; + if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) { + timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS; } - else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){ + else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){ timeout = pdMS_TO_TICKS(timeoutMs); } @@ -77,7 +77,7 @@ ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) { } } -ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout( +ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout( TickType_t timeoutTicks) { if(handle == nullptr) { return SEMAPHORE_NULLPOINTER; @@ -91,7 +91,7 @@ ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout( } } -ReturnValue_t Semaphore::giveBinarySemaphore() { +ReturnValue_t BinarySemaphore::giveBinarySemaphore() { if (handle == nullptr) { return SEMAPHORE_NULLPOINTER; } @@ -103,11 +103,11 @@ ReturnValue_t Semaphore::giveBinarySemaphore() { } } -SemaphoreHandle_t Semaphore::getSemaphore() { +SemaphoreHandle_t BinarySemaphore::getSemaphore() { return handle; } -ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) { +ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) { if (semaphore == nullptr) { return SEMAPHORE_NULLPOINTER; } @@ -119,7 +119,7 @@ ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) { } } -void Semaphore::resetSemaphore() { +void BinarySemaphore::resetSemaphore() { if(handle != nullptr) { vSemaphoreDelete(handle); handle = xSemaphoreCreateBinary(); @@ -127,20 +127,20 @@ void Semaphore::resetSemaphore() { } } -ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) { +ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) { return takeBinarySemaphore(timeoutMs); } -ReturnValue_t Semaphore::release() { +ReturnValue_t BinarySemaphore::release() { return giveBinarySemaphore(); } -uint8_t Semaphore::getSemaphoreCounter() { +uint8_t BinarySemaphore::getSemaphoreCounter() { return uxSemaphoreGetCount(handle); } // Be careful with the stack size here. This is called from an ISR! -ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore, +ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore, BaseType_t * higherPriorityTaskWoken) { if (semaphore == nullptr) { return SEMAPHORE_NULLPOINTER; diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h index 6383432f..bd4ddb95 100644 --- a/osal/FreeRTOS/BinarySemaphore.h +++ b/osal/FreeRTOS/BinarySemaphore.h @@ -23,7 +23,7 @@ extern "C" { * @author R. Mueller * @ingroup osal */ -class Semaphore: public SemaphoreIF, +class BinarySemaphore: public SemaphoreIF, public HasReturnvaluesIF { public: static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF; @@ -44,20 +44,20 @@ public: static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3); //! @brief Default ctor - Semaphore(); + BinarySemaphore(); //! @brief Copy ctor - Semaphore(const Semaphore&); + BinarySemaphore(const BinarySemaphore&); //! @brief Copy assignment - Semaphore& operator=(const Semaphore&); + BinarySemaphore& operator=(const BinarySemaphore&); //! @brief Move ctor - Semaphore (Semaphore &&); + BinarySemaphore (BinarySemaphore &&); //! @brief Move assignment - Semaphore & operator=(Semaphore &&); + BinarySemaphore & operator=(BinarySemaphore &&); //! @brief Destructor - virtual ~Semaphore(); + virtual ~BinarySemaphore(); ReturnValue_t acquire(uint32_t timeoutMs = - Semaphore::NO_BLOCK_TIMEOUT) override; + BinarySemaphore::NO_BLOCK_TIMEOUT) override; ReturnValue_t release() override; uint8_t getSemaphoreCounter() override; @@ -71,7 +71,7 @@ public: * -@c RETURN_FAILED on failure */ ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs = - Semaphore::NO_BLOCK_TIMEOUT); + BinarySemaphore::NO_BLOCK_TIMEOUT); /** * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks. @@ -80,7 +80,7 @@ public: * - @c RETURN_FAILED on failure */ ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks = - Semaphore::NO_BLOCK_TICKS); + BinarySemaphore::NO_BLOCK_TICKS); /** * Give back the binary semaphore diff --git a/osal/FreeRTOS/CountingSemaphore.h b/osal/FreeRTOS/CountingSemaphore.h index 8c059af5..a33a0fa5 100644 --- a/osal/FreeRTOS/CountingSemaphore.h +++ b/osal/FreeRTOS/CountingSemaphore.h @@ -2,7 +2,15 @@ #define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ #include -class CountingSemaphore: public Semaphore { +/** + * @brief Counting semaphores, which can be acquire more than once. + * @details + * See: https://www.freertos.org/CreateCounting.html + * API of counting semaphores is almost identical to binary semaphores, + * so we just inherit from binary semaphore and provide the respective + * constructors. + */ +class CountingSemaphore: public BinarySemaphore { public: CountingSemaphore(uint8_t count, uint8_t initCount); //! @brief Copy ctor, disabled diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp index dd319025..9a355891 100644 --- a/osal/FreeRTOS/SemaphoreFactory.cpp +++ b/osal/FreeRTOS/SemaphoreFactory.cpp @@ -20,7 +20,7 @@ SemaphoreFactory* SemaphoreFactory::instance() { } SemaphoreIF* SemaphoreFactory::createBinarySemaphore() { - return new Semaphore(); + return new BinarySemaphore(); } SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,