renamed timeout values

osal/FreeRTOS/BinSemaphUsingTask.cpp

@@ -17,11 +17,11 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);

osal/FreeRTOS/BinSemaphUsingTask.h

@@ -26,7 +26,7 @@ public:
 	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
+	        SemaphoreIF::BLOCKING) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
@@ -40,7 +40,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::NO_TIMEOUT);
+	        SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.

osal/FreeRTOS/BinarySemaphore.cpp

@@ -36,11 +36,11 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	    timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);

osal/FreeRTOS/BinarySemaphore.h

@@ -53,7 +53,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+			SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -62,7 +62,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
+			SemaphoreIF::BLOCKING);
 
 	/**
 	 * Release the binary semaphore.

osal/FreeRTOS/CountingSemaphUsingTask.cpp

@@ -38,11 +38,11 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);

osal/FreeRTOS/CountingSemaphUsingTask.h

@@ -31,7 +31,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +61,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.

osal/FreeRTOS/SemaphoreFactory.cpp

@@ -6,8 +6,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;

osal/linux/BinarySemaphore.cpp

@@ -27,13 +27,13 @@ BinarySemaphore& BinarySemaphore::operator =(
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
 	int result = 0;
-	if(timeoutMs == SemaphoreIF::NO_TIMEOUT) {
+	if(timeoutMs == SemaphoreIF::POLLING) {
 		result = sem_trywait(&handle);
 	}
-	else if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
+	else if(timeoutMs == SemaphoreIF::BLOCKING) {
 	    result = sem_wait(&handle);
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;

osal/linux/BinarySemaphore.h

@@ -50,7 +50,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+	       	   SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release the binary semaphore.

osal/linux/SemaphoreFactory.cpp

@@ -3,8 +3,8 @@
 #include <framework/osal/linux/CountingSemaphore.h>
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
+const uint32_t SemaphoreIF::POLLING = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = 0xFFFFFFFF;
+const uint32_t SemaphoreIF::BLOCKING = 0xffffffff;
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

tasks/SemaphoreIF.h

@@ -21,10 +21,21 @@
 class SemaphoreIF {
 public:
 	virtual~ SemaphoreIF() {};
-	//! Needs to be defined in implementation. No blocking time
+	/**
-	static const uint32_t NO_TIMEOUT;
+	 * @brief 	Timeout value used for polling lock attempt.
-	//! Needs to be defined in implementation. Blocks indefinitely.
+	 * @details
-	static const uint32_t MAX_TIMEOUT;
+	 * If the lock is not successfull, MUTEX_TIMEOUT will be returned
+	 * immediately. Value needs to be defined in implementation.
+	 */
+	static const uint32_t POLLING;
+	/**
+	 * @brief 	Timeout value used for permanent blocking lock attempt.
+	 * @details
+	 * The task will be blocked (indefinitely) until the mutex is unlocked.
+	 * Value needs to be defined in implementation.
+	 */
+	static const uint32_t BLOCKING;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
 	//! Semaphore timeout
 	static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);