Merge remote-tracking branch 'upstream/master' into mueller/FreeRTOS/TaskManagement

osal/FreeRTOS/Clock.cpp

@@ -1,6 +1,6 @@
-#include <framework/timemanager/Clock.h>
-#include <framework/globalfunctions/timevalOperations.h>
-#include <framework/osal/FreeRTOS/Timekeeper.h>
+#include "../../timemanager/Clock.h"
+#include "../../globalfunctions/timevalOperations.h"
+#include "Timekeeper.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
@@ -155,7 +155,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,7 +170,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}

osal/FreeRTOS/FixedTimeslotTask.cpp

@@ -1,6 +1,6 @@
 #include "FixedTimeslotTask.h"
 
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;

osal/FreeRTOS/FixedTimeslotTask.h

@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
-#include <framework/devicehandlers/FixedSlotSequence.h>
-#include <framework/tasks/FixedTimeslotTaskIF.h>
-#include <framework/tasks/Typedef.h>
+#include "../../devicehandlers/FixedSlotSequence.h"
+#include "../../tasks/FixedTimeslotTaskIF.h"
+#include "../../tasks/Typedef.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>

osal/FreeRTOS/MessageQueue.cpp

@@ -1,6 +1,6 @@
 #include "MessageQueue.h"
 
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 // TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls
 

osal/FreeRTOS/MessageQueue.h

@@ -1,9 +1,9 @@
 #ifndef MESSAGEQUEUE_H_
 #define MESSAGEQUEUE_H_
 
-#include <framework/internalError/InternalErrorReporterIF.h>
-#include <framework/ipc/MessageQueueIF.h>
-#include <framework/ipc/MessageQueueMessage.h>
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueIF.h"
+#include "../../ipc/MessageQueueMessage.h"
 
 #include <FreeRTOS.h>
 #include <queue.h>

osal/FreeRTOS/Mutex.cpp

@@ -1,28 +1,32 @@
-#include "Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-const uint32_t MutexIF::NO_TIMEOUT = 0;
+#include "../../serviceinterface/ServiceInterfaceStream.h"
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	//TODO print error
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
 }
 
 Mutex::~Mutex() {
-	if (handle != 0) {
+	if (handle != nullptr) {
 		vSemaphoreDelete(handle);
 	}
 
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if (timeoutMs != NO_TIMEOUT) {
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -30,21 +34,18 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO could not be acquired/timeout
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_TIMEOUT;
 	}
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO is not owner
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
 	}
 }

osal/FreeRTOS/Mutex.h

@@ -1,22 +1,29 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
-
-#include <framework/ipc/MutexIF.h>
-
-
-#include <FreeRTOS.h>
-#include "semphr.h"
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
 
+#include "../../ipc/MutexIF.h"
 
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
 class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
 private:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */

osal/FreeRTOS/MutexFactory.cpp

@@ -1,4 +1,4 @@
-#include <framework/ipc/MutexFactory.h>
+#include "../../ipc/MutexFactory.h"
 
 #include "../FreeRTOS/Mutex.h"
 

osal/FreeRTOS/PeriodicTask.cpp

@@ -1,7 +1,7 @@
 #include "PeriodicTask.h"
 
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tasks/ExecutableObjectIF.h>
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tasks/ExecutableObjectIF.h"
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
 		TaskStackSize setStack, TaskPeriod setPeriod,

osal/FreeRTOS/PeriodicTask.h

@@ -1,9 +1,9 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 #define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_
 
-#include <framework/objectmanager/ObjectManagerIF.h>
-#include <framework/tasks/PeriodicTaskIF.h>
-#include <framework/tasks/Typedef.h>
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../tasks/PeriodicTaskIF.h"
+#include "../../tasks/Typedef.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>

osal/FreeRTOS/QueueFactory.cpp

@@ -1,6 +1,6 @@
-#include <framework/ipc/QueueFactory.h>
+#include "../../ipc/QueueFactory.h"
 
-#include <framework/osal/FreeRTOS/MessageQueue.h>
+#include "MessageQueue.h"
 
 
 QueueFactory* QueueFactory::factoryInstance = NULL;

osal/FreeRTOS/TaskFactory.cpp

@@ -1,5 +1,5 @@
-#include <framework/tasks/TaskFactory.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include "../../tasks/TaskFactory.h"
+#include "../../returnvalues/HasReturnvaluesIF.h"
 
 #include "PeriodicTask.h"
 #include "FixedTimeslotTask.h"

osal/FreeRTOS/Timekeeper.cpp

@@ -1,4 +1,4 @@
-#include <framework/osal/FreeRTOS/Timekeeper.h>
+#include "Timekeeper.h"
 
 #include "FreeRTOSConfig.h"
 

osal/FreeRTOS/Timekeeper.h

@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_
 
-#include <framework/timemanager/Clock.h>
+#include "../../timemanager/Clock.h"
 
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>