implemented semaph factory

osal/FreeRTOS/BinarySemaphore.cpp

@@ -3,21 +3,21 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-BinarySemaphore::BinarySemaphore() {
+Semaphore::Semaphore() {
 	handle = xSemaphoreCreateBinary();
 	if(handle == nullptr) {
-		sif::error << "Binary semaphore creation failure" << std::endl;
+		sif::error << "Semaphore: Binary semaph creation failure" << std::endl;
 	}
 	xSemaphoreGive(handle);
 }
 
-BinarySemaphore::~BinarySemaphore() {
+Semaphore::~Semaphore() {
 	vSemaphoreDelete(handle);
 }
 
 // This copy ctor is important as it prevents the assignment to a ressource
 // (other.handle) variable which is later deleted!
-BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
+Semaphore::Semaphore(const Semaphore& other) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -25,7 +25,7 @@ BinarySemaphore::BinarySemaphore(const BinarySemaphore& other) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
+Semaphore& Semaphore::operator =(const Semaphore& s) {
     if(this != &s) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -36,7 +36,7 @@ BinarySemaphore& BinarySemaphore::operator =(const BinarySemaphore& s) {
     return *this;
 }
 
-BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
+Semaphore::Semaphore(Semaphore&& s) {
     handle = xSemaphoreCreateBinary();
     if(handle == nullptr) {
         sif::error << "Binary semaphore creation failure" << std::endl;
@@ -44,8 +44,8 @@ BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
     xSemaphoreGive(handle);
 }
 
-BinarySemaphore& BinarySemaphore::operator =(
+Semaphore& Semaphore::operator =(
-        BinarySemaphore&& s) {
+        Semaphore&& s) {
     if(&s != this) {
         handle = xSemaphoreCreateBinary();
         if(handle == nullptr) {
@@ -56,15 +56,15 @@ BinarySemaphore& BinarySemaphore::operator =(
     return *this;
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
-	TickType_t timeout = BinarySemaphore::NO_BLOCK_TICKS;
+	TickType_t timeout = Semaphore::NO_BLOCK_TICKS;
-	if(timeoutMs == BinarySemaphore::BLOCK_TIMEOUT) {
+	if(timeoutMs == Semaphore::BLOCK_TIMEOUT) {
-	    timeout = BinarySemaphore::BLOCK_TIMEOUT_TICKS;
+	    timeout = Semaphore::BLOCK_TIMEOUT_TICKS;
 	}
-	else if(timeoutMs > BinarySemaphore::NO_BLOCK_TIMEOUT){
+	else if(timeoutMs > Semaphore::NO_BLOCK_TIMEOUT){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -77,7 +77,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphore(uint32_t timeoutMs) {
 	}
 }
 
-ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
+ReturnValue_t Semaphore::takeBinarySemaphoreTickTimeout(
         TickType_t timeoutTicks) {
 	if(handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -91,7 +91,7 @@ ReturnValue_t BinarySemaphore::takeBinarySemaphoreTickTimeout(
 	}
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
+ReturnValue_t Semaphore::giveBinarySemaphore() {
 	if (handle == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -103,11 +103,11 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore() {
 	}
 }
 
-SemaphoreHandle_t BinarySemaphore::getSemaphore() {
+SemaphoreHandle_t Semaphore::getSemaphore() {
 	return handle;
 }
 
-ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
+ReturnValue_t Semaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
 	}
@@ -119,7 +119,7 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphore(SemaphoreHandle_t semaphore)
 	}
 }
 
-void BinarySemaphore::resetSemaphore() {
+void Semaphore::resetSemaphore() {
 	if(handle != nullptr) {
 		vSemaphoreDelete(handle);
 		handle = xSemaphoreCreateBinary();
@@ -127,20 +127,20 @@ void BinarySemaphore::resetSemaphore() {
 	}
 }
 
-ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
+ReturnValue_t Semaphore::acquire(uint32_t timeoutMs) {
 	return takeBinarySemaphore(timeoutMs);
 }
 
-ReturnValue_t BinarySemaphore::release() {
+ReturnValue_t Semaphore::release() {
 	return giveBinarySemaphore();
 }
 
-uint8_t BinarySemaphore::getSemaphoreCounter() {
+uint8_t Semaphore::getSemaphoreCounter() {
 	return uxSemaphoreGetCount(handle);
 }
 
 // Be careful with the stack size here. This is called from an ISR!
-ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
+ReturnValue_t Semaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 		BaseType_t * higherPriorityTaskWoken) {
 	if (semaphore == nullptr) {
 		return SEMAPHORE_NULLPOINTER;
@@ -157,3 +157,4 @@ ReturnValue_t BinarySemaphore::giveBinarySemaphoreFromISR(SemaphoreHandle_t sema
 		return SEMAPHORE_NOT_OWNED;
 	}
 }
+

osal/FreeRTOS/BinarySemaphore.h

@@ -14,14 +14,16 @@ extern "C" {
 // 		 and switch between the classes with #ifdefs.
 //		 Task Notifications require FreeRTOS V8.2 something..
 /**
- * @brief OS Tool to achieve synchronization of between tasks or between task and ISR
+ * @brief 	OS Tool to achieve synchronization of between tasks or between
+ * 			task and ISR. The default semaphore implementation creates a
+ * 			binary semaphore, which can only be taken once.
  * @details
  * Documentation: https://www.freertos.org/Embedded-RTOS-Binary-Semaphores.html
  *
  * @author 	R. Mueller
  * @ingroup osal
  */
-class BinarySemaphore: public SemaphoreIF,
+class Semaphore: public SemaphoreIF,
 		public HasReturnvaluesIF {
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
@@ -41,35 +43,21 @@ public:
 	static constexpr ReturnValue_t SEMAPHORE_NOT_OWNED = MAKE_RETURN_CODE(2);
 	static constexpr ReturnValue_t SEMAPHORE_NULLPOINTER = MAKE_RETURN_CODE(3);
 
-	BinarySemaphore();
+	//! @brief Default ctor
-
+	Semaphore();
-	/**
+	//! @brief Copy ctor
-	 * @brief Copy ctor
+	Semaphore(const Semaphore&);
-	 */
+	//! @brief Copy assignment
-	BinarySemaphore(const BinarySemaphore&);
+	Semaphore& operator=(const Semaphore&);
-
+	//! @brief Move ctor
-	/**
+	Semaphore (Semaphore &&);
-	 * @brief Copy assignment
+	//! @brief Move assignment
-	 */
+	Semaphore & operator=(Semaphore &&);
-	BinarySemaphore& operator=(const BinarySemaphore&);
+	//! @brief Destructor
-
+	virtual ~Semaphore();
-	/**
-	 * @brief Move constructor
-	 */
-	BinarySemaphore (BinarySemaphore &&);
-
-	/**
-	 * Move assignment
-	 */
-	BinarySemaphore & operator=(BinarySemaphore &&);
-
-	/**
-	 * Delete the binary semaphore to prevent a memory leak
-	 */
-	virtual ~BinarySemaphore();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT) override;
+	        Semaphore::NO_BLOCK_TIMEOUT) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() override;
 
@@ -83,7 +71,7 @@ public:
 	 *         -@c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphore(uint32_t timeoutMs =
-	        BinarySemaphore::NO_BLOCK_TIMEOUT);
+	        Semaphore::NO_BLOCK_TIMEOUT);
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -92,7 +80,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t takeBinarySemaphoreTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_BLOCK_TICKS);
+	        Semaphore::NO_BLOCK_TICKS);
 
 	/**
 	 * Give back the binary semaphore
@@ -130,7 +118,7 @@ public:
 	 */
 	static ReturnValue_t giveBinarySemaphoreFromISR(SemaphoreHandle_t semaphore,
 				BaseType_t * higherPriorityTaskWoken);
-private:
+protected:
 	SemaphoreHandle_t handle;
 };
 

osal/FreeRTOS/CountingSemaphore.cpp

@@ -0,0 +1,26 @@
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+CountingSemaphore::CountingSemaphore(uint8_t count, uint8_t initCount):
+		count(count), initCount(initCount) {
+	handle = xSemaphoreCreateCounting(count, initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore::CountingSemaphore(CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+}
+
+CountingSemaphore& CountingSemaphore::operator =(
+		CountingSemaphore&& other) {
+	handle = xSemaphoreCreateCounting(other.count, other.initCount);
+	if(handle == nullptr) {
+		sif::error << "CountingSemaphore: Creation failure" << std::endl;
+	}
+	return * this;
+}

osal/FreeRTOS/CountingSemaphore.h

@@ -0,0 +1,21 @@
+#ifndef FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#define FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+
+class CountingSemaphore: public Semaphore {
+public:
+	CountingSemaphore(uint8_t count, uint8_t initCount);
+	//! @brief Copy ctor, disabled
+	CountingSemaphore(const CountingSemaphore&) = delete;
+	//! @brief Copy assignment, disabled
+	CountingSemaphore& operator=(const CountingSemaphore&) = delete;
+	//! @brief Move ctor
+	CountingSemaphore (CountingSemaphore &&);
+	//! @brief Move assignment
+	CountingSemaphore & operator=(CountingSemaphore &&);
+private:
+	uint8_t count = 0;
+	uint8_t initCount = 0;
+};
+
+#endif /* FRAMEWORK_OSAL_FREERTOS_COUNTINGSEMAPHORE_H_ */

osal/FreeRTOS/Mutex.h

@@ -3,10 +3,10 @@
 
 #include <framework/ipc/MutexIF.h>
 
-
+extern "C" {
-#include <FreeRTOS.h>
+#include <freertos/FreeRTOS.h>
-#include "semphr.h"
+#include <freertos/semphr.h>
-
+}
 
 
 class Mutex : public MutexIF {

osal/FreeRTOS/MutexFactory.cpp

@@ -1,10 +1,11 @@
 #include <framework/ipc/MutexFactory.h>
 
-#include "../FreeRTOS/Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
-//TODO: Different variant than the lazy loading in QueueFactory. What's better and why? -> one is on heap the other on bss/data
+//TODO: Different variant than the lazy loading in QueueFactory.
+//What's better and why? -> one is on heap the other on bss/data
 //MutexFactory* MutexFactory::factoryInstance = new MutexFactory();
-MutexFactory* MutexFactory::factoryInstance = NULL;
+MutexFactory* MutexFactory::factoryInstance = nullptr;
 
 MutexFactory::MutexFactory() {
 }
@@ -13,7 +14,7 @@ MutexFactory::~MutexFactory() {
 }
 
 MutexFactory* MutexFactory::instance() {
-	if (factoryInstance == NULL){
+	if (factoryInstance == nullptr){
 		factoryInstance = new MutexFactory();
 	}
 	return MutexFactory::factoryInstance;

osal/FreeRTOS/SemaphoreFactory.cpp

@@ -0,0 +1,33 @@
+#include <framework/osal/FreeRTOS/BinarySemaphore.h>
+#include <framework/osal/FreeRTOS/CountingSemaphore.h>
+#include <framework/tasks/SemaphoreFactory.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
+SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
+
+SemaphoreFactory::SemaphoreFactory() {
+}
+
+SemaphoreFactory::~SemaphoreFactory() {
+	delete factoryInstance;
+}
+
+SemaphoreFactory* SemaphoreFactory::instance() {
+	if (factoryInstance == nullptr){
+		factoryInstance = new SemaphoreFactory();
+	}
+	return SemaphoreFactory::factoryInstance;
+}
+
+SemaphoreIF* SemaphoreFactory::createBinarySemaphore() {
+	return new Semaphore();
+}
+
+SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t count,
+		uint8_t initCount) {
+	return new CountingSemaphore(count, initCount);
+}
+
+void SemaphoreFactory::deleteMutex(SemaphoreIF* semaphore) {
+	delete semaphore;
+}

tasks/SemaphoreFactory.h

@@ -0,0 +1,45 @@
+#ifndef FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#define FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_
+#include <framework/tasks/SemaphoreIF.h>
+
+/**
+ * Creates Semaphore.
+ * This class is a "singleton" interface, i.e. it provides an
+ * interface, but also is the base class for a singleton.
+ */
+class SemaphoreFactory {
+public:
+	virtual ~SemaphoreFactory();
+	/**
+	 * Returns the single instance of SemaphoreFactory.
+	 * The implementation of #instance is found in its subclasses.
+	 * Thus, we choose link-time variability of the  instance.
+	 */
+	static SemaphoreFactory* instance();
+
+	/**
+	 * Create a binary semaphore.
+	 * Creator function for a binary semaphore which may only be acquired once
+	 * @return Pointer to newly created semaphore class instance.
+	 */
+	SemaphoreIF* createBinarySemaphore();
+	/**
+	 * Create a counting semaphore.
+	 * Creator functons for a counting semaphore which may be acquired multiple
+	 * times.
+	 * @param count Semaphore can be taken count times.
+	 * @param initCount Initial count value.
+	 * @return
+	 */
+	SemaphoreIF* createCountingSemaphore(uint8_t count, uint8_t initCount);
+	void deleteMutex(SemaphoreIF* mutex);
+
+private:
+	/**
+	 * External instantiation is not allowed.
+	 */
+	SemaphoreFactory();
+	static SemaphoreFactory* factoryInstance;
+};
+
+#endif /* FRAMEWORK_TASKS_SEMAPHOREFACTORY_H_ */