more clang-tidy improvements

.run/fsfw-tests_coverage.run.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="fsfw-tests_coverage" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-example-hosted" TARGET_NAME="fsfw-tests_coverage" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-example-hosted" RUN_TARGET_NAME="fsfw-tests">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>

.run/fsfw.run.xml

@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="fsfw" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="fsfw-tests" TARGET_NAME="fsfw" CONFIG_NAME="Debug Unittest" RUN_TARGET_PROJECT_NAME="fsfw-tests" RUN_TARGET_NAME="fsfw-tests">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>

CHANGELOG.md

@@ -8,7 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v5.0.0] 25.07.2022
+# [v5.0.0]
 
 ## Changes
 
@@ -19,13 +19,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Bump C++ required version to C++17. Every project which uses the FSFW and every modern
   compiler supports it
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/622
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
+  name clashes with Windows defines.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - New CMake option `FSFW_HAL_LINUX_ADD_LIBGPIOD` to specifically exclude `gpiod` code.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Devicehandlers: Periodic printout is run-time configurable now
 - `oneShotAction` flag in the `TestTask` class is not static anymore
-- `SimpleRingBuffer::writeData` now checks if the amount is larger than the total size of the 
-  Buffer and rejects such writeData calls with `HasReturnvaluesIF::RETURN_FAILED`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/586
 - Major update for version handling, using `git describe` to fetch version information with git.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
   - Add helper functions provided by [`cmake-modules`](https://github.com/bilke/cmake-modules)
@@ -43,9 +46,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   creation call. It allows passing context information and an arbitrary user argument into
   the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
-- Internal API change: Moved the `fsfw_hal` to the `src` folder and integration and internal
-  tests part of `fsfw_tests` to `src`. Unittests are now in a dedicated folder called `unittests`
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/653
 
 ### Task Module Refactoring
 
@@ -120,8 +120,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
-- New constructor for PoolEntry which allows to simply specify the length of the pool entry.
-  This is also the new default constructor for scalar value with 0 as an initial value
 - Added options for CI/CD builds: `FSFW_CICD_BUILD`. This allows the source code to know
   whether it is running in CI/CD
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/623
@@ -141,6 +139,7 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
     - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
   Easiest solution for now: Keep this option OFF by default.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
@@ -155,17 +154,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
-## HAL
-
-- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
-- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
-- SPI: Getter functions for SPI speed and mode.
-- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed
 
 - TCP TMTC Server: `MutexGuard` was not created properly in

CMakeLists.txt

@@ -13,7 +13,7 @@ list(APPEND CMAKE_MODULE_PATH
 # Version file handling  #
 # ##############################################################################
 
-set(FSFW_VERSION_IF_GIT_FAILS 5)
+set(FSFW_VERSION_IF_GIT_FAILS 4)
 set(FSFW_SUBVERSION_IF_GIT_FAILS 0)
 set(FSFW_REVISION_IF_GIT_FAILS 0)
 
@@ -67,7 +67,6 @@ endif()
 set(FSFW_SOURCES_DIR "${CMAKE_SOURCE_DIR}/src/fsfw")
 
 set(FSFW_ETL_LIB_NAME etl)
-set(FSFW_ETL_LINK_TARGET etl::etl)
 set(FSFW_ETL_LIB_MAJOR_VERSION
     20
     CACHE STRING "ETL library major version requirement")
@@ -104,11 +103,11 @@ if(FSFW_GENERATE_SECTIONS)
   option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()
 
-option(FSFW_BUILD_TESTS "Build unittest binary in addition to static library"
+option(FSFW_BUILD_UNITTESTS
-       OFF)
+       "Build unittest binary in addition to static library" OFF)
 option(FSFW_CICD_BUILD "Build for CI/CD. This can disable problematic test" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
   option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()
 
@@ -118,11 +117,6 @@ option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
 option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
 option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)
 
-if(UNIX)
-    option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add Linux peripheral drivers" OFF)
-    option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Attempt to add Linux GPIOD drivers" OFF)
-endif()
-
 # Optional sources
 option(FSFW_ADD_PUS "Compile with PUS sources" ON)
 option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
@@ -145,7 +139,7 @@ if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
                                                 TRUE)
 endif()
 
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
   message(
     STATUS
       "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
@@ -168,9 +162,10 @@ if(FSFW_BUILD_TESTS)
     list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
   endif()
 
-  set(FSFW_CONFIG_PATH unittests/testcfg)
+  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
-  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in
+                 tests/TestsConfig.h)
 
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
@@ -188,18 +183,15 @@ if(FSFW_BUILD_TESTS)
   endif()
 endif()
 
-message(
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
-  STATUS
-    "${MSG_PREFIX} Finding and/or providing etl library with version ${FSFW_ETL_LIB_MAJOR_VERSION}"
-)
 
 # Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
+      "No ETL installation was found with find_package. Installing and providing "
       "etl with FindPackage")
   include(FetchContent)
 
@@ -289,15 +281,16 @@ message(
 )
 
 add_subdirectory(src)
-add_subdirectory(contrib)
+add_subdirectory(tests)
-if(FSFW_BUILD_TESTS)
+if(FSFW_ADD_HAL)
-  add_subdirectory(unittests)
+  add_subdirectory(hal)
 endif()
+add_subdirectory(contrib)
 if(FSFW_BUILD_DOCS)
   add_subdirectory(docs)
 endif()
 
-if(FSFW_BUILD_TESTS)
+if(FSFW_BUILD_UNITTESTS)
   if(FSFW_TESTS_GEN_COV)
     if(CMAKE_COMPILER_IS_GNUCXX)
       include(CodeCoverage)
@@ -454,8 +447,8 @@ target_include_directories(
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                 ${COMPILER_FLAGS})
 
-target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ADDITIONAL_LINK_LIBS})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_ETL_LINK_TARGET})
+                                               ${FSFW_ADDITIONAL_LINK_LIBS})
 
 string(
   CONCAT

README.md

@@ -132,14 +132,14 @@ You can use the following commands inside the `fsfw` folder to set up the build
 
 ```sh
 mkdir build-tests && cd build-tests
-cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
 You can also use `-DFSFW_OSAL=linux` on Linux systems.
 
 Coverage data in HTML format can be generated using the `CodeCoverage`
 [CMake module](https://github.com/bilke/cmake-modules/tree/master).
-To build the unittests, run them and then generate the coverage data in this format,
+To build the unittests, run them and then generare the coverage data in this format,
 the following command can be used inside the build directory after the build system was set up
 
 ```sh
@@ -188,10 +188,7 @@ and open the documentation conveniently. Try `helper.py -h for more information.
 
 The formatting is done by the `clang-format` tool. The configuration is contained within the
 `.clang-format` file in the repository root. As long as `clang-format` is installed, you
-can run the `auto-format.sh` helper script to format all source files consistently. Furthermore cmake-format is required to format CMake files which can be installed with:
+can run the `apply-clang-format.sh` helper script to format all source files consistently.
-````sh
-sudo pip install cmakelang
-````
 
 ## Index
 

automation/Dockerfile

@@ -12,9 +12,3 @@ RUN git clone https://github.com/catchorg/Catch2.git && \
 	git checkout v3.0.0-preview5 && \
 	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
 	cmake --build build/ --target install
-
-RUN git clone https://github.com/ETLCPP/etl.git && \
-	cd etl && \
-	git checkout 20.28.0 && \
-	cmake -B build . && \
-	cmake --install build/

automation/Jenkinsfile

@@ -3,7 +3,7 @@ pipeline {
         BUILDDIR = 'build-tests'
     }
     agent {
-        docker { image 'fsfw-ci:d3'}
+        docker { image 'fsfw-ci:d2'}
     }
     stages {
         stage('Clean') {
@@ -14,7 +14,7 @@ pipeline {
         stage('Configure') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON -DFSFW_CICD_BUILD=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
                 }
             }
         }

docs/getting_started.rst

@@ -106,7 +106,7 @@ You can use the following commands inside the ``fsfw`` folder to set up the buil
 .. code-block:: console
 
    mkdir build-tests && cd build-tests
-   cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host ..
+   cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
 
 
 You can also use ``-DFSFW_OSAL=linux`` on Linux systems.

hal/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.13)
+
+# Can also be changed by upper CMakeLists.txt file
+find_library(LIB_FSFW_NAME fsfw REQUIRED)
+
+option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod library" OFF)
+# On by default for now because I did not have an issue including and compiling those files
+# and libraries on a Desktop Linux system and the primary target of the FSFW is still embedded
+# Linux. The only exception from this is the gpiod library which requires a dedicated installation,
+# but CMake is able to determine whether this library is installed with find_library.
+option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add peripheral drivers for embedded Linux" ON)
+option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Target implements libgpiod" ON)
+
+option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
+option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)
+option(FSFW_HAL_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+
+set(LINUX_HAL_PATH_NAME linux)
+set(STM32H7_PATH_NAME stm32h7)
+
+add_subdirectory(src)
+
+foreach(INCLUDE_PATH ${FSFW_HAL_ADDITIONAL_INC_PATHS})
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
+        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+    else()
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+    endif()
+
+    if(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()
+
+    list(APPEND FSFW_HAL_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_ADD_INC_PATHS_ABS}
+)
+
+target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_DEFINES}
+)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_LINK_LIBS}
+)

hal/src/CMakeLists.txt

@@ -0,0 +1,9 @@
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw_hal)

hal/src/fsfw_hal/common/gpio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GpioCookie.cpp
+)

hal/src/fsfw_hal/common/gpio/GpioIF.h

@@ -46,9 +46,9 @@ class GpioIF : public HasReturnvaluesIF {
    *          an ouput or input gpio.
    *
    * @param gpioId    A unique number which specifies the GPIO to read.
-   * @param gpioState State of GPIO will be written to this reference
+   * @param gpioState State of GPIO will be written to this pointer.
    */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
 };
 
 #endif /* COMMON_GPIO_GPIOIF_H_ */

hal/src/fsfw_hal/common/gpio/gpioDefinitions.h

@@ -9,7 +9,7 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -1, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, NONE = 99 };
 
 enum class Direction : int { IN = 0, OUT = 1 };
 

hal/src/fsfw_hal/devicehandlers/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GyroL3GD20Handler.cpp
+    MgmRM3100Handler.cpp
+    MgmLIS3MDLHandler.cpp
+)

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -252,7 +252,6 @@ ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &l
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForPeriodicPacket(dataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -17,8 +17,6 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
   registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
 }
 
-MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {}
-
 void MgmLIS3MDLHandler::doStartUp() {
   switch (internalState) {
     case (InternalState::STATE_NONE): {
@@ -90,7 +88,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
 
 uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
   command |= (1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -98,7 +96,7 @@ uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
 
 uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) {
   command &= ~(1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom == true) {
+  if (continuousCom) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -375,16 +373,13 @@ float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
 
 ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(const uint8_t *commandData,
                                                          size_t commandDataLen) {
-  if (commandData == nullptr) {
-    return INVALID_COMMAND_PARAMETER;
-  }
   triggerEvent(CHANGE_OF_SETUP_PARAMETER);
   uint32_t size = 2;
   commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
   if (commandDataLen > 1) {
     return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
   }
-  switch (commandData[0]) {
+  switch (*commandData) {
     case (MGMLIS3MDL::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;
@@ -475,7 +470,6 @@ ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &lo
   localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForPeriodicPacket(dataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -28,7 +28,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
 
   MgmLIS3MDLHandler(uint32_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     uint32_t transitionDelay);
-  virtual ~MgmLIS3MDLHandler();
+  ~MgmLIS3MDLHandler() override = default;
 
   void enablePeriodicPrintouts(bool enable, uint8_t divider);
   /**
@@ -46,7 +46,7 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   void doShutDown() override;
   void doStartUp() override;
   void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
-  virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+  uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
   ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
                                         size_t commandDataLen) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
@@ -60,9 +60,9 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param packet
    * @return
    */
-  virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void fillCommandAndReplyMap() override;
-  void modeChanged(void) override;
+  void modeChanged() override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
 
@@ -72,8 +72,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
 
   uint32_t transitionDelay;
-  // Single SPI command has 2 bytes, first for adress, second for content
-  size_t singleComandSize = 2;
   // Has the size for all adresses of the lis3mdl + the continous write bit
   uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1];
 
@@ -88,7 +86,6 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    */
   uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
 
-  uint8_t statusRegister = 0;
   bool goToNormalMode = false;
 
   enum class InternalState {
@@ -111,14 +108,14 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
    * @param single command to set the read-bit at
    * @param boolean to select a continuous read bit, default = false
    */
-  uint8_t readCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t readCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * Sets the write bit for the command
    * @param single command to set the write-bit at
    * @param boolean to select a continuous write bit, default = false
    */
-  uint8_t writeCommand(uint8_t command, bool continuousCom = false);
+  static uint8_t writeCommand(uint8_t command, bool continuousCom = false);
 
   /**
    * This Method gets the full scale for the measurement range

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -312,7 +312,6 @@ ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &loc
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForPeriodicPacket(primaryDataset.getSid(), false, 10.0, false);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -330,9 +329,9 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
   int32_t fieldStrengthRawZ = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
 
   // Now scale to physical value in microtesla
-  float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
+  float fieldStrengthX = static_cast<float>(fieldStrengthRawX) * scaleFactorX;
-  float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
+  float fieldStrengthY = static_cast<float>(fieldStrengthRawY) * scaleFactorY;
-  float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+  float fieldStrengthZ = static_cast<float>(fieldStrengthRawZ) * scaleFactorZ;
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -72,7 +72,6 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   RM3100::Rm3100PrimaryDataset primaryDataset;
 
   uint8_t commandBuffer[10];
-  uint8_t commandBufferLen = 0;
 
   uint8_t cmmRegValue = RM3100::CMM_VALUE;
   uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE;
@@ -100,4 +99,4 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
-#endif /* MISSION_DEVICEHANDLING_MGMRM3100HANDLER_H_ */
+#endif /* MISSION_DEVICES_MGMRM3100HANDLER_H_ */

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -0,0 +1,25 @@
+if(FSFW_HAL_ADD_RASPBERRY_PI)
+    add_subdirectory(rpi)
+endif()
+
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	UnixFileGuard.cpp
+	CommandExecutor.cpp
+	utility.cpp
+)
+
+if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
+if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
+	add_subdirectory(gpio)
+endif()
+	add_subdirectory(uart)
+	# Adding those does not really make sense on Apple systems which
+	# are generally host systems. It won't even compile as the headers
+	# are missing
+	if(NOT APPLE)
+		add_subdirectory(i2c)
+		add_subdirectory(spi)
+	endif()
+endif()
+
+add_subdirectory(uio)

hal/src/fsfw_hal/linux/CommandExecutor.cpp

@@ -32,8 +32,6 @@ ReturnValue_t CommandExecutor::execute() {
   } else if (state == States::PENDING) {
     return COMMAND_PENDING;
   }
-  // Reset data in read vector
-  std::memset(readVec.data(), 0, readVec.size());
   currentCmdFile = popen(currentCmd.c_str(), "r");
   if (currentCmdFile == nullptr) {
     lastError = errno;
@@ -207,5 +205,3 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
-
-const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }

hal/src/fsfw_hal/linux/CommandExecutor.h

@@ -109,8 +109,6 @@ class CommandExecutor {
    */
   void reset();
 
-  const std::vector<char>& getReadVector() const;
-
  private:
   std::string currentCmd;
   bool blocking = true;

hal/src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -6,7 +6,7 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface.h"
 
-UnixFileGuard::UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                              std::string diagnosticPrefix)
     : fileDescriptor(fileDescriptor) {
   if (fileDescriptor == nullptr) {

hal/src/fsfw_hal/linux/UnixFileGuard.h

@@ -15,7 +15,7 @@ class UnixFileGuard {
 
   static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
 
-  UnixFileGuard(const std::string& device, int* fileDescriptor, int flags,
+  UnixFileGuard(std::string device, int* fileDescriptor, int flags,
                 std::string diagnosticPrefix = "");
 
   virtual ~UnixFileGuard();

hal/src/fsfw_hal/linux/gpio/CMakeLists.txt

@@ -0,0 +1,16 @@
+# This abstraction layer requires the gpiod library. You can install this library
+# with "sudo apt-get install -y libgpiod-dev". If you are cross-compiling, you need
+# to install the package before syncing the sysroot to your host computer.
+find_library(LIB_GPIO gpiod)
+
+if(${LIB_GPIO} MATCHES LIB_GPIO-NOTFOUND)
+    message(STATUS "gpiod library not found, not linking against it")
+else()
+    target_sources(${LIB_FSFW_NAME} PRIVATE
+        LinuxLibgpioIF.cpp
+    )
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_GPIO}
+    )
+endif()
+

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -294,7 +294,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
   return RETURN_OK;
 }
 
-ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -313,10 +313,7 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState)
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    gpioState = static_cast<gpio::Levels>(gpiod_line_get_value(regularGpio->lineHandle));
+    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
-    if (gpioState == gpio::Levels::FAILED) {
-      return GPIO_GET_VALUE_FAILED;
-    }
   } else {
     auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
     if (gpioCallback->callback == nullptr) {

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h

@@ -31,16 +31,14 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
   static constexpr ReturnValue_t GPIO_INIT_FAILED =
       HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 6);
-  // Will be returned if getting the line value failed. Error type will be set to errno in this case
+
-  static constexpr ReturnValue_t GPIO_GET_VALUE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 7);
   LinuxLibgpioIF(object_id_t objectId);
   virtual ~LinuxLibgpioIF();
 
   ReturnValue_t addGpios(GpioCookie* gpioCookie) override;
   ReturnValue_t pullHigh(gpioId_t gpioId) override;
   ReturnValue_t pullLow(gpioId_t gpioId) override;
-  ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& gpioState) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
 
  private:
   static const size_t MAX_CHIPNAME_LENGTH = 11;

hal/src/fsfw_hal/linux/i2c/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    I2cComIF.cpp
+    I2cCookie.cpp
+)
+
+
+
+

hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -170,20 +170,18 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 
   int readLen = read(fd, replyBuffer, requestLen);
   if (readLen != static_cast<int>(requestLen)) {
-#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-    if (readLen < 0) {
+               << "device failed with error code " << errno << ". Description"
-      sif::warning << "I2cComIF::requestReceiveMessage: Reading from I2C "
+               << " of error: " << strerror(errno) << std::endl;
-                   << "device failed with error code " << errno << " | " << strerror(errno)
+    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
-                   << std::endl;
+               << " bytes" << std::endl;
-    } else {
-      sif::warning << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from "
-                   << requestLen << " bytes" << std::endl;
-    }
-#else
-#endif
 #endif
     i2cDeviceMapIter->second.replyLen = 0;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 

hal/src/fsfw_hal/linux/rpi/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GpioRPi.cpp
+)

hal/src/fsfw_hal/linux/spi/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    SpiComIF.cpp
+    SpiCookie.cpp
+)
+
+
+
+

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -15,8 +15,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 #include "fsfw_hal/linux/utility.h"
 
-SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
+SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
-    : SystemObject(objectId), gpioComIF(gpioComIF), dev(std::move(devname)) {
+    : SystemObject(objectId), gpioComIF(gpioComIF) {
   if (gpioComIF == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -27,7 +27,7 @@ SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
   }
 
-  csMutex = MutexFactory::instance()->createMutex();
+  spiMutex = MutexFactory::instance()->createMutex();
 }
 
 ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
@@ -85,7 +85,8 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
 
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
+  UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
+                           "SpiComIF::initializeInterface");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
@@ -181,7 +182,8 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   int retval = 0;
   /* Prepare transfer */
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  std::string device = spiCookie->getSpiDevice();
+  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -194,27 +196,20 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 
   bool fullDuplex = spiCookie->isFullDuplex();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  bool csLockManual = spiCookie->getCsLockManual();
 
-  MutexIF::TimeoutType csType;
+  /* Pull SPI CS low. For now, no support for active high given  */
-  dur_millis_t csTimeout = 0;
+  if (gpioId != gpio::NO_GPIO) {
-  // Pull SPI CS low. For now, no support for active high given
+    result = spiMutex->lockMutex(timeoutType, timeoutMs);
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
     if (result != RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
 #else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
 #endif
 #endif
       return result;
     }
-    updateLinePolarity(fileDescriptor);
     result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -226,8 +221,6 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
-  } else {
-    updateLinePolarity(fileDescriptor);
   }
 
   /* Execute transfer */
@@ -255,9 +248,9 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     }
   }
 
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
-    result = csMutex->unlockMutex();
+    result = spiMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
@@ -285,8 +278,9 @@ ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 
 ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::string device = spiCookie->getSpiDevice();
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -298,22 +292,12 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     return result;
   }
 
-  bool csLockManual = spiCookie->getCsLockManual();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  MutexIF::TimeoutType csType;
+  if (gpioId != gpio::NO_GPIO) {
-  dur_millis_t csTimeout = 0;
+    result = spiMutex->lockMutex(timeoutType, timeoutMs);
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    spiCookie->getMutexParams(csType, csTimeout);
-    result = csMutex->lockMutex(csType, csTimeout);
     if (result != RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
-                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
-                 << std::endl;
-#else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
-#endif
 #endif
       return result;
     }
@@ -331,9 +315,9 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     result = HALF_DUPLEX_TRANSFER_FAILED;
   }
 
-  if (gpioId != gpio::NO_GPIO and not csLockManual) {
+  if (gpioId != gpio::NO_GPIO) {
     gpioComIF->pullHigh(gpioId);
-    result = csMutex->unlockMutex();
+    result = spiMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
@@ -362,7 +346,15 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* SpiComIF::getCsMutex() { return csMutex; }
+MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
+  if (timeoutType != nullptr) {
+    *timeoutType = this->timeoutType;
+  }
+  if (timeoutMs != nullptr) {
+    *timeoutMs = this->timeoutMs;
+  }
+  return spiMutex;
+}
 
 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
   if (spiCookie == nullptr) {
@@ -409,27 +401,11 @@ void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed)
   if (retval != 0) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
   }
-}
+  // This updates the SPI clock default polarity. Only setting the mode does not update
-
+  // the line state, which can be an issue on mode switches because the clock line will
-void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const {
+  // switch the state after the chip select is pulled low
-  uint8_t tmpMode = 0;
-  int retval = ioctl(spiFd, SPI_IOC_RD_MODE, &tmpMode);
-  if (retval != 0) {
-    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Reading SPI mode failed");
-  }
-  mode = static_cast<spi::SpiModes>(tmpMode);
-
-  retval = ioctl(spiFd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
-  if (retval != 0) {
-    utility::handleIoctlError("SpiComIF::getSpiSpeedAndMode: Getting SPI speed failed");
-  }
-}
-
-const std::string& SpiComIF::getSpiDev() const { return dev; }
-
-void SpiComIF::updateLinePolarity(int spiFd) {
   clockUpdateTransfer.len = 0;
-  int retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
+  retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
   if (retval != 0) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Updating SPI default clock failed");
   }

hal/src/fsfw_hal/linux/spi/SpiComIF.h

@@ -22,17 +22,17 @@ class SpiCookie;
  */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
-  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
   static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
+      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
 
-  SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
+  SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;
   ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -44,8 +44,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * @brief   This function returns the mutex which can be used to protect the spi bus when
    *          the chip select must be driven from outside of the com if.
    */
-  MutexIF* getCsMutex();
+  MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
-  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -60,20 +59,6 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 
   GpioIF* getGpioInterface();
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
-  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
-
-  /**
-   * This updates the SPI clock default polarity. Only setting the mode does not update
-   * the line state, which can be an issue on mode switches because the clock line will
-   * switch the state after the chip select is pulled low.
-   *
-   * It is recommended to call this function after #setSpiSpeedAndMode and after locking the
-   * CS mutex if the SPI bus has multiple SPI devices with different speed and SPI modes attached.
-   * @param spiFd
-   */
-  void updateLinePolarity(int spiFd);
-
-  const std::string& getSpiDev() const;
   void performSpiWiretapping(SpiCookie* spiCookie);
 
   ReturnValue_t getReadBuffer(address_t spiAddress, uint8_t** buffer);
@@ -85,14 +70,10 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   };
 
   GpioIF* gpioComIF = nullptr;
-  std::string dev = "";
+
-  /**
+  MutexIF* spiMutex = nullptr;
-   * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-   * pulled high
+  uint32_t timeoutMs = 20;
-   */
-  MutexIF* csMutex = nullptr;
-  // MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  // uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
   spi_ioc_transfer clockUpdateTransfer = {};
 
   using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;

hal/src/fsfw_hal/linux/spi/SpiCookie.cpp

@@ -1,25 +1,26 @@
 #include "SpiCookie.h"
 
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
+                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed)
+    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, spiDev, maxSize, spiMode,
+                spiSpeed, nullptr, nullptr) {}
+
+SpiCookie::SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxSize,
                      spi::SpiModes spiMode, uint32_t spiSpeed)
-    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
+    : SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {}
-                nullptr, nullptr) {}
 
-SpiCookie::SpiCookie(address_t spiAddress, const size_t maxSize, spi::SpiModes spiMode,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-                     uint32_t spiSpeed)
-    : SpiCookie(spiAddress, gpio::NO_GPIO, maxSize, spiMode, spiSpeed) {}
-
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
-                     spi::SpiModes spiMode, uint32_t spiSpeed,
-                     spi::send_callback_function_t callback, void* args)
-    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
-                callback, args) {}
-
-SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
                      const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
                      spi::send_callback_function_t callback, void* args)
+    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, spiDev, maxSize, spiMode,
+                spiSpeed, callback, args) {}
+
+SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
+                     std::string spiDev, const size_t maxSize, spi::SpiModes spiMode,
+                     uint32_t spiSpeed, spi::send_callback_function_t callback, void* args)
     : spiAddress(spiAddress),
       chipSelectPin(chipSelect),
+      spiDevice(spiDev),
       comIfMode(comIfMode),
       maxSize(maxSize),
       spiMode(spiMode),
@@ -49,6 +50,8 @@ size_t SpiCookie::getMaxBufferSize() const { return maxSize; }
 
 address_t SpiCookie::getSpiAddress() const { return spiAddress; }
 
+std::string SpiCookie::getSpiDevice() const { return spiDevice; }
+
 void SpiCookie::setThreeWireSpi(bool enable) { uncommonParameters.threeWireSpi = enable; }
 
 void SpiCookie::setLsbFirst(bool enable) { uncommonParameters.lsbFirst = enable; }
@@ -104,17 +107,3 @@ void SpiCookie::getCallback(spi::send_callback_function_t* callback, void** args
   *callback = this->sendCallback;
   *args = this->callbackArgs;
 }
-
-void SpiCookie::setCsLockManual(bool enable) { manualCsLock = enable; }
-
-bool SpiCookie::getCsLockManual() const { return manualCsLock; }
-
-void SpiCookie::getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const {
-  csTimeoutType = this->csTimeoutType;
-  csTimeout = this->csTimeout;
-}
-
-void SpiCookie::setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout) {
-  this->csTimeoutType = csTimeoutType;
-  this->csTimeout = csTimeout;
-}

hal/src/fsfw_hal/linux/spi/SpiCookie.h

@@ -2,8 +2,6 @@
 #define LINUX_SPI_SPICOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
-#include <fsfw/ipc/MutexIF.h>
-#include <fsfw/timemanager/clockDefinitions.h>
 #include <linux/spi/spidev.h>
 
 #include "../../common/gpio/gpioDefinitions.h"
@@ -22,8 +20,6 @@
  */
 class SpiCookie : public CookieIF {
  public:
-  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
-
   /**
    * Each SPI device will have a corresponding cookie. The cookie is used by the communication
    * interface and contains device specific information like the largest expected size to be
@@ -33,22 +29,23 @@ class SpiCookie : public CookieIF {
    * @param spiDev
    * @param maxSize
    */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
-            uint32_t spiSpeed);
+            spi::SpiModes spiMode, uint32_t spiSpeed);
 
   /**
    * Like constructor above, but without a dedicated GPIO CS. Can be used for hardware
    * slave select or if CS logic is performed with decoders.
    */
-  SpiCookie(address_t spiAddress, const size_t maxReplySize, spi::SpiModes spiMode,
+  SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxReplySize,
-            uint32_t spiSpeed);
+            spi::SpiModes spiMode, uint32_t spiSpeed);
 
   /**
    * Use the callback mode of the SPI communication interface. The user can pass the callback
    * function here or by using the setter function #setCallbackMode
    */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, spi::SpiModes spiMode,
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
-            uint32_t spiSpeed, spi::send_callback_function_t callback, void* args);
+            spi::SpiModes spiMode, uint32_t spiSpeed, spi::send_callback_function_t callback,
+            void* args);
 
   /**
    * Get the callback function
@@ -58,6 +55,7 @@ class SpiCookie : public CookieIF {
   void getCallback(spi::send_callback_function_t* callback, void** args);
 
   address_t getSpiAddress() const;
+  std::string getSpiDevice() const;
   gpioId_t getChipSelectPin() const;
   size_t getMaxBufferSize() const;
 
@@ -141,42 +139,9 @@ class SpiCookie : public CookieIF {
    */
   void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);
 
-  void getMutexParams(MutexIF::TimeoutType& csTimeoutType, dur_millis_t& csTimeout) const;
-  void setMutexParams(MutexIF::TimeoutType csTimeoutType, dur_millis_t csTimeout);
-
-  void setCsLockManual(bool enable);
-  bool getCsLockManual() const;
-
   spi_ioc_transfer* getTransferStructHandle();
 
  private:
-  address_t spiAddress;
-  gpioId_t chipSelectPin;
-
-  spi::SpiComIfModes comIfMode;
-
-  // Required for regular mode
-  const size_t maxSize;
-  spi::SpiModes spiMode;
-  /**
-   * If this is set to true, the SPI ComIF will not perform any mutex locking for the
-   * CS mechanism. The user is responsible to locking and unlocking the mutex for the
-   * whole duration of the transfers.
-   */
-  bool manualCsLock = false;
-  uint32_t spiSpeed;
-  bool halfDuplex = false;
-
-  MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::WAITING;
-  dur_millis_t csTimeout = DEFAULT_MUTEX_TIMEOUT;
-
-  // Required for callback mode
-  spi::send_callback_function_t sendCallback = nullptr;
-  void* callbackArgs = nullptr;
-
-  struct spi_ioc_transfer spiTransferStruct = {};
-  UncommonParameters uncommonParameters;
-
   /**
    * Internal constructor which initializes every field
    * @param spiAddress
@@ -189,8 +154,27 @@ class SpiCookie : public CookieIF {
    * @param args
    */
   SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
             spi::send_callback_function_t callback, void* args);
+
+  address_t spiAddress;
+  gpioId_t chipSelectPin;
+  std::string spiDevice;
+
+  spi::SpiComIfModes comIfMode;
+
+  // Required for regular mode
+  const size_t maxSize;
+  spi::SpiModes spiMode;
+  uint32_t spiSpeed;
+  bool halfDuplex = false;
+
+  // Required for callback mode
+  spi::send_callback_function_t sendCallback = nullptr;
+  void* callbackArgs = nullptr;
+
+  struct spi_ioc_transfer spiTransferStruct = {};
+  UncommonParameters uncommonParameters;
 };
 
 #endif /* LINUX_SPI_SPICOOKIE_H_ */

hal/src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UartComIF.cpp
+	UartCookie.cpp
+)

hal/src/fsfw_hal/linux/uart/UartCookie.cpp

@@ -2,8 +2,8 @@
 
 #include <fsfw/serviceinterface.h>
 
-UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
-                       size_t maxReplyLen, UartModes uartMode)
+                       UartBaudRate baudrate, size_t maxReplyLen)
     : handlerId(handlerId),
       deviceFile(deviceFile),
       uartMode(uartMode),

hal/src/fsfw_hal/linux/uart/UartCookie.h

@@ -69,8 +69,8 @@ class UartCookie : public CookieIF {
    *                        8 databits (number of bits transfered with one uart frame)
    *                        One stop bit
    */
-  UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
-             size_t maxReplyLen, UartModes uartMode = UartModes::NON_CANONICAL);
+             UartBaudRate baudrate, size_t maxReplyLen);
 
   virtual ~UartCookie();
 

hal/src/fsfw_hal/linux/uio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UioMapper.cpp
+)

hal/src/fsfw_hal/stm32h7/CMakeLists.txt

@@ -2,4 +2,6 @@ add_subdirectory(spi)
 add_subdirectory(gpio)
 add_subdirectory(devicetest)
 
-target_sources(${LIB_FSFW_NAME} PRIVATE dma.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    dma.cpp
+)

hal/src/fsfw_hal/stm32h7/devicetest/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GyroL3GD20H.cpp
+)

hal/src/fsfw_hal/stm32h7/gpio/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    gpio.cpp
+)

hal/src/fsfw_hal/stm32h7/i2c/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+)

hal/src/fsfw_hal/stm32h7/spi/CMakeLists.txt

@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    spiCore.cpp
+    spiDefinitions.cpp
+    spiInterrupts.cpp
+    mspInit.cpp
+    SpiCookie.cpp
+    SpiComIF.cpp
+    stm32h743zi.cpp
+)

hal/src/fsfw_hal/stm32h7/uart/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+)

scripts/auto-formatter.sh

@@ -3,11 +3,6 @@ if [[ ! -f README.md ]]; then
   cd ..
 fi
 
-folder_list=(
-  "./src"
-  "./unittests"
-)
-
 cmake_fmt="cmake-format"
 file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
@@ -20,10 +15,9 @@ fi
 cpp_format="clang-format"
 file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
 if command -v ${cpp_format} &> /dev/null; then
-  for dir in ${folder_list[@]}; do
+  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-    echo "Auto-formatting ${dir} recursively"
+  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
+  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
-  done
 else
   echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi

scripts/helper.py

@@ -48,20 +48,6 @@ def main():
         action="store_true",
         help="Run valgrind on generated test binary",
     )
-    parser.add_argument(
-        "-g",
-        "--generators",
-        default = "Ninja",
-        action="store",
-        help="CMake generators",
-    )
-    parser.add_argument(
-        "-w",
-        "--windows",
-        default=False,
-        action="store_true",
-        help="Run on windows",
-    )
 
     args = parser.parse_args()
     if args.all:
@@ -129,14 +115,14 @@ def handle_tests_type(args, build_dir_list: list):
     if args.create:
         if os.path.exists(UNITTEST_FOLDER_NAME):
             shutil.rmtree(UNITTEST_FOLDER_NAME)
-        create_tests_build_cfg(args)
+        create_tests_build_cfg()
         build_directory = UNITTEST_FOLDER_NAME
     elif len(build_dir_list) == 0:
         print(
             "No valid CMake tests build directory found. "
             "Trying to set up test build system"
         )
-        create_tests_build_cfg(args)
+        create_tests_build_cfg()
         build_directory = UNITTEST_FOLDER_NAME
     elif len(build_dir_list) == 1:
         build_directory = build_dir_list[0]
@@ -161,15 +147,10 @@ def handle_tests_type(args, build_dir_list: list):
         os.chdir("..")
 
 
-def create_tests_build_cfg(args):
+def create_tests_build_cfg():
     os.mkdir(UNITTEST_FOLDER_NAME)
     os.chdir(UNITTEST_FOLDER_NAME)
-    if args.windows:
+    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
-        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON \
-        -DGCOVR_PATH="py -m gcovr" ..'
-    else:
-        cmake_cmd = 'cmake -G "' + args.generators + '" -DFSFW_OSAL=host -DFSFW_BUILD_TESTS=ON ..'
-    cmd_runner(cmake_cmd)
     os.chdir("..")
 
 

src/CMakeLists.txt

@@ -4,8 +4,3 @@ target_include_directories(${LIB_FSFW_NAME}
                            INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(fsfw)
-if(FSFW_ADD_HAL)
-  add_subdirectory(fsfw_hal)
-endif()
-
-add_subdirectory(fsfw_tests)

src/fsfw/action/CommandActionHelper.h

@@ -16,8 +16,8 @@ class CommandActionHelper {
  public:
   explicit CommandActionHelper(CommandsActionsIF* owner);
   virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
-                              const uint8_t* data = nullptr, uint32_t size = 0);
+                              uint32_t size);
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);

src/fsfw/cfdp/CFDPHandler.cpp

@@ -12,9 +12,7 @@ object_id_t CFDPHandler::packetDestination = 0;
 
 CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
     : SystemObject(setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
   distributor = dist;
 }
 

src/fsfw/cfdp/pdu/AckInfo.cpp

@@ -13,10 +13,12 @@ AckInfo::AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedC
   }
 }
 
+AckInfo::AckInfo() = default;
+
 cfdp::ConditionCode AckInfo::getAckedConditionCode() const { return ackedConditionCode; }
 
-void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
+void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_) {
-  this->ackedConditionCode = ackedConditionCode;
+  ackedConditionCode = ackedConditionCode_;
   if (ackedDirective == cfdp::FileDirectives::FINISH) {
     this->directiveSubtypeCode = 0b0001;
   } else {
@@ -26,20 +28,18 @@ void AckInfo::setAckedConditionCode(cfdp::ConditionCode ackedConditionCode) {
 
 cfdp::FileDirectives AckInfo::getAckedDirective() const { return ackedDirective; }
 
-void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective) {
+void AckInfo::setAckedDirective(cfdp::FileDirectives ackedDirective_) {
-  this->ackedDirective = ackedDirective;
+  ackedDirective = ackedDirective_;
 }
 
 uint8_t AckInfo::getDirectiveSubtypeCode() const { return directiveSubtypeCode; }
 
-void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode) {
+void AckInfo::setDirectiveSubtypeCode(uint8_t directiveSubtypeCode_) {
-  this->directiveSubtypeCode = directiveSubtypeCode;
+  directiveSubtypeCode = directiveSubtypeCode_;
 }
 
 cfdp::AckTransactionStatus AckInfo::getTransactionStatus() const { return transactionStatus; }
 
-AckInfo::AckInfo() {}
+void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus_) {
-
+  transactionStatus = transactionStatus_;
-void AckInfo::setTransactionStatus(cfdp::AckTransactionStatus transactionStatus) {
-  this->transactionStatus = transactionStatus;
 }

src/fsfw/cfdp/pdu/AckInfo.h

@@ -9,16 +9,16 @@ class AckInfo {
   AckInfo(cfdp::FileDirectives ackedDirective, cfdp::ConditionCode ackedConditionCode,
           cfdp::AckTransactionStatus transactionStatus, uint8_t directiveSubtypeCode = 0);
 
-  cfdp::ConditionCode getAckedConditionCode() const;
+  [[nodiscard]] cfdp::ConditionCode getAckedConditionCode() const;
-  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode);
+  void setAckedConditionCode(cfdp::ConditionCode ackedConditionCode_);
 
-  cfdp::FileDirectives getAckedDirective() const;
+  [[nodiscard]] cfdp::FileDirectives getAckedDirective() const;
   void setAckedDirective(cfdp::FileDirectives ackedDirective);
 
-  uint8_t getDirectiveSubtypeCode() const;
+  [[nodiscard]] uint8_t getDirectiveSubtypeCode() const;
   void setDirectiveSubtypeCode(uint8_t directiveSubtypeCode);
 
-  cfdp::AckTransactionStatus getTransactionStatus() const;
+  [[nodiscard]] cfdp::AckTransactionStatus getTransactionStatus() const;
   void setTransactionStatus(cfdp::AckTransactionStatus transactionStatus);
 
  private:

src/fsfw/cfdp/pdu/AckPduDeserializer.h

@@ -13,7 +13,7 @@ class AckPduDeserializer : public FileDirectiveDeserializer {
    * @return
    *  - cfdp::INVALID_DIRECTIVE_FIELDS: Invalid fields
    */
-  ReturnValue_t parseData();
+  ReturnValue_t parseData() override;
 
  private:
   bool checkAndSetCodes(uint8_t rawAckedByte, uint8_t rawAckedConditionCode);

src/fsfw/cfdp/pdu/AckPduSerializer.h

@@ -18,7 +18,7 @@ class AckPduSerializer : public FileDirectiveSerializer {
    */
   AckPduSerializer(AckInfo& ackInfo, PduConfig& pduConf);
 
-  size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;

src/fsfw/container/SimpleRingBuffer.cpp

@@ -2,9 +2,6 @@
 
 #include <cstring>
 
-#include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"
-
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld, size_t maxExcessBytes)
     : RingBufferBase<>(0, size, overwriteOld), maxExcessBytes(maxExcessBytes) {
   if (maxExcessBytes > size) {
@@ -51,19 +48,6 @@ void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data, size_t amount) {
-  if (data == nullptr) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  if (amount > getMaxSize()) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "SimpleRingBuffer::writeData: Amount of data too large" << std::endl;
-#else
-    sif::printError("SimpleRingBuffer::writeData: Amount of data too large\n");
-#endif
-#endif
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
   if (availableWriteSpace() >= amount or overwriteOld) {
     size_t amountTillWrap = writeTillWrap();
     if (amountTillWrap >= amount) {

src/fsfw/controller/ControllerBase.cpp

@@ -13,9 +13,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
       submode(SUBMODE_NONE),
       modeHelper(this),
       healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
+  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }