eive/fsfw
eive/fsfw
15
1
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases 1 Wiki Activity

renamed timeout values

Browse Source
This commit is contained in:
Robin Müller 2020-06-02 22:36:42 +02:00
parent 73183b39ef
commit d4f69633f0
11 changed files with 41 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
osal/FreeRTOS/BinSemaphUsingTask.cpp
View File

@ -17,11 +17,11 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
} }
ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) { 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); timeout = pdMS_TO_TICKS(timeoutMs);
} }
return acquireWithTickTimeout(timeout); return acquireWithTickTimeout(timeout);

4
osal/FreeRTOS/BinSemaphUsingTask.h
View File

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

8
osal/FreeRTOS/BinarySemaphore.cpp
View File

@ -36,11 +36,11 @@ BinarySemaphore& BinarySemaphore::operator =(
} }
ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) { 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); timeout = pdMS_TO_TICKS(timeoutMs);
} }
return acquireWithTickTimeout(timeout); return acquireWithTickTimeout(timeout);

4
osal/FreeRTOS/BinarySemaphore.h
View File

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

8
osal/FreeRTOS/CountingSemaphUsingTask.cpp
View File

@ -38,11 +38,11 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
} }
ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) { 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); timeout = pdMS_TO_TICKS(timeoutMs);
} }
return acquireWithTickTimeout(timeout); return acquireWithTickTimeout(timeout);

4
osal/FreeRTOS/CountingSemaphUsingTask.h
View File

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

4
osal/FreeRTOS/SemaphoreFactory.cpp
View File

@ -6,8 +6,8 @@
#include <framework/serviceinterface/ServiceInterfaceStream.h> #include <framework/serviceinterface/ServiceInterfaceStream.h>
SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr; 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_REGULAR_SEMAPHORES = 0;
static const uint32_t USE_TASK_NOTIFICATIONS = 1; static const uint32_t USE_TASK_NOTIFICATIONS = 1;

6
osal/linux/BinarySemaphore.cpp
View File

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

2
osal/linux/BinarySemaphore.h
View File

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

4
osal/linux/SemaphoreFactory.cpp
View File

@ -3,8 +3,8 @@
#include <framework/osal/linux/CountingSemaphore.h> #include <framework/osal/linux/CountingSemaphore.h>
#include <framework/serviceinterface/ServiceInterfaceStream.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; SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;

19
tasks/SemaphoreIF.h
View File

@ -21,10 +21,21 @@
class SemaphoreIF { class SemaphoreIF {
public: public:
virtual~ SemaphoreIF() {}; 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; static const uint8_t INTERFACE_ID = CLASS_ID::SEMAPHORE_IF;
//! Semaphore timeout //! Semaphore timeout
static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1); static constexpr ReturnValue_t SEMAPHORE_TIMEOUT = MAKE_RETURN_CODE(1);