CMakeLists.txt

@@ -174,6 +174,27 @@ if(FSFW_BUILD_TESTS)
   configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
   configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
+  if(FSFW_OSAL MATCHES "freertos")
+    message(STATUS "${MSG_PREFIX} Downloading FreeRTOS with FetchContent")
+    include(FetchContent)
+
+    set(FreeRTOS_PORT posix)
+
+    FetchContent_Declare(
+      FreeRTOS
+      GIT_REPOSITORY https://egit.irs.uni-stuttgart.de/fsfw/FreeRTOS-LTS
+      GIT_TAG develop
+      GIT_SUBMODULES FreeRTOS/FreeRTOS-Kernel)
+
+    FetchContent_MakeAvailable(FreeRTOS)
+
+    set(LIB_OS_NAME FreeRTOS)
+    target_include_directories(FreeRTOS PUBLIC unittests/testcfg/freertos)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads REQUIRED)
+    target_link_libraries(FreeRTOS PRIVATE ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
   if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
@@ -226,6 +247,7 @@ if(FSFW_FETCH_CONTENT_TARGETS)
     # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
     set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
   endif()
+
 endif()
 
 set(FSFW_CORE_INC_PATH "inc")
@@ -360,6 +382,9 @@ if(FSFW_BUILD_TESTS)
   endif()
   target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2
                                                  ${LIB_FSFW_NAME})
+  if(FSFW_OSAL MATCHES "freertos")
+    target_link_libraries(${FSFW_TEST_TGT} PRIVATE FreeRTOS)
+  endif()
 endif()
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it. If

automation/Jenkinsfile

@@ -1,48 +1,53 @@
 pipeline {
     environment {
-        BUILDDIR = 'cmake-build-tests'
+        BUILDDIR_HOST = 'cmake-build-tests-host'
+        BUILDDIR_LINUX = 'cmake-build-tests-linux'
+        BUILDDIR_FREERTOS = 'cmake-build-tests-freertos'
         DOCDDIR = 'cmake-build-documentation'
     }
     agent {
         docker { 
             image 'fsfw-ci:d6'
-            args '--network host'
+            args '--network host --sysctl fs.mqueue.msg_max=100'
         }
     }
     stages {
-        stage('Clean') {
+        stage('Host') {
             steps {
-                sh 'rm -rf $BUILDDIR'
-            }
-        }
-        stage('Configure') {
-            steps {
-                dir(BUILDDIR) {
+                sh 'rm -rf $BUILDDIR_HOST'
+
+                dir(BUILDDIR_HOST) {
                     sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
-                }
-            }
-        }
-        stage('Build') {
-            steps {
-                dir(BUILDDIR) {
                     sh 'cmake --build . -j4'
-                }
-            }
-        }
-        stage('Unittests') {
-            steps {
-                dir(BUILDDIR) {
                     sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                    sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
                 }
             }
         }
-        stage('Valgrind') {
+        stage('Linux') {
             steps {
-                dir(BUILDDIR) {
+                sh 'rm -rf $BUILDDIR_LINUX'
+
+                dir(BUILDDIR_LINUX) {
+                    sh 'cmake -DFSFW_OSAL=linux -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake --build . -j4'
+                    sh 'cmake --build . -- fsfw-tests_coverage -j4'
                     sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
                 }
             }
         }
+        stage('FreeRTOS') {
+            steps {
+                sh 'rm -rf $BUILDDIR_FREERTOS'
+
+                dir(BUILDDIR_FREERTOS) {
+                    sh 'cmake -DFSFW_OSAL=freertos -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake --build . -j4'
+                    sh 'cmake --build . -- fsfw-tests_coverage -j4'
+                    //sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
+                }
+            }
+        }
         stage('Documentation') {
             when {
                 branch 'development'

src/fsfw/events/EventManager.cpp

@@ -23,6 +23,7 @@ EventManager::EventManager(object_id_t setObjectId)
 }
 
 EventManager::~EventManager() {
+  listenerList.clear();
   QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
   MutexFactory::instance()->deleteMutex(mutex);
 }
@@ -61,9 +62,14 @@ ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
   if (!result.second) {
     return returnvalue::FAILED;
   }
+
   return returnvalue::OK;
 }
 
+ReturnValue_t EventManager::unregisterListener(MessageQueueId_t listener) {
+  return listenerList.erase(listener) == 1 ? returnvalue::OK : returnvalue::FAILED;
+}
+
 ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener, EventId_t event) {
   return subscribeToEventRange(listener, event);
 }

src/fsfw/events/EventManager.h

@@ -31,6 +31,7 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
   MessageQueueId_t getEventReportQueue();
 
   ReturnValue_t registerListener(MessageQueueId_t listener, bool forwardAllButSelected = false);
+  ReturnValue_t unregisterListener(MessageQueueId_t listener) override;
   ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event);
   ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object);
   ReturnValue_t subscribeToEventRange(MessageQueueId_t listener, EventId_t idFrom = 0,

src/fsfw/events/EventManagerIF.h

@@ -18,6 +18,7 @@ class EventManagerIF {
 
   virtual ReturnValue_t registerListener(MessageQueueId_t listener,
                                          bool forwardAllButSelected = false) = 0;
+  virtual ReturnValue_t unregisterListener(MessageQueueId_t listener) = 0;
   virtual ReturnValue_t subscribeToEvent(MessageQueueId_t listener, EventId_t event) = 0;
   virtual ReturnValue_t subscribeToAllEventsFrom(MessageQueueId_t listener, object_id_t object) = 0;
   virtual ReturnValue_t unsubscribeFromAllEvents(MessageQueueId_t listener, object_id_t object) = 0;

src/fsfw/fdir/FailureIsolationBase.cpp

@@ -23,7 +23,7 @@ FailureIsolationBase::~FailureIsolationBase() {
 #endif
     return;
   }
-  manager->unsubscribeFromAllEvents(eventQueue->getId(), ownerId);
+  manager->unregisterListener(eventQueue->getId());
   QueueFactory::instance()->deleteMessageQueue(eventQueue);
 }
 

src/fsfw/globalfunctions/matching/MatchTree.h

@@ -24,7 +24,7 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
   MatchTree(iterator root, uint8_t maxDepth = -1)
       : BinaryTree<SerializeableMatcherIF<T>>(root.element), maxDepth(maxDepth) {}
   MatchTree() : BinaryTree<SerializeableMatcherIF<T>>(), maxDepth(-1) {}
-  virtual ~MatchTree() {}
+  virtual ~MatchTree() { clear(); }
   virtual bool match(T number) override { return matchesTree(number); }
   bool matchesTree(T number) {
     iterator iter = this->begin();
@@ -176,6 +176,45 @@ class MatchTree : public SerializeableMatcherIF<T>, public BinaryTree<Serializea
     return cleanUpElement(position);
   }
 
+  void clear() {
+    Node* localRoot = BinaryTree<SerializeableMatcherIF<T>>::rootNode;
+
+    if (localRoot == nullptr) {
+      return;
+    }
+
+    Node* node = localRoot->left;
+
+    while (true) {
+      if (node->left != nullptr) {
+        node = node->left;
+        continue;
+      }
+      if (node->right != nullptr) {
+        node = node->right;
+        continue;
+      }
+      if (node->parent == nullptr) {
+        // this is the root node with no children
+        if (node->value != nullptr) {
+          cleanUpElement(iterator(node));
+        }
+        return;
+      }
+      // leaf
+      {
+        Node* parent = node->parent;
+        if (parent->left == node) {
+          parent->left = nullptr;
+        } else {
+          parent->right = nullptr;
+        }
+        cleanUpElement(iterator(node));
+        node = parent;
+      }
+    }
+  }
+
   virtual ReturnValue_t cleanUpElement(iterator position) { return returnvalue::OK; }
 
   bool matchSubtree(iterator iter, T number) {

src/fsfw/health/HealthTable.cpp

@@ -6,8 +6,6 @@
 
 HealthTable::HealthTable(object_id_t objectid) : SystemObject(objectid) {
   mutex = MutexFactory::instance()->createMutex();
-  ;
-
   mapIterator = healthMap.begin();
 }
 

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -14,7 +14,10 @@ InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t m
   mutex = MutexFactory::instance()->createMutex();
 }
 
-InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
+InternalErrorReporter::~InternalErrorReporter() {
+  MutexFactory::instance()->deleteMutex(mutex);
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
 
 void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
   this->diagnosticPrintout = enable;

src/fsfw/objectmanager/ObjectManager.cpp

@@ -23,9 +23,17 @@ void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc,
 
 ObjectManager::ObjectManager() = default;
 
+void ObjectManager::clear() {
+  if (objManagerInstance != nullptr) {
+    delete objManagerInstance;
+    objManagerInstance = nullptr;
+  }
+}
+
 ObjectManager::~ObjectManager() {
-  for (auto const& iter : objectList) {
-    delete iter.second;
+  teardown = true;
+  for (auto iter = objectList.begin(); iter != objectList.end(); iter = objectList.erase(iter)) {
+    delete iter->second;
   }
 }
 
@@ -53,6 +61,12 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
 }
 
 ReturnValue_t ObjectManager::remove(object_id_t id) {
+  // this function is called during destruction of System Objects
+  // disabeld for teardown to avoid iterator invalidation and
+  // double free
+  if (teardown) {
+    return returnvalue::OK;
+  }
   if (this->getSystemObject(id) != nullptr) {
     this->objectList.erase(id);
 #if FSFW_CPP_OSTREAM_ENABLED == 1

src/fsfw/objectmanager/ObjectManager.h

@@ -24,12 +24,17 @@ class ObjectManager : public ObjectManagerIF {
   using produce_function_t = void (*)(void* args);
 
   /**
-   * Returns the single instance of TaskFactory.
+   * Returns the single instance of ObjectManager.
    * The implementation of #instance is found in its subclasses.
    * Thus, we choose link-time variability of the  instance.
    */
   static ObjectManager* instance();
 
+  /**
+   * Deletes the single instance of ObjectManager
+   */
+  static void clear();
+
   void setObjectFactoryFunction(produce_function_t prodFunc, void* args);
 
   template <typename T>
@@ -66,6 +71,9 @@ class ObjectManager : public ObjectManagerIF {
    */
   std::map<object_id_t, SystemObjectIF*> objectList;
   static ObjectManager* objManagerInstance;
+  // used when the OM itself is deleted to modify behaviour of remove()
+  // to avoid iterator invalidation and double free
+  bool teardown = false;
 };
 
 // Documentation can be found in the class method declaration above

src/fsfw/osal/CMakeLists.txt

@@ -1,10 +1,13 @@
 # Check the OS_FSFW variable
 if(FSFW_OSAL MATCHES "freertos")
   add_subdirectory(freertos)
+  set(FSFW_OSAL_FREERTOS 1)
 elseif(FSFW_OSAL MATCHES "rtems")
   add_subdirectory(rtems)
+  set(FSFW_OSAL_RTEMS 1)
 elseif(FSFW_OSAL MATCHES "linux")
   add_subdirectory(linux)
+  set(FSFW_OSAL_LINUX 1)
 elseif(FSFW_OSAL MATCHES "host")
   add_subdirectory(host)
   if(WIN32)
@@ -13,16 +16,17 @@ elseif(FSFW_OSAL MATCHES "host")
     # We still need to pull in some Linux specific sources
     target_sources(${LIB_FSFW_NAME} PUBLIC linux/tcpipHelpers.cpp)
   endif()
-
+  set(FSFW_OSAL_HOST 1)
 else()
-
   message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
   # Not set. Assumuing this is a host build, try to determine host OS
   if(WIN32)
     add_subdirectory(host)
     add_subdirectory(windows)
+    set(FSFW_OSAL_HOST 1)
   elseif(UNIX)
     add_subdirectory(linux)
+    set(FSFW_OSAL_LINUX 1)
   else()
     # MacOS or other OSes have not been tested yet / are not supported.
     message(FATAL_ERROR "The host OS could not be determined! Aborting.")
@@ -31,3 +35,5 @@ else()
 endif()
 
 add_subdirectory(common)
+
+configure_file(osal.h.in ${CMAKE_BINARY_DIR}/fsfw/osal/osal.h)

src/fsfw/osal/freertos/BinSemaphUsingTask.h

@@ -40,7 +40,7 @@ class BinarySemaphoreUsingTask : public SemaphoreIF {
   void refreshTaskHandle();
 
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = portMAX_DELAY) override;
+                        uint32_t timeoutMs = 0) override;
   ReturnValue_t release() override;
   uint8_t getSemaphoreCounter() const override;
   static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);

src/fsfw/osal/freertos/BinarySemaphore.h

@@ -51,7 +51,7 @@ class BinarySemaphore : public SemaphoreIF {
    *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
    */
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = portMAX_DELAY) override;
+                        uint32_t timeoutMs = 0) override;
 
   /**
    * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.

src/fsfw/osal/freertos/Clock.cpp

@@ -110,11 +110,13 @@ ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval*
   time_tm.tm_min = from->minute;
   time_tm.tm_sec = from->second;
 
-  time_t seconds = mktime(&time_tm);
+  time_tm.tm_isdst = 0;
+
+  time_t seconds = timegm(&time_tm);
 
   to->tv_sec = seconds;
   to->tv_usec = from->usecond;
-  // Fails in 2038..
+
   return returnvalue::OK;
 }
 

src/fsfw/osal/freertos/CountingSemaphUsingTask.h

@@ -34,7 +34,7 @@ class CountingSemaphoreUsingTask : public SemaphoreIF {
    *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
    */
   ReturnValue_t acquire(TimeoutType timeoutType = TimeoutType::BLOCKING,
-                        uint32_t timeoutMs = portMAX_DELAY) override;
+                        uint32_t timeoutMs = 0) override;
 
   /**
    * Release a semaphore, increasing the number of available counting

src/fsfw/osal/freertos/FixedTimeslotTask.cpp

@@ -56,7 +56,9 @@ ReturnValue_t FixedTimeslotTask::startTask() {
   // start time for the first entry.
   auto slotListIter = pollingSeqTable.current;
 
-  pollingSeqTable.intializeSequenceAfterTaskCreation();
+  ReturnValue_t result = pollingSeqTable.intializeSequenceAfterTaskCreation();
+  // Ignore returnvalue for now
+  static_cast<void>(result);
 
   // The start time for the first entry is read.
   uint32_t intervalMs = slotListIter->pollingTimeMs;

src/fsfw/osal/freertos/Mutex.cpp

@@ -22,7 +22,7 @@ ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
     return MutexIF::MUTEX_NOT_FOUND;
   }
   // If the timeout type is BLOCKING, this will be the correct value.
-  uint32_t timeout = portMAX_DELAY;
+  TickType_t timeout = portMAX_DELAY;
   if (timeoutType == TimeoutType::POLLING) {
     timeout = 0;
   } else if (timeoutType == TimeoutType::WAITING) {

src/fsfw/osal/freertos/TaskManagement.cpp

@@ -3,16 +3,16 @@
 void TaskManagement::vRequestContextSwitchFromTask() { vTaskDelay(0); }
 
 void TaskManagement::requestContextSwitch(CallContext callContext = CallContext::TASK) {
-  if (callContext == CallContext::ISR) {
-    // This function depends on the partmacro.h definition for the specific device
-    vRequestContextSwitchFromISR();
-  } else {
-    vRequestContextSwitchFromTask();
-  }
+  //   if (callContext == CallContext::ISR) {
+  //     // This function depends on the partmacro.h definition for the specific device
+  //     vRequestContextSwitchFromISR();
+  //   } else {
+  vRequestContextSwitchFromTask();
+  //   }
 }
 
 TaskHandle_t TaskManagement::getCurrentTaskHandle() { return xTaskGetCurrentTaskHandle(); }
 
-size_t TaskManagement::getTaskStackHighWatermark(TaskHandle_t task) {
-  return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
-}
+// size_t TaskManagement::getTaskStackHighWatermark(TaskHandle_t task) {
+//   return uxTaskGetStackHighWaterMark(task) * sizeof(StackType_t);
+// }

src/fsfw/osal/freertos/TaskManagement.h

@@ -11,7 +11,7 @@
  * Architecture dependant portmacro.h function call.
  * Should be implemented in bsp.
  */
-extern "C" void vRequestContextSwitchFromISR();
+// extern "C" void vRequestContextSwitchFromISR();
 
 /*!
  * Used by functions to tell if they are being called from
@@ -53,7 +53,7 @@ TaskHandle_t getCurrentTaskHandle();
  * @return Smallest value of stack remaining since the task was started in
  * 		   words.
  */
-size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
+// size_t getTaskStackHighWatermark(TaskHandle_t task = nullptr);
 
 };  // namespace TaskManagement
 

src/fsfw/osal/linux/MessageQueue.cpp

@@ -21,7 +21,7 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize, MqArgs*
   attributes.mq_msgsize = maxMessageSize;
   attributes.mq_flags = 0;  // Flags are ignored on Linux during mq_open
   // Set the name of the queue. The slash is mandatory!
-  sprintf(name, "/FSFW_MQ%u\n", queueCounter++);
+  sprintf(name, "/FSFW_MQ%u", queueCounter++);
 
   // Create a nonblocking queue if the name is available (the queue is read
   // and writable for the owner as well as the group)

src/fsfw/osal/osal.h.in

@@ -0,0 +1,36 @@
+#pragma once
+
+namespace osal {
+    enum osalTarget{
+        HOST,
+        LINUX,
+        WINDOWS,
+        FREERTOS,
+        RTEMS,
+    };
+
+#cmakedefine FSFW_OSAL_HOST
+#cmakedefine FSFW_OSAL_LINUX
+#cmakedefine FSFW_OSAL_WINDOWS
+#cmakedefine FSFW_OSAL_FREERTOS
+#cmakedefine FSFW_OSAL_RTEMS
+
+
+    constexpr osalTarget getTarget() {
+#ifdef FSFW_OSAL_HOST
+  return HOST;
+#endif
+#ifdef FSFW_OSAL_LINUX
+  return LINUX;
+#endif
+#ifdef FSFW_OSAL_WINDOWS
+  return WINDOWS;
+#endif
+#ifdef FSFW_OSAL_FREERTOS
+  return FREERTOS;
+#endif
+#ifdef FSFW_OSAL_RTEMS
+  return RTEMS;
+#endif
+    }
+};

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -2,12 +2,12 @@
 
 #include <cstddef>
 
+#include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"
-#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 #include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
-#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 
 static constexpr auto DEF_END = SerializeIF::Endianness::BIG;
 
@@ -180,7 +180,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
   if (CRC::crc16ccitt(data, size) != 0) {
     return CONTAINED_TC_CRC_MISSMATCH;
   }
-  
+
   // store currentPacket and receive the store address
   store_address_t addr{};
   if (tcStore->addData(&addr, data, size) != returnvalue::OK ||

src/fsfw/timemanager/CCSDSTime.cpp

@@ -552,10 +552,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const CCSDSTime::CDS_short*
   if (to == nullptr or from == nullptr) {
     return returnvalue::FAILED;
   }
-  uint16_t days = (from->dayMSB << 8) + from->dayLSB;
-  if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-    return INVALID_TIME_FORMAT;
-  }
+  int32_t days = (from->dayMSB << 8) + from->dayLSB;
   days -= DAYS_CCSDS_TO_UNIX_EPOCH;
   to->tv_sec = days * SECONDS_PER_DAY;
   uint32_t msDay =

unittests/CatchRunner.cpp

@@ -10,16 +10,60 @@
 
 #define CATCH_CONFIG_COLOUR_WINDOWS
 
+#include <fsfw/osal/osal.h>
+
 #include <catch2/catch_session.hpp>
 
+#ifdef FSFW_OSAL_FREERTOS
+#include <FreeRTOS.h>
+
+#include "task.h"
+#endif
+
 extern int customSetup();
 extern int customTeardown();
 
+#ifdef FSFW_OSAL_FREERTOS
+struct Taskparameters {
+  int argc;
+  char** argv;
+  TaskHandle_t catchTask;
+} taskParameters;
+
+void unittestTaskFunction(void* pvParameters) {
+  Taskparameters* parameters = (Taskparameters*)pvParameters;
+
+  int result = Catch::Session().run(parameters->argc, parameters->argv);
+
+  vTaskDelay(pdMS_TO_TICKS(10));
+  vTaskSuspendAll();
+  vTaskDelete(parameters->catchTask);
+  customTeardown();
+  exit(result);
+}
+#endif
+
 int main(int argc, char* argv[]) {
   customSetup();
 
+  int result = 0;
+
+#ifdef FSFW_OSAL_FREERTOS
+  xTaskCreate(
+      unittestTaskFunction, /* The function that implements the task. */
+      "Unittests", /* The text name assigned to the task - for debug only as it is not used by the
+                      kernel. */
+      configMINIMAL_STACK_SIZE, /* The size of the stack to allocate to the task. */
+      &taskParameters, /* The parameter passed to the task - not used in this simple case. */
+      1,               /* The priority assigned to the task. */
+      &taskParameters.catchTask); /* The task handle is not required, so NULL is passed. */
+  taskParameters.argc = argc;
+  taskParameters.argv = argv;
+  vTaskStartScheduler();
+#else
   // Catch internal function call
-  int result = Catch::Session().run(argc, argv);
+  result = Catch::Session().run(argc, argv);
+#endif
 
   // global clean-up
   customTeardown();

unittests/CatchSetup.cpp

@@ -31,4 +31,7 @@ int customSetup() {
   return 0;
 }
 
-int customTeardown() { return 0; }
+int customTeardown() {
+  ObjectManager::clear();
+  return 0;
+}

unittests/devicehandler/DeviceHandlerCommander.cpp

@@ -9,7 +9,9 @@ DeviceHandlerCommander::DeviceHandlerCommander(object_id_t objectId)
       QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-DeviceHandlerCommander::~DeviceHandlerCommander() {}
+DeviceHandlerCommander::~DeviceHandlerCommander() {
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
 
 ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
   readCommandQueue();

unittests/osal/TestClock.cpp

@@ -1,5 +1,6 @@
 #include <fsfw/globalfunctions/timevalOperations.h>
 #include <fsfw/timemanager/Clock.h>
+#include <stdio.h>
 
 #include <array>
 #include <catch2/catch_approx.hpp>

unittests/osal/TestSemaphore.cpp

@@ -1,46 +1,38 @@
-
-#ifdef LINUX
-
-/*
+#include <fsfw/osal/osal.h>
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 
-#include "catch.hpp"
-#include "core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
-        //perform set-up here
-        SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
-                        createBinarySemaphore();
-        REQUIRE(binSemaph != nullptr);
-        SECTION("Simple Test") {
-                // set-up is run for each section
-                REQUIRE(binSemaph->getSemaphoreCounter() == 1);
-                REQUIRE(binSemaph->release() ==
-                                static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
-                REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
-                                result::OK);
-                {
-                        // not precise enough on linux.. should use clock instead..
-                        //Stopwatch stopwatch(false);
-                        //REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
-                        //		SemaphoreIF::SEMAPHORE_TIMEOUT);
-                        //dur_millis_t time = stopwatch.stop();
-                        //CHECK(time == 5);
-                }
-                REQUIRE(binSemaph->getSemaphoreCounter() == 0);
-                REQUIRE(binSemaph->release() == result::OK);
-        }
-        SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
-        // perform tear-down here
+// binary semaphores currently only supported on linux
+#if defined(FSFW_OSAL_LINUX) || defined(FSFW_OSAL_FREERTOS)
+
+TEST_CASE("Binary Semaphore Test", "[BinSemaphore]") {
+  // perform set-up here
+  SemaphoreIF* binSemaph = SemaphoreFactory::instance()->createBinarySemaphore();
+  REQUIRE(binSemaph != nullptr);
+  SECTION("Simple Test") {
+    // set-up is run for each section
+    REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+    REQUIRE(binSemaph->release() == static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+    REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) == returnvalue::OK);
+    {
+      // not precise enough on linux.. should use clock instead..
+      // Stopwatch stopwatch(false);
+      // REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+      //		SemaphoreIF::SEMAPHORE_TIMEOUT);
+      // dur_millis_t time = stopwatch.stop();
+      // CHECK(time == 5);
+    }
+    REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+    REQUIRE(binSemaph->release() == returnvalue::OK);
+  }
+  SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+  // perform tear-down here
 }
 
-
-TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
-        SECTION("Simple Test") {
-
-        }
+TEST_CASE("Counting Semaphore Test", "[CountingSemaph]") {
+  SECTION("Simple Test") {}
 }
-*/
 
-#endif
+#endif

unittests/testcfg/freertos/FreeRTOSConfig.h

@@ -0,0 +1,102 @@
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+#define configUSE_PREEMPTION 1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION 0
+#define configUSE_TICKLESS_IDLE 0
+#define configTICK_RATE_HZ 1000
+#define configMAX_PRIORITIES 5
+#define configMINIMAL_STACK_SIZE ((unsigned short)PTHREAD_STACK_MIN)
+#define configMAX_TASK_NAME_LEN 16
+#define configUSE_16_BIT_TICKS 0
+#define configIDLE_SHOULD_YIELD 1
+#define configUSE_TASK_NOTIFICATIONS 1
+#define configTASK_NOTIFICATION_ARRAY_ENTRIES 3
+#define configUSE_MUTEXES 1
+#define configUSE_RECURSIVE_MUTEXES 0
+#define configUSE_COUNTING_SEMAPHORES 1
+#define configUSE_ALTERNATIVE_API 0 /* Deprecated! */
+#define configQUEUE_REGISTRY_SIZE 20
+#define configUSE_QUEUE_SETS 0
+#define configUSE_TIME_SLICING 0
+#define configUSE_NEWLIB_REENTRANT 0
+#define configENABLE_BACKWARD_COMPATIBILITY 1
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5
+#define configUSE_MINI_LIST_ITEM 1
+#define configSTACK_DEPTH_TYPE uint16_t
+#define configMESSAGE_BUFFER_LENGTH_TYPE size_t
+#define configHEAP_CLEAR_MEMORY_ON_FREE 1
+
+/* Memory allocation related definitions. */
+#define configSUPPORT_STATIC_ALLOCATION 0
+#define configSUPPORT_DYNAMIC_ALLOCATION 1
+#define configTOTAL_HEAP_SIZE ((size_t)(1024 * 1024))
+#define configAPPLICATION_ALLOCATED_HEAP 1
+#define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP 0
+
+/* Hook function related definitions. */
+#define configUSE_IDLE_HOOK 0
+#define configUSE_TICK_HOOK 0
+#define configCHECK_FOR_STACK_OVERFLOW 0
+#define configUSE_MALLOC_FAILED_HOOK 0
+#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
+#define configUSE_SB_COMPLETED_CALLBACK 0
+
+/* Run time and task stats gathering related definitions. */
+#define configGENERATE_RUN_TIME_STATS 0
+#define configUSE_TRACE_FACILITY 0
+#define configUSE_STATS_FORMATTING_FUNCTIONS 0
+
+/* Co-routine related definitions. */
+#define configUSE_CO_ROUTINES 0
+#define configMAX_CO_ROUTINE_PRIORITIES 1
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS 1
+#define configTIMER_TASK_PRIORITY 3
+#define configTIMER_QUEUE_LENGTH 10
+#define configTIMER_TASK_STACK_DEPTH configMINIMAL_STACK_SIZE
+
+/* Interrupt nesting behaviour configuration. */
+#define configKERNEL_INTERRUPT_PRIORITY [dependent of processor]
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY [dependent on processor and application]
+#define configMAX_API_CALL_INTERRUPT_PRIORITY [dependent on processor and application]
+
+/* Define to trap errors during development. */
+//#define configASSERT( ( x ) ) if( ( x ) == 0 ) vAssertCalled( __FILE__, __LINE__ )
+
+/* FreeRTOS MPU specific definitions. */
+#define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS 0
+#define configTOTAL_MPU_REGIONS 8    /* Default value. */
+#define configTEX_S_C_B_FLASH 0x07UL /* Default value. */
+#define configTEX_S_C_B_SRAM 0x07UL  /* Default value. */
+#define configENFORCE_SYSTEM_CALLS_FROM_KERNEL_ONLY 1
+#define configALLOW_UNPRIVILEGED_CRITICAL_SECTIONS 1
+#define configENABLE_ERRATA_837070_WORKAROUND 1
+
+/* ARMv8-M secure side port related definitions. */
+#define secureconfigMAX_SECURE_CONTEXTS 5
+
+/* Optional functions - most linkers will remove unused functions anyway. */
+#define INCLUDE_vTaskPrioritySet 1
+#define INCLUDE_uxTaskPriorityGet 1
+#define INCLUDE_vTaskDelete 1
+#define INCLUDE_vTaskSuspend 1
+#define INCLUDE_xResumeFromISR 1
+#define INCLUDE_vTaskDelayUntil 1
+#define INCLUDE_vTaskDelay 1
+#define INCLUDE_xTaskGetSchedulerState 1
+#define INCLUDE_xTaskGetCurrentTaskHandle 1
+#define INCLUDE_uxTaskGetStackHighWaterMark 0
+#define INCLUDE_uxTaskGetStackHighWaterMark2 0
+#define INCLUDE_xTaskGetIdleTaskHandle 0
+#define INCLUDE_eTaskGetState 0
+#define INCLUDE_xEventGroupSetBitFromISR 1
+#define INCLUDE_xTimerPendFunctionCall 0
+#define INCLUDE_xTaskAbortDelay 0
+#define INCLUDE_xTaskGetHandle 0
+#define INCLUDE_xTaskResumeFromISR 1
+
+/* A header file that defines trace macro can be included here. */
+
+#endif /* FREERTOS_CONFIG_H */