tweak changelog

Reviewed-on: eive/fsfw#102
Reviewed-by: Jakob Meier <meierj@irs.uni-stuttgart.de>

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
 
@@ -23,9 +23,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   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 +40,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
 
@@ -91,6 +85,7 @@ PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 
 ### Time
 
@@ -120,8 +115,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,7 +134,6 @@ 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

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"
-       OFF)
+option(FSFW_BUILD_UNITTESTS
+       "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()
 
@@ -140,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"
@@ -163,9 +162,10 @@ if(FSFW_BUILD_TESTS)
     list(APPEND FSFW_FETCH_CONTENT_TARGETS Catch2)
   endif()
 
-  set(FSFW_CONFIG_PATH unittests/testcfg)
-  configure_file(unittests/testcfg/FSFWConfig.h.in FSFWConfig.h)
-  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+  set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+  configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.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})
@@ -183,7 +183,10 @@ if(FSFW_BUILD_TESTS)
   endif()
 endif()
 
-message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
+message(
+  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} QUIET)
@@ -191,7 +194,7 @@ find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     STATUS
-      "No ETL installation was found with find_package. Installing and providing "
+      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
       "etl with FindPackage")
   include(FetchContent)
 
@@ -281,15 +284,16 @@ message(
 )
 
 add_subdirectory(src)
-add_subdirectory(contrib)
-if(FSFW_BUILD_TESTS)
-  add_subdirectory(unittests)
+add_subdirectory(tests)
+if(FSFW_ADD_HAL)
+  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)
@@ -446,8 +450,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} PUBLIC ${FSFW_ETL_LINK_TARGET})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
+                                               ${FSFW_ADDITIONAL_LINK_LIBS})
 
 string(
   CONCAT

README.md

@@ -139,7 +139,7 @@ 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:
-````sh
-sudo pip install cmakelang
-````
+can run the `apply-clang-format.sh` helper script to format all source files consistently.
 
 ## 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 ..'
                 }
             }
         }

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/CMakeLists.txt

@@ -2,9 +2,9 @@ add_subdirectory(devicehandlers)
 add_subdirectory(common)
 
 if(UNIX)
-  add_subdirectory(linux)
+    add_subdirectory(linux)
 endif()
 
 if(FSFW_HAL_ADD_STM32H7)
-  add_subdirectory(stm32h7)
+    add_subdirectory(stm32h7)
 endif()

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 pointer.
+   * @param gpioState State of GPIO will be written to this reference
    */
-  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& 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, NONE = 99 };
+enum class Levels : int { LOW = 0, HIGH = 1, FAILED = -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,6 +252,7 @@ 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

@@ -375,13 +375,16 @@ 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) {
+  switch (commandData[0]) {
     case (MGMLIS3MDL::ON): {
       commandBuffer[1] = registers[0] | (1 << 7);
       break;
@@ -472,6 +475,7 @@ 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/MgmRM3100Handler.cpp

@@ -312,6 +312,7 @@ 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;
 }
 

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,6 +32,8 @@ 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;
@@ -205,3 +207,5 @@ 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,6 +109,8 @@ 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(std::string device, int* fileDescriptor, int flags,
+UnixFileGuard::UnixFileGuard(const 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(std::string device, int* fileDescriptor, int flags,
+  UnixFileGuard(const 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/Gpio.h

@@ -0,0 +1,27 @@
+#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
+#define FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_
+
+#include "fsfw_hal/common/gpio/GpioIF.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
+
+/**
+ * @brief   Additional abstraction layer for handling GPIOs.
+ *
+ * @author  J. Meier
+ */
+class Gpio {
+ public:
+  Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
+    if (gpioIF == nullptr) {
+      sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
+    }
+  }
+  ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); }
+  ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); }
+
+ private:
+  gpioId_t gpioId = gpio::NO_GPIO;
+  GpioIF* gpioIF = nullptr;
+};
+
+#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_GPIO_GPIO_H_ */

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, int* gpioState) {
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
   gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -313,7 +313,10 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
     if (regularGpio == nullptr) {
       return GPIO_TYPE_FAILURE;
     }
-    *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
+    gpioState = static_cast<gpio::Levels>(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,14 +31,16 @@ 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, int* gpioState) override;
+  ReturnValue_t readGpio(gpioId_t gpioId, gpio::Levels& 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,18 +170,20 @@ 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 and FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-               << "device failed with error code " << errno << ". Description"
-               << " of error: " << strerror(errno) << std::endl;
-    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
-               << " bytes" << std::endl;
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if (readLen < 0) {
+      sif::warning << "I2cComIF::requestReceiveMessage: Reading from I2C "
+                   << "device failed with error code " << errno << " | " << strerror(errno)
+                   << 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/ManualCsLockGuard.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "fsfw/ipc/MutexIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw_hal/common/gpio/GpioIF.h"
+
+class ManualCsLockWrapper : public HasReturnvaluesIF {
+ public:
+  ManualCsLockWrapper(MutexIF* lock, GpioIF* gpioIF, SpiCookie* cookie,
+                      MutexIF::TimeoutType type = MutexIF::TimeoutType::BLOCKING,
+                      uint32_t timeoutMs = 0)
+      : lock(lock), gpioIF(gpioIF), cookie(cookie), type(type), timeoutMs(timeoutMs) {
+    if (cookie == nullptr) {
+      // TODO: Error? Or maybe throw exception..
+      return;
+    }
+    cookie->setCsLockManual(true);
+    lockResult = lock->lockMutex(type, timeoutMs);
+    if (lockResult != RETURN_OK) {
+      return;
+    }
+    gpioResult = gpioIF->pullLow(cookie->getChipSelectPin());
+  }
+
+  ~ManualCsLockWrapper() {
+    if (gpioResult == RETURN_OK) {
+      gpioIF->pullHigh(cookie->getChipSelectPin());
+    }
+    cookie->setCsLockManual(false);
+    if (lockResult == RETURN_OK) {
+      lock->unlockMutex();
+    }
+  }
+  ReturnValue_t lockResult;
+  ReturnValue_t gpioResult;
+
+ private:
+  MutexIF* lock;
+  GpioIF* gpioIF;
+  SpiCookie* cookie;
+  MutexIF::TimeoutType type;
+  uint32_t timeoutMs = 0;
+};

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, GpioIF* gpioComIF)
-    : SystemObject(objectId), gpioComIF(gpioComIF) {
+SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
+    : SystemObject(objectId), gpioComIF(gpioComIF), dev(std::move(devname)) {
   if (gpioComIF == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -27,7 +27,7 @@ SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
   }
 
-  spiMutex = MutexFactory::instance()->createMutex();
+  csMutex = MutexFactory::instance()->createMutex();
 }
 
 ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
@@ -85,8 +85,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
 
   int fileDescriptor = 0;
-  UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
-                           "SpiComIF::initializeInterface");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::initializeInterface");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return fileHelper.getOpenResult();
   }
@@ -182,8 +181,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   int retval = 0;
   /* Prepare transfer */
   int fileDescriptor = 0;
-  std::string device = spiCookie->getSpiDevice();
-  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -196,20 +194,27 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 
   bool fullDuplex = spiCookie->isFullDuplex();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
+  bool csLockManual = spiCookie->getCsLockManual();
 
-  /* Pull SPI CS low. For now, no support for active high given  */
-  if (gpioId != gpio::NO_GPIO) {
-    result = spiMutex->lockMutex(timeoutType, timeoutMs);
+  MutexIF::TimeoutType csType;
+  dur_millis_t csTimeout = 0;
+  // Pull SPI CS low. For now, no support for active high given
+  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" << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+                 << "0x" << std::hex << std::setfill('0') << std::setw(4) << result << std::dec
+                 << std::endl;
 #else
-      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex with code %d\n", result);
 #endif
 #endif
       return result;
     }
+    updateLinePolarity(fileDescriptor);
     result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -221,6 +226,8 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 #endif
       return result;
     }
+  } else {
+    updateLinePolarity(fileDescriptor);
   }
 
   /* Execute transfer */
@@ -248,9 +255,9 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     }
   }
 
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
     gpioComIF->pullHigh(gpioId);
-    result = spiMutex->unlockMutex();
+    result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
@@ -278,9 +285,8 @@ 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(device, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
+  UnixFileGuard fileHelper(dev, &fileDescriptor, O_RDWR, "SpiComIF::requestReceiveMessage");
   if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
     return OPENING_FILE_FAILED;
   }
@@ -292,12 +298,22 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     return result;
   }
 
+  bool csLockManual = spiCookie->getCsLockManual();
   gpioId_t gpioId = spiCookie->getChipSelectPin();
-  if (gpioId != gpio::NO_GPIO) {
-    result = spiMutex->lockMutex(timeoutType, timeoutMs);
+  MutexIF::TimeoutType csType;
+  dur_millis_t csTimeout = 0;
+  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::getSendSuccess: Failed to lock mutex" << std::endl;
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex with code "
+                 << "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;
     }
@@ -315,9 +331,9 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     result = HALF_DUPLEX_TRANSFER_FAILED;
   }
 
-  if (gpioId != gpio::NO_GPIO) {
+  if (gpioId != gpio::NO_GPIO and not csLockManual) {
     gpioComIF->pullHigh(gpioId);
-    result = spiMutex->unlockMutex();
+    result = csMutex->unlockMutex();
     if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
@@ -346,15 +362,7 @@ ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
-  if (timeoutType != nullptr) {
-    *timeoutType = this->timeoutType;
-  }
-  if (timeoutMs != nullptr) {
-    *timeoutMs = this->timeoutMs;
-  }
-  return spiMutex;
-}
+MutexIF* SpiComIF::getCsMutex() { return csMutex; }
 
 void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
   if (spiCookie == nullptr) {
@@ -401,11 +409,27 @@ 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
-  // switch the state after the chip select is pulled low
+}
+
+void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const {
+  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;
-  retval = ioctl(spiFd, SPI_IOC_MESSAGE(1), &clockUpdateTransfer);
+  int 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 spiRetvalId = CLASS_ID::HAL_SPI;
+  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
   static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
 
-  SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
+  SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;
   ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -44,7 +44,8 @@ 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* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
+  MutexIF* getCsMutex();
+  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -59,6 +60,20 @@ 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);
@@ -70,10 +85,14 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   };
 
   GpioIF* gpioComIF = nullptr;
-
-  MutexIF* spiMutex = nullptr;
-  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  uint32_t timeoutMs = 20;
+  std::string dev = "";
+  /**
+   * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was
+   * pulled high
+   */
+  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,26 +1,25 @@
 #include "SpiCookie.h"
 
-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,
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
                      spi::SpiModes spiMode, uint32_t spiSpeed)
-    : SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {}
+    : SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, maxSize, spiMode, spiSpeed,
+                nullptr, nullptr) {}
 
-SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
-                     const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+SpiCookie::SpiCookie(address_t spiAddress, const size_t maxSize, spi::SpiModes spiMode,
+                     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, spiDev, maxSize, spiMode,
-                spiSpeed, callback, args) {}
+    : SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, 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)
+                     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),
@@ -50,8 +49,6 @@ 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; }
@@ -107,3 +104,17 @@ 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,6 +2,8 @@
 #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"
@@ -20,6 +22,8 @@
  */
 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
@@ -29,23 +33,22 @@ class SpiCookie : public CookieIF {
    * @param spiDev
    * @param maxSize
    */
-  SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
-            spi::SpiModes spiMode, uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, gpioId_t chipSelect, const size_t maxSize, 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, std::string spiDev, const size_t maxReplySize,
-            spi::SpiModes spiMode, uint32_t spiSpeed);
+  SpiCookie(address_t spiAddress, const size_t maxReplySize, 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, std::string spiDev, const size_t maxSize,
-            spi::SpiModes spiMode, uint32_t spiSpeed, spi::send_callback_function_t callback,
-            void* args);
+  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);
 
   /**
    * Get the callback function
@@ -55,7 +58,6 @@ 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;
 
@@ -139,9 +141,42 @@ 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
@@ -154,27 +189,8 @@ class SpiCookie : public CookieIF {
    * @param args
    */
   SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
-            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            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, UartModes uartMode,
-                       UartBaudRate baudrate, size_t maxReplyLen)
+UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+                       size_t maxReplyLen, UartModes uartMode)
     : 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, UartModes uartMode,
-             UartBaudRate baudrate, size_t maxReplyLen);
+  UartCookie(object_id_t handlerId, std::string deviceFile, UartBaudRate baudrate,
+             size_t maxReplyLen, UartModes uartMode = UartModes::NON_CANONICAL);
 
   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,6 +3,12 @@ if [[ ! -f README.md ]]; then
   cd ..
 fi
 
+folder_list=(
+  "./src"
+  "./hal"
+  "./tests"
+)
+
 cmake_fmt="cmake-format"
 file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
@@ -15,8 +21,10 @@ 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
-  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./unittests ${file_selectors} | xargs ${cpp_format} --style=file -i
+  for dir in ${folder_list[@]}; do
+    echo "Auto-formatting ${dir} recursively"
+    find ${dir} ${file_selectors} | xargs clang-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:
-        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)
+    cmd_runner("cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..")
     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/ActionHelper.cpp

@@ -6,7 +6,7 @@
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : owner(setOwner), queueToUse(useThisQueue) {}
 
-ActionHelper::~ActionHelper() = default;
+ActionHelper::~ActionHelper() {}
 
 ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
   if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
@@ -59,7 +59,7 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
-  const uint8_t* dataPtr = nullptr;
+  const uint8_t* dataPtr = NULL;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/ActionHelper.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_
 
+#include "../ipc/MessageQueueIF.h"
+#include "../serialize/SerializeIF.h"
 #include "ActionMessage.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/serialize/SerializeIF.h"
 /**
  * @brief Action Helper is a helper class which handles action messages
  *

src/fsfw/action/ActionMessage.cpp

@@ -2,9 +2,9 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 
-ActionMessage::ActionMessage() = default;
+ActionMessage::ActionMessage() {}
 
-ActionMessage::~ActionMessage() = default;
+ActionMessage::~ActionMessage() {}
 
 void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
                                store_address_t parameters) {
@@ -64,8 +64,9 @@ void ActionMessage::clear(CommandMessage* message) {
   switch (message->getCommand()) {
     case EXECUTE_ACTION:
     case DATA_REPLY: {
-      auto* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-      if (ipcStore != nullptr) {
+      StorageManagerIF* ipcStore =
+          ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+      if (ipcStore != NULL) {
         ipcStore->deleteData(getStoreId(message));
       }
       break;

src/fsfw/action/CommandActionHelper.cpp

@@ -2,14 +2,14 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner)
-    : owner(setOwner), queueToUse(nullptr), ipcStore(nullptr), commandCount(0), lastTarget(0) {}
+    : owner(setOwner), queueToUse(NULL), ipcStore(NULL), commandCount(0), lastTarget(0) {}
 
-CommandActionHelper::~CommandActionHelper() = default;
+CommandActionHelper::~CommandActionHelper() {}
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  SerializeIF *data) {
-  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == nullptr) {
+  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == NULL) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -29,8 +29,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo, ActionId_t actionId,
                                                  const uint8_t *data, uint32_t size) {
-  auto *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
-  if (receiver == nullptr) {
+  //    if (commandCount != 0) {
+  //        return CommandsFunctionsIF::ALREADY_COMMANDING;
+  //    }
+  HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+  if (receiver == NULL) {
     return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
   }
   store_address_t storeId;
@@ -56,12 +59,12 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId, ActionI
 
 ReturnValue_t CommandActionHelper::initialize() {
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == nullptr) {
+  if (ipcStore == NULL) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   queueToUse = owner->getCommandQueuePtr();
-  if (queueToUse == nullptr) {
+  if (queueToUse == NULL) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -101,7 +104,7 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
 uint8_t CommandActionHelper::getCommandCount() const { return commandCount; }
 
 void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-  const uint8_t *data = nullptr;
+  const uint8_t *data = NULL;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/CommandActionHelper.h

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

src/fsfw/action/CommandsActionsIF.h

@@ -1,9 +1,9 @@
 #ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
 #define FSFW_ACTION_COMMANDSACTIONSIF_H_
 
+#include "../ipc/MessageQueueIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "CommandActionHelper.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * Interface to separate commanding actions of other objects.
@@ -21,7 +21,7 @@ class CommandsActionsIF {
   static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
   static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
   static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-  virtual ~CommandsActionsIF() = default;
+  virtual ~CommandsActionsIF() {}
   virtual MessageQueueIF* getCommandQueuePtr() = 0;
 
  protected:

src/fsfw/action/HasActionsIF.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_ACTION_HASACTIONSIF_H_
 #define FSFW_ACTION_HASACTIONSIF_H_
 
+#include "../ipc/MessageQueueIF.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
 #include "ActionHelper.h"
 #include "ActionMessage.h"
 #include "SimpleActionHelper.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief
@@ -40,12 +40,12 @@ class HasActionsIF {
   static const ReturnValue_t INVALID_PARAMETERS = MAKE_RETURN_CODE(2);
   static const ReturnValue_t EXECUTION_FINISHED = MAKE_RETURN_CODE(3);
   static const ReturnValue_t INVALID_ACTION_ID = MAKE_RETURN_CODE(4);
-  virtual ~HasActionsIF() = default;
+  virtual ~HasActionsIF() {}
   /**
    * Function to get the MessageQueueId_t of the implementing object
    * @return MessageQueueId_t of the object
    */
-  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
+  virtual MessageQueueId_t getCommandQueue() const = 0;
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently

src/fsfw/action/SimpleActionHelper.cpp

@@ -3,7 +3,7 @@
 SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : ActionHelper(setOwner, useThisQueue), isExecuting(false) {}
 
-SimpleActionHelper::~SimpleActionHelper() = default;
+SimpleActionHelper::~SimpleActionHelper() {}
 
 void SimpleActionHelper::step(ReturnValue_t result) {
   // STEP_OFFESET is subtracted to compensate for adding offset in base
@@ -38,7 +38,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
     ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::IS_BUSY);
     queueToUse->sendMessage(commandedBy, &reply);
   }
-  const uint8_t* dataPtr = nullptr;
+  const uint8_t* dataPtr = NULL;
   size_t size = 0;
   ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
   if (result != HasReturnvaluesIF::RETURN_OK) {

src/fsfw/action/SimpleActionHelper.h

@@ -11,15 +11,15 @@
 class SimpleActionHelper : public ActionHelper {
  public:
   SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-  ~SimpleActionHelper() override;
+  virtual ~SimpleActionHelper();
   void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
   ReturnValue_t reportData(SerializeIF* data);
 
  protected:
   void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-                        store_address_t dataAddress) override;
-  void resetHelper() override;
+                        store_address_t dataAddress);
+  virtual void resetHelper();
 
  private:
   bool isExecuting;
@@ -28,4 +28,4 @@ class SimpleActionHelper : public ActionHelper {
   uint8_t stepCount = 0;
 };
 
-#endif /* FSFW_ACTION_SIMPLEACTIONHELPER_H_ */
+#endif /* SIMPLEACTIONHELPER_H_ */