Merge branch 'mueller/tc-packet-pus-improvement' into develop

Reviewed-on: fsfw/fsfw#643

CHANGELOG.md

@@ -12,6 +12,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changes
 
+- Renamed auto-formatting script to `auto-formatter.sh` and made it more robust.
+  If `cmake-format` is installed, it will also auto-format the `CMakeLists.txt` files now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/626
 - 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
@@ -43,6 +47,38 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
 
+### Task Module Refactoring
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/636
+
+**Refactoring general task code**
+
+- There was a lot of duplicate/boilerplate code inside the individual task IF OSAL implementations.
+  Remove it by introducing base classes `PeriodicTaskBase` and `FixedTimeslotTaskBase`.
+
+**Refactor PeriodicTaskIF**
+
+- Convert `virtual ReturnValue_t addComponent(object_id_t object)` to
+  `virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0)`, allowing to pass
+  the operation code passed to `performOperation`. Updated API taking
+  an `ExecutableObjectIF` accordingly
+
+**Refactor FixedTimeslotTaskIF**
+
+- Add additional `addSlot` function which takes an `ExecutableObjectIF` pointer and its Object ID
+
+**Refactor FixedSequenceSlot**
+
+- Introduce typedef `CustomCheckFunc` for `ReturnValue_t (*customCheckFunction)(const SlotList&)`.
+- Convert `ReturnValue_t (*customCheckFunction)(const SlotList&)` to
+  `ReturnValue_t (*customCheckFunction)(const SlotList&, void*)`, allowing arbitrary user arguments
+  for the custom checker
+
+**Linux Task Module**
+
+- Use composition instead of inheritance for the `PeriodicPosixTask` and make the `PosixTask` a
+  member of the class
+
 ### HAL
 
 - HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
@@ -84,6 +120,11 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
 
 ## Additions
 
+- 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
+- Basic `clion` support: Update `.gitignore` and add some basic run configurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/625
 - LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
   the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
   can make good use of it and it usually makes the code faster and/or smaller.

CMakeLists.txt

@@ -67,13 +67,13 @@ 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")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
     CACHE STRING "ETL library exact version requirement")
+set(FSFW_ETL_LINK_TARGET etl::etl)
 
 set(FSFW_CATCH2_LIB_MAJOR_VERSION
     3
@@ -82,15 +82,6 @@ set(FSFW_CATCH2_LIB_VERSION
     v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5
     CACHE STRING "Catch2 library exact version requirement")
 
-set(FSFW_FMT_LIB_NAME fmt)
-set(FSFW_FMT_LINK_TARGET fmt::fmt)
-set(FSFW_FMT_LIB_MAJOR_VERSION
-    8
-    CACHE STRING "{fmt} library major version requirement")
-set(FSFW_FMT_LIB_VERSION
-    ${FSFW_FMT_LIB_MAJOR_VERSION}.1.1
-    CACHE STRING "{fmt} library exact version requirement")
-
 # Keep this off by default for now. See PR:
 # https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616 for information which
 # keeping this on by default is problematic
@@ -114,6 +105,7 @@ endif()
 
 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_UNITTESTS)
   option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
@@ -177,11 +169,11 @@ if(FSFW_BUILD_UNITTESTS)
 
   project(${FSFW_TEST_TGT} CXX C)
   add_executable(${FSFW_TEST_TGT})
-
   if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
     set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
                                                   TRUE)
   endif()
+
   if(FSFW_TESTS_GEN_COV)
     message(STATUS "${MSG_PREFIX} Generating coverage data for the library")
     message(STATUS "${MSG_PREFIX} Targets linking against ${LIB_FSFW_NAME} "
@@ -191,7 +183,7 @@ if(FSFW_BUILD_UNITTESTS)
   endif()
 endif()
 
-message(STATUS "${MSG_PREFIX} Finding and/or etl (Embedded Template Library)")
+message(STATUS "${MSG_PREFIX} Finding and/or providing ETL library")
 
 # Check whether the user has already installed ETL first
 find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
@@ -211,26 +203,6 @@ if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_ETL_LIB_NAME})
 endif()
 
-message(STATUS "Finding and/or providing {fmt} formatting library")
-
-# Check whether the user has already installed ETL first
-find_package(fmt ${FSFW_FMT_LIB_MAJOR_VERSION} QUIET)
-# Not installed, so use FetchContent to download and provide etl
-if(NOT ${FSFW_FMT_LIB_NAME}_FOUND)
-  message(
-    STATUS
-      "No {fmt} installation was found with find_package. Installing and providing "
-      "{fmt} with FindPackage")
-  include(FetchContent)
-
-  FetchContent_Declare(
-    ${FSFW_FMT_LIB_NAME}
-    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
-    GIT_TAG ${FSFW_FMT_LIB_VERSION})
-
-  list(APPEND FSFW_FETCH_CONTENT_TARGETS ${FSFW_FMT_LIB_NAME})
-endif()
-
 # The documentation for FetchContent recommends declaring all the dependencies
 # before making them available. We make all declared dependency available here
 # after their declaration
@@ -240,7 +212,7 @@ if(FSFW_FETCH_CONTENT_TARGETS)
     add_library(${FSFW_ETL_LINK_TARGET} ALIAS ${FSFW_ETL_LIB_NAME})
   endif()
   if(TARGET Catch2)
-    # Fixes regression -preview4, to be confirmed in later releases. Related
+    # Fixes regression -preview4, to be confirmed in later releases Related
     # GitHub issue: https://github.com/catchorg/Catch2/issues/2417
     set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
   endif()
@@ -475,13 +447,8 @@ target_include_directories(
 target_compile_options(${LIB_FSFW_NAME} PRIVATE ${FSFW_WARNING_FLAGS}
                                                 ${COMPILER_FLAGS})
 
-target_link_libraries(${LIB_FSFW_NAME} PUBLIC ${FSFW_FMT_LINK_TARGET})
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${FSFW_ETL_LINK_TARGET}
-
+                                               ${FSFW_ADDITIONAL_LINK_LIBS})
-target_link_libraries(
-  ${LIB_FSFW_NAME}
-  PRIVATE # If any ELT headers are ever exposed inside a header or as part of
-          # the API, the ETL target needs to be linked PUBLIC
-          ${FSFW_ETL_LINK_TARGET} ${FSFW_ADDITIONAL_LINK_LIBS})
 
 string(
   CONCAT
@@ -491,13 +458,6 @@ string(
     "Target OSAL: ${FSFW_OS_NAME}\n"
     "######################################################################\n")
 
-# The additional / is important to remove the last character from the path. Note
-# that it does not matter if the OS uses / or \, because we are only saving the
-# path size.
-string(LENGTH "${CMAKE_SOURCE_DIR}/" FSFW_SOURCE_PATH_SIZE)
-target_compile_definitions(
-  ${LIB_FSFW_NAME} PRIVATE "-DFSFW_SOURCE_PATH_SIZE=${FSFW_SOURCE_PATH_SIZE}")
-
 add_custom_command(
   TARGET ${LIB_FSFW_NAME}
   POST_BUILD

README.md

@@ -99,7 +99,7 @@ add and link against the FSFW library in general.
 
 4. Link against the FSFW library
 
-   ```cmake
+   ```sh
    target_link_libraries(${YourProjectName} PRIVATE fsfw)
    ```
 
@@ -131,7 +131,7 @@ default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF
 You can use the following commands inside the `fsfw` folder to set up the build system
 
 ```sh
-mkdir build-Unittest && cd build-Unittest
+mkdir build-tests && cd build-tests
 cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 ```
 

automation/Jenkinsfile

@@ -14,7 +14,7 @@ pipeline {
         stage('Configure') {
             steps {
                 dir(BUILDDIR) {
-                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..'
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON -DFSFW_CICD_BUILD=ON ..'
                 }
             }
         }

hal/src/fsfw_hal/common/gpio/GpioCookie.cpp

@@ -1,19 +1,30 @@
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
-GpioCookie::GpioCookie() = default;
+GpioCookie::GpioCookie() {}
 
 ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
   if (gpioConfig == nullptr) {
-    FSFW_LOGW("addGpio: gpioConfig is nullpointer\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "GpioCookie::addGpio: gpioConfig is nullpointer" << std::endl;
+#else
+    sif::printWarning("GpioCookie::addGpio: gpioConfig is nullpointer\n");
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   auto gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
     auto statusPair = gpioMap.emplace(gpioId, gpioConfig);
-    if (!statusPair.second) {
+    if (statusPair.second == false) {
-      FSFW_LOGW("addGpio: Failed to add GPIO {} to GPIO map\n", gpioId);
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "GpioCookie::addGpio: Failed to add GPIO " << gpioId << " to GPIO map"
+                   << std::endl;
+#else
+      sif::printWarning("GpioCookie::addGpio: Failed to add GPIO %d to GPIO map\n", gpioId);
+#endif
+#endif
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -60,8 +60,16 @@ ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t
       return buildCommandFromCommand(*id, nullptr, 0);
     }
     default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       /* Might be a configuration error. */
-      FSFW_LOGW("buildTransitionDeviceCommand: Unknown internal state\n");
+      sif::warning << "GyroL3GD20Handler::buildTransitionDeviceCommand: "
+                      "Unknown internal state!"
+                   << std::endl;
+#else
+      sif::printDebug(
+          "GyroL3GD20Handler::buildTransitionDeviceCommand: "
+          "Unknown internal state!\n");
+#endif
       return HasReturnvaluesIF::RETURN_OK;
   }
   return HasReturnvaluesIF::RETURN_OK;
@@ -184,8 +192,17 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
       if (periodicPrintout) {
         if (debugDivider.checkAndIncrement()) {
           /* Set terminal to utf-8 if there is an issue with micro printout. */
-          FSFW_LOGI("GyroHandlerL3GD20H: Angular velocities (deg/s):\nX {} | Y {} | Z {}\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                    angVelocX, angVelocY, angVelocZ);
+          sif::info << "GyroHandlerL3GD20H: Angular velocities (deg/s):" << std::endl;
+          sif::info << "X: " << angVelocX << std::endl;
+          sif::info << "Y: " << angVelocY << std::endl;
+          sif::info << "Z: " << angVelocZ << std::endl;
+#else
+          sif::printInfo("GyroHandlerL3GD20H: Angular velocities (deg/s):\n");
+          sif::printInfo("X: %f\n", angVelocX);
+          sif::printInfo("Y: %f\n", angVelocY);
+          sif::printInfo("Z: %f\n", angVelocZ);
+#endif
         }
       }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -76,16 +76,21 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(DeviceCommandId_t
     }
     default: {
       /* might be a configuration error. */
-      FSFW_LOGW("buildTransitionDeviceCommand: Unknown internal state\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "GyroHandler::buildTransitionDeviceCommand: Unknown internal state!"
+                   << std::endl;
+#else
+      sif::printWarning("GyroHandler::buildTransitionDeviceCommand: Unknown internal state!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
       return HasReturnvaluesIF::RETURN_OK;
     }
   }
-  return buildCommandFromCommand(*id, nullptr, 0);
+  return buildCommandFromCommand(*id, NULL, 0);
 }
 
 uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
   command |= (1 << MGMLIS3MDL::RW_BIT);
-  if (continuousCom) {
+  if (continuousCom == true) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -93,7 +98,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) {
+  if (continuousCom == true) {
     command |= (1 << MGMLIS3MDL::MS_BIT);
   }
   return command;
@@ -181,7 +186,13 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
     // Check validity by checking config registers
     if (start[1] != registers[0] or start[2] != registers[1] or start[3] != registers[2] or
         start[4] != registers[3] or start[5] != registers[4]) {
-      FSFW_LOGW("scanForReply: Invalid registers\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "MGMHandlerLIS3MDL::scanForReply: Invalid registers!" << std::endl;
+#else
+      sif::printWarning("MGMHandlerLIS3MDL::scanForReply: Invalid registers!\n");
+#endif
+#endif
       return DeviceHandlerIF::INVALID_DATA;
     }
     if (mode == _MODE_START_UP) {
@@ -199,9 +210,17 @@ ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start, size_t len,
     *foundId = getPendingCommand();
     if (*foundId == MGMLIS3MDL::IDENTIFY_DEVICE) {
       if (start[1] != MGMLIS3MDL::DEVICE_ID) {
-        FSFW_LOGW(
+#if FSFW_VERBOSE_LEVEL >= 1
-            "scanForReply: Device identification failed, found ID {} not equal to expected {}\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-            start[1], MGMLIS3MDL::DEVICE_ID);
+        sif::warning << "MGMHandlerLIS3MDL::scanForReply: "
+                        "Device identification failed!"
+                     << std::endl;
+#else
+        sif::printWarning(
+            "MGMHandlerLIS3MDL::scanForReply: "
+            "Device identification failed!\n");
+#endif
+#endif
         return DeviceHandlerIF::INVALID_DATA;
       }
 
@@ -249,10 +268,19 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
 
       if (periodicPrintout) {
         if (debugDivider.checkAndIncrement()) {
-          FSFW_LOGI(
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              "MGMHandlerLIS3: Magnetic field strength in"
+          sif::info << "MGMHandlerLIS3: Magnetic field strength in"
-              " microtesla (uT):\nX {} | Y {} | Z {}\n",
+                       " microtesla:"
-              mgmX, mgmY, mgmZ);
+                    << std::endl;
+          sif::info << "X: " << mgmX << " uT" << std::endl;
+          sif::info << "Y: " << mgmY << " uT" << std::endl;
+          sif::info << "Z: " << mgmZ << " uT" << std::endl;
+#else
+          sif::printInfo("MGMHandlerLIS3: Magnetic field strength in microtesla:\n");
+          sif::printInfo("X: %f uT\n", mgmX);
+          sif::printInfo("Y: %f uT\n", mgmY);
+          sif::printInfo("Z: %f uT\n", mgmZ);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 0 */
         }
       }
 
@@ -283,11 +311,15 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
     }
 
     case MGMLIS3MDL::READ_TEMPERATURE: {
-      auto tempValueRaw = static_cast<int16_t>((packet[2] << 8) | packet[1]);
+      int16_t tempValueRaw = packet[2] << 8 | packet[1];
       float tempValue = 25.0 + ((static_cast<float>(tempValueRaw)) / 8.0);
       if (periodicPrintout) {
         if (debugDivider.check()) {
-          FSFW_LOGI("MGMHandlerLIS3: Temperature: {} C\n", tempValue);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::info << "MGMHandlerLIS3: Temperature: " << tempValue << " C" << std::endl;
+#else
+          sif::printInfo("MGMHandlerLIS3: Temperature: %f C\n");
+#endif
         }
       }
 

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -81,8 +81,18 @@ ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(DeviceCommandId_t *
       break;
     }
     default:
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       // Might be a configuration error
-      FSFW_LOGW("buildTransitionDeviceCommand: Unknown internal state\n");
+      sif::warning << "MgmRM3100Handler::buildTransitionDeviceCommand: "
+                      "Unknown internal state"
+                   << std::endl;
+#else
+      sif::printWarning(
+          "MgmRM3100Handler::buildTransitionDeviceCommand: "
+          "Unknown internal state\n");
+#endif
+#endif
       return HasReturnvaluesIF::RETURN_OK;
   }
 
@@ -325,10 +335,19 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
 
   if (periodicPrintout) {
     if (debugDivider.checkAndIncrement()) {
-      FSFW_LOGI(
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-          "MgmRM3100Handler: Magnetic field strength in"
+      sif::info << "MgmRM3100Handler: Magnetic field strength in"
-          " microtesla(uT)\nX {} | Y {} | Z {}\n",
+                   " microtesla:"
-          fieldStrengthX, fieldStrengthY, fieldStrengthZ);
+                << std::endl;
+      sif::info << "X: " << fieldStrengthX << " uT" << std::endl;
+      sif::info << "Y: " << fieldStrengthY << " uT" << std::endl;
+      sif::info << "Z: " << fieldStrengthZ << " uT" << std::endl;
+#else
+      sif::printInfo("MgmRM3100Handler: Magnetic field strength in microtesla:\n");
+      sif::printInfo("X: %f uT\n", fieldStrengthX);
+      sif::printInfo("Y: %f uT\n", fieldStrengthY);
+      sif::printInfo("Z: %f uT\n", fieldStrengthZ);
+#endif
     }
   }
 

hal/src/fsfw_hal/linux/CommandExecutor.cpp

@@ -59,16 +59,22 @@ ReturnValue_t CommandExecutor::close() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void CommandExecutor::printLastError(const std::string& funcName) const {
+void CommandExecutor::printLastError(std::string funcName) const {
   if (lastError != 0) {
-    FSFW_LOGW("{} | pclose failed with code {} | {}\n", funcName, lastError, strerror(lastError));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << funcName << " pclose failed with code " << lastError << ": "
+                 << strerror(lastError) << std::endl;
+#else
+    sif::printError("%s pclose failed with code %d: %s\n", funcName, lastError,
+                    strerror(lastError));
+#endif
   }
 }
 
-void CommandExecutor::setRingBuffer(SimpleRingBuffer* ringBuffer_,
+void CommandExecutor::setRingBuffer(SimpleRingBuffer* ringBuffer,
-                                    DynamicFIFO<uint16_t>* sizesFifo_) {
+                                    DynamicFIFO<uint16_t>* sizesFifo) {
-  this->ringBuffer = ringBuffer_;
+  this->ringBuffer = ringBuffer;
-  this->sizesFifo = sizesFifo_;
+  this->sizesFifo = sizesFifo;
 }
 
 ReturnValue_t CommandExecutor::check(bool& replyReceived) {
@@ -96,13 +102,23 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
         ssize_t readBytes = read(currentFd, readVec.data(), readVec.size());
         if (readBytes == 0) {
           // Should not happen
-          FSFW_LOGWT("CommandExecutor::check: No bytes read after poll event\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::warning << "CommandExecutor::check: No bytes read "
+                          "after poll event.."
+                       << std::endl;
+#else
+          sif::printWarning("CommandExecutor::check: No bytes read after poll event..\n");
+#endif
           break;
         } else if (readBytes > 0) {
           replyReceived = true;
           if (printOutput) {
             // It is assumed the command output is line terminated
-            FSFW_LOGIT("{} | {}", currentCmd, readVec.data());
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::info << currentCmd << " | " << readVec.data();
+#else
+            sif::printInfo("%s | %s", currentCmd, readVec.data());
+#endif
           }
           if (ringBuffer != nullptr) {
             ringBuffer->writeData(reinterpret_cast<const uint8_t*>(readVec.data()), readBytes);
@@ -114,11 +130,20 @@ ReturnValue_t CommandExecutor::check(bool& replyReceived) {
           }
         } else {
           // Should also not happen
-          FSFW_LOGW("check: Error {} | {}\n", errno, strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+          sif::warning << "CommandExecutor::check: Error " << errno << ": " << strerror(errno)
+                       << std::endl;
+#else
+          sif::printWarning("CommandExecutor::check: Error %d: %s\n", errno, strerror(errno));
+#endif
         }
       }
       if (waiter.revents & POLLERR) {
-        FSFW_LOGW("check: Poll error\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "CommandExecuter::check: Poll error" << std::endl;
+#else
+        sif::printWarning("CommandExecuter::check: Poll error\n");
+#endif
         return COMMAND_ERROR;
       }
       if (waiter.revents & POLLHUP) {
@@ -158,7 +183,11 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   while (fgets(readVec.data(), readVec.size(), currentCmdFile) != nullptr) {
     std::string output(readVec.data());
     if (printOutput) {
-      FSFW_LOGI("{} | {}", currentCmd, output);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << currentCmd << " | " << output;
+#else
+      sif::printInfo("%s | %s", currentCmd, output);
+#endif
     }
     if (ringBuffer != nullptr) {
       ringBuffer->writeData(reinterpret_cast<const uint8_t*>(output.data()), output.size());

hal/src/fsfw_hal/linux/CommandExecutor.h

@@ -93,7 +93,7 @@ class CommandExecutor {
 
   States getCurrentState() const;
   int getLastError() const;
-  void printLastError(const std::string& funcName) const;
+  void printLastError(std::string funcName) const;
 
   /**
    * Assign a ring buffer and a FIFO which will be filled by the executor with the output

hal/src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -14,8 +14,15 @@ UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
   }
   *fileDescriptor = open(device.c_str(), flags);
   if (*fileDescriptor < 0) {
-    FSFW_LOGW("{} | Opening device failed with error code {} | {}\n", diagnosticPrefix, errno,
+#if FSFW_VERBOSE_LEVEL >= 1
-              strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << diagnosticPrefix << ": Opening device failed with error code " << errno << ": "
+                 << strerror(errno) << std::endl;
+#else
+    sif::printWarning("%s: Opening device failed with error code %d: %s\n", diagnosticPrefix, errno,
+                      strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     openStatus = OPEN_FILE_FAILED;
   }
 }

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

@@ -26,10 +26,19 @@ ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
   std::string deviceFile;
 
   if (cookie == nullptr) {
-    FSFW_LOGE("{}", "initializeInterface: Invalid cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
-  auto* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
+#endif
+    return NULLPOINTER;
+  }
+
   i2cAddress = i2cCookie->getAddress();
 
   i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
@@ -38,14 +47,20 @@ ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
     I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
     auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
     if (not statusPair.second) {
-      FSFW_LOGW("initializeInterface: Failed to insert device with address {} to I2C device map\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                i2cAddress);
+      sif::error << "I2cComIF::initializeInterface: Failed to insert device with address "
+                 << i2cAddress << "to I2C device "
+                 << "map" << std::endl;
+#endif
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
   }
 
-  FSFW_LOGE("initializeInterface: Device with address {} already in use\n", i2cAddress);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress
+             << "already in use" << std::endl;
+#endif
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
@@ -55,7 +70,9 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
   std::string deviceFile;
 
   if (sendData == nullptr) {
-    FSFW_LOGW("{}", "sendMessage: Send Data is nullptr\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Send Data is nullptr" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -63,16 +80,21 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
     return HasReturnvaluesIF::RETURN_OK;
   }
 
-  auto* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
   if (i2cCookie == nullptr) {
-    FSFW_LOGWT("{}", "sendMessage: Invalid I2C Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
   address_t i2cAddress = i2cCookie->getAddress();
   i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-    FSFW_LOGWT("{}", "sendMessage: I2C address of cookie not registered in I2C device map\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -87,8 +109,11 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
   }
 
   if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
-    FSFW_LOGE("sendMessage: Failed to send data to I2C device with error code {} | {}\n", errno,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              strerror(errno));
+    sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
+                  "device with error code "
+               << errno << ". Error description: " << strerror(errno) << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -110,9 +135,11 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
     return HasReturnvaluesIF::RETURN_OK;
   }
 
-  auto* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
   if (i2cCookie == nullptr) {
-    FSFW_LOGWT("{}", "requestReceiveMessage: Invalid I2C Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
+#endif
     i2cDeviceMapIter->second.replyLen = 0;
     return NULLPOINTER;
   }
@@ -120,8 +147,10 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
   address_t i2cAddress = i2cCookie->getAddress();
   i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-    FSFW_LOGW("requestReceiveMessage: I2C address {} of Cookie not registered in i2cDeviceMap",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              i2cAddress);
+    sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
+               << "registered in i2cDeviceMap" << std::endl;
+#endif
     i2cDeviceMapIter->second.replyLen = 0;
     return HasReturnvaluesIF::RETURN_FAILED;
   }
@@ -139,13 +168,20 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 
   uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
 
-  ssize_t readLen = read(fd, replyBuffer, requestLen);
+  int readLen = read(fd, replyBuffer, requestLen);
   if (readLen != static_cast<int>(requestLen)) {
-    FSFW_LOGWT(
+#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
-        "requestReceiveMessage: Reading from I2C device failed with error code "
+    sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
-        "{} | {}\nRead only {} from {} bytes\n",
+               << "device failed with error code " << errno << ". Description"
-        errno, strerror(errno), readLen, requestLen);
+               << " of error: " << strerror(errno) << std::endl;
+    sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from " << requestLen
+               << " bytes" << std::endl;
+#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;
   }
 
@@ -159,17 +195,21 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 }
 
 ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
-  auto* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
   if (i2cCookie == nullptr) {
-    FSFW_LOGW("{}", "readReceivedMessage: Invalid I2C Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
   address_t i2cAddress = i2cCookie->getAddress();
   i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
-    FSFW_LOGE("readReceivedMessage: I2C address {} of cookie not found in I2C device map\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              i2cAddress);
+    sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
+               << "found in i2cDeviceMap" << std::endl;
+#endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   *buffer = i2cDeviceMapIter->second.replyBuffer.data();
@@ -181,8 +221,16 @@ ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
 ReturnValue_t I2cComIF::openDevice(std::string deviceFile, address_t i2cAddress,
                                    int* fileDescriptor) {
   if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
-    FSFW_LOGWT("openDevice: Specifying target device failed with error code {} | {}\n", errno,
+#if FSFW_VERBOSE_LEVEL >= 1
-               strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
+                 << std::endl;
+    sif::warning << "Error description " << strerror(errno) << std::endl;
+#else
+    sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
+    sif::printWarning("Error description: %s\n", strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   return HasReturnvaluesIF::RETURN_OK;

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

@@ -11,7 +11,6 @@
 #include <cstring>
 
 #include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"
 #include "fsfw_hal/linux/UnixFileGuard.h"
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 #include "fsfw_hal/linux/utility.h"
@@ -19,7 +18,13 @@
 SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
     : SystemObject(objectId), gpioComIF(gpioComIF) {
   if (gpioComIF == nullptr) {
-    FSFW_LOGET("{}", "SpiComIF::SpiComIF: GPIO communication interface invalid\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "SpiComIF::SpiComIF: GPIO communication interface invalid!" << std::endl;
+#else
+    sif::printError("SpiComIF::SpiComIF: GPIO communication interface invalid!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
   }
 
   spiMutex = MutexFactory::instance()->createMutex();
@@ -27,7 +32,7 @@ SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF)
 
 ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   int retval = 0;
-  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
   if (spiCookie == nullptr) {
     return NULLPOINTER;
   }
@@ -40,17 +45,30 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
     SpiInstance spiInstance(bufferSize);
     auto statusPair = spiDeviceMap.emplace(spiAddress, spiInstance);
     if (not statusPair.second) {
-      FSFW_LOGWT(
+#if FSFW_VERBOSE_LEVEL >= 1
-          "SpiComIF::initializeInterface: Failed to insert device with address {} to SPI device "
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-          "map\n",
+      sif::error << "SpiComIF::initializeInterface: Failed to insert device with address "
-          spiAddress);
+                 << spiAddress << "to SPI device map" << std::endl;
+#else
+      sif::printError(
+          "SpiComIF::initializeInterface: Failed to insert device with address "
+          "%lu to SPI device map\n",
+          static_cast<unsigned long>(spiAddress));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     /* Now we emplaced the read buffer in the map, we still need to assign that location
     to the SPI driver transfer struct */
     spiCookie->assignReadBuffer(statusPair.first->second.replyBuffer.data());
   } else {
-    FSFW_LOGWT("{}", "initializeInterface: SPI address already exists\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "SpiComIF::initializeInterface: SPI address already exists!" << std::endl;
+#else
+    sif::printError("SpiComIF::initializeInterface: SPI address already exists!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -115,7 +133,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
 }
 
 ReturnValue_t SpiComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
-  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
   if (spiCookie == nullptr) {
@@ -123,9 +141,19 @@ ReturnValue_t SpiComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
   }
 
   if (sendLen > spiCookie->getMaxBufferSize()) {
-    FSFW_LOGW(
+#if FSFW_VERBOSE_LEVEL >= 1
-        "sendMessage: Too much data sent, send length {} larger than maximum buffer length {}\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-        spiCookie->getMaxBufferSize(), sendLen);
+    sif::warning << "SpiComIF::sendMessage: Too much data sent, send length " << sendLen
+                 << "larger than maximum buffer length " << spiCookie->getMaxBufferSize()
+                 << std::endl;
+#else
+    sif::printWarning(
+        "SpiComIF::sendMessage: Too much data sent, send length %lu larger "
+        "than maximum buffer length %lu!\n",
+        static_cast<unsigned long>(sendLen),
+        static_cast<unsigned long>(spiCookie->getMaxBufferSize()));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return DeviceCommunicationIF::TOO_MUCH_DATA;
   }
 
@@ -173,12 +201,24 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   if (gpioId != gpio::NO_GPIO) {
     result = spiMutex->lockMutex(timeoutType, timeoutMs);
     if (result != RETURN_OK) {
-      FSFW_LOGET("{}", "sendMessage: Failed to lock mutex\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
+#else
+      sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
+#endif
+#endif
       return result;
     }
     result = gpioComIF->pullLow(gpioId);
     if (result != HasReturnvaluesIF::RETURN_OK) {
-      FSFW_LOGW("{}", "sendMessage: Pulling low CS pin failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "SpiComIF::sendMessage: Pulling low CS pin failed" << std::endl;
+#else
+      sif::printWarning("SpiComIF::sendMessage: Pulling low CS pin failed");
+#endif
+#endif
       return result;
     }
   }
@@ -197,7 +237,13 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   } else {
     /* We write with a blocking half-duplex transfer here */
     if (write(fileDescriptor, sendData, sendLen) != static_cast<ssize_t>(sendLen)) {
-      FSFW_LOGET("{}", "sendMessage: Half-Duplex write operation failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "SpiComIF::sendMessage: Half-Duplex write operation failed!" << std::endl;
+#else
+      sif::printWarning("SpiComIF::sendMessage: Half-Duplex write operation failed!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
       result = HALF_DUPLEX_TRANSFER_FAILED;
     }
   }
@@ -206,7 +252,9 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
     gpioComIF->pullHigh(gpioId);
     result = spiMutex->unlockMutex();
     if (result != RETURN_OK) {
-      FSFW_LOGWT("{}", "sendMessage: Failed to unlock mutex\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
+#endif
       return result;
     }
   }
@@ -216,7 +264,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
 ReturnValue_t SpiComIF::getSendSuccess(CookieIF* cookie) { return HasReturnvaluesIF::RETURN_OK; }
 
 ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
-  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
   if (spiCookie == nullptr) {
     return NULLPOINTER;
   }
@@ -248,14 +296,22 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   if (gpioId != gpio::NO_GPIO) {
     result = spiMutex->lockMutex(timeoutType, timeoutMs);
     if (result != RETURN_OK) {
-      FSFW_LOGW("{}", "getSendSuccess: Failed to lock mutex\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
+#endif
       return result;
     }
     gpioComIF->pullLow(gpioId);
   }
 
   if (read(fileDescriptor, rxBuf, readSize) != static_cast<ssize_t>(readSize)) {
-    FSFW_LOGW("{}", "sendMessage: Half-Duplex read operation failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "SpiComIF::sendMessage: Half-Duplex read operation failed!" << std::endl;
+#else
+    sif::printWarning("SpiComIF::sendMessage: Half-Duplex read operation failed!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     result = HALF_DUPLEX_TRANSFER_FAILED;
   }
 
@@ -263,7 +319,9 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     gpioComIF->pullHigh(gpioId);
     result = spiMutex->unlockMutex();
     if (result != RETURN_OK) {
-      FSFW_LOGW("{}", "getSendSuccess: Failed to unlock mutex\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
+#endif
       return result;
     }
   }
@@ -272,7 +330,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
 }
 
 ReturnValue_t SpiComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
-  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
   if (spiCookie == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
@@ -303,10 +361,16 @@ void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
     return;
   }
   size_t dataLen = spiCookie->getTransferStructHandle()->len;
-  auto* dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->tx_buf);
+  uint8_t* dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->tx_buf);
-  sif::info("Sent SPI data:\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "Sent SPI data: " << std::endl;
   arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
-  sif::info("Received SPI data:\n");
+  sif::info << "Received SPI data: " << std::endl;
+#else
+  sif::printInfo("Sent SPI data: \n");
+  arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
+  sif::printInfo("Received SPI data: \n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
   dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->rx_buf);
   arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
 }

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

@@ -1,10 +1,10 @@
 #include "UartComIF.h"
 
+#include <errno.h>
 #include <fcntl.h>
 #include <termios.h>
 #include <unistd.h>
 
-#include <cerrno>
 #include <cstring>
 
 #include "fsfw/FSFW.h"
@@ -23,9 +23,11 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
     return NULLPOINTER;
   }
 
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGE("{}", "initializeInterface: Invalid UART Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UartComIF::initializeInterface: Invalid UART Cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
@@ -40,12 +42,18 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
     size_t maxReplyLen = uartCookie->getMaxReplyLen();
     UartElements uartElements = {fileDescriptor, std::vector<uint8_t>(maxReplyLen), 0};
     auto status = uartDeviceMap.emplace(deviceFile, uartElements);
-    if (!status.second) {
+    if (status.second == false) {
-      FSFW_LOGW("initializeInterface: Failed to insert device {} to UART device map\n", deviceFile);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UartComIF::initializeInterface: Failed to insert device " << deviceFile
+                   << "to UART device map" << std::endl;
+#endif
       return RETURN_FAILED;
     }
   } else {
-    FSFW_LOGW("initializeInterface: UART device {} already in use\n", deviceFile);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::initializeInterface: UART device " << deviceFile
+                 << " already in use" << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -65,14 +73,19 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
   int fd = open(deviceFile.c_str(), flags);
 
   if (fd < 0) {
-    FSFW_LOGW("configureUartPort: Failed to open UART {} with error code {} | {}\n", deviceFile,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              errno, strerror(errno));
+    sif::warning << "UartComIF::configureUartPort: Failed to open uart " << deviceFile
+                 << "with error code " << errno << strerror(errno) << std::endl;
+#endif
     return fd;
   }
 
   /* Read in existing settings */
   if (tcgetattr(fd, &options) != 0) {
-    FSFW_LOGW("configureUartPort: Error {} from tcgetattr: {}\n", errno, strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::configureUartPort: Error " << errno
+                 << "from tcgetattr: " << strerror(errno) << std::endl;
+#endif
     return fd;
   }
 
@@ -93,8 +106,10 @@ int UartComIF::configureUartPort(UartCookie* uartCookie) {
 
   /* Save option settings */
   if (tcsetattr(fd, TCSANOW, &options) != 0) {
-    FSFW_LOGW("configureUartPort: Failed to set options with error {} | {}\n", errno,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              strerror(errno));
+    sif::warning << "UartComIF::configureUartPort: Failed to set options with error " << errno
+                 << ": " << strerror(errno);
+#endif
     return fd;
   }
   return fd;
@@ -146,8 +161,9 @@ void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCook
       options->c_cflag |= CS8;
       break;
     default:
-      FSFW_LOGW("setDatasizeOptions: Invalid size {} specified\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                static_cast<unsigned int>(uartCookie->getBitsPerWord()));
+      sif::warning << "UartComIF::setDatasizeOptions: Invalid size specified" << std::endl;
+#endif
       break;
   }
 }
@@ -300,7 +316,9 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       break;
 #endif  // ! __APPLE__
     default:
-      FSFW_LOGW("{}", "UartComIF::configureBaudrate: Baudrate not supported\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
+#endif
       break;
   }
 }
@@ -315,27 +333,37 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
   }
 
   if (sendData == nullptr) {
-    FSFW_LOGWT("{}", "sendMessage: Send data is nullptr");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::sendMessage: Send data is nullptr" << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "sendMessage: Invalid UART Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::sendMessasge: Invalid UART Cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
   deviceFile = uartCookie->getDeviceFile();
   uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter == uartDeviceMap.end()) {
-    FSFW_LOGWT("{}", "sendMessage: Device file {} not in UART map\n", deviceFile);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "UartComIF::sendMessage: Device file " << deviceFile << "not in UART map"
+               << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
   fd = uartDeviceMapIter->second.fileDescriptor;
 
   if (write(fd, sendData, sendLen) != static_cast<int>(sendLen)) {
-    FSFW_LOGE("sendMessage: Failed to send data with error code {} | {}", errno, strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UartComIF::sendMessage: Failed to send data with error code " << errno
+               << ": Error description: " << strerror(errno) << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -348,9 +376,11 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   std::string deviceFile;
   UartDeviceMapIter uartDeviceMapIter;
 
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "requestReceiveMessage: Invalid UART Cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "UartComIF::requestReceiveMessage: Invalid Uart Cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
@@ -363,7 +393,10 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   }
 
   if (uartDeviceMapIter == uartDeviceMap.end()) {
-    FSFW_LOGW("requestReceiveMessage: Device file {} not in UART map\n", deviceFile);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "UartComIF::requestReceiveMessage: Device file " << deviceFile
+               << " not in uart map" << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -381,7 +414,7 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   uint8_t maxReadCycles = uartCookie.getReadCycles();
   uint8_t currentReadCycles = 0;
-  ssize_t bytesRead = 0;
+  int bytesRead = 0;
   size_t currentBytesRead = 0;
   size_t maxReplySize = uartCookie.getMaxReplyLen();
   int fd = iter->second.fileDescriptor;
@@ -392,7 +425,16 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
     if (currentBytesRead >= maxReplySize) {
       // Overflow risk. Emit warning, trigger event and break. If this happens,
       // the reception buffer is not large enough or data is not polled often enough.
-      FSFW_LOGWT("{}", "requestReceiveMessage: Next read would cause overflow\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "UartComIF::requestReceiveMessage: Next read would cause overflow!"
+                   << std::endl;
+#else
+      sif::printWarning(
+          "UartComIF::requestReceiveMessage: "
+          "Next read would cause overflow!");
+#endif
+#endif
       result = UART_RX_BUFFER_TOO_SMALL;
       break;
     } else {
@@ -403,7 +445,15 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
     if (bytesRead < 0) {
       // EAGAIN: No data available in non-blocking mode
       if (errno != EAGAIN) {
-        FSFW_LOGWT("handleCanonicalRead: read failed with code {} | {}\n", errno, strerror(errno));
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "UartComIF::handleCanonicalRead: read failed with code" << errno << ": "
+                     << strerror(errno) << std::endl;
+#else
+        sif::printWarning("UartComIF::handleCanonicalRead: read failed with code %d: %s\n", errno,
+                          strerror(errno));
+#endif
+#endif
         return RETURN_FAILED;
       }
 
@@ -423,16 +473,27 @@ ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDevi
   auto bufferPtr = iter->second.replyBuffer.data();
   // Size check to prevent buffer overflow
   if (requestLen > uartCookie.getMaxReplyLen()) {
-    FSFW_LOGW("{}", "requestReceiveMessage: Next read would cause overflow\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::requestReceiveMessage: Next read would cause overflow!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "UartComIF::requestReceiveMessage: "
+        "Next read would cause overflow!");
+#endif
+#endif
     return UART_RX_BUFFER_TOO_SMALL;
   }
-  ssize_t bytesRead = read(fd, bufferPtr, requestLen);
+  int bytesRead = read(fd, bufferPtr, requestLen);
   if (bytesRead < 0) {
     return RETURN_FAILED;
   } else if (bytesRead != static_cast<int>(requestLen)) {
     if (uartCookie.isReplySizeFixed()) {
-      FSFW_LOGWT("UartComIF::requestReceiveMessage: Only read {} of {} bytes\n", bytesRead,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                 requestLen);
+      sif::warning << "UartComIF::requestReceiveMessage: Only read " << bytesRead << " of "
+                   << requestLen << " bytes" << std::endl;
+#endif
       return RETURN_FAILED;
     }
   }
@@ -444,16 +505,21 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   std::string deviceFile;
   UartDeviceMapIter uartDeviceMapIter;
 
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "readReceivedMessage: Invalid uart cookie");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "UartComIF::readReceivedMessage: Invalid uart cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
 
   deviceFile = uartCookie->getDeviceFile();
   uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter == uartDeviceMap.end()) {
-    FSFW_LOGW("UartComIF::readReceivedMessage: Device file {} not in UART map\n", deviceFile);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "UartComIF::readReceivedMessage: Device file " << deviceFile << " not in uart map"
+               << std::endl;
+#endif
     return RETURN_FAILED;
   }
 
@@ -469,9 +535,11 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
 ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
   std::string deviceFile;
   UartDeviceMapIter uartDeviceMapIter;
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "flushUartRxBuffer: Invalid UART cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::flushUartRxBuffer: Invalid uart cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();
@@ -487,9 +555,11 @@ ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
 ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
   std::string deviceFile;
   UartDeviceMapIter uartDeviceMapIter;
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "flushUartTxBuffer: Invalid uart cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::flushUartTxBuffer: Invalid uart cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();
@@ -505,9 +575,11 @@ ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
 ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
   std::string deviceFile;
   UartDeviceMapIter uartDeviceMapIter;
-  auto* uartCookie = dynamic_cast<UartCookie*>(cookie);
+  UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
-    FSFW_LOGWT("{}", "flushUartTxAndRxBuf: Invalid UART cookie\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::flushUartTxAndRxBuf: Invalid uart cookie!" << std::endl;
+#endif
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();

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

@@ -90,7 +90,7 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
    *                      parity settings.
    *
    */
-  static void setParityOptions(struct termios* options, UartCookie* uartCookie);
+  void setParityOptions(struct termios* options, UartCookie* uartCookie);
 
   void setStopBitOptions(struct termios* options, UartCookie* uartCookie);
 

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

@@ -12,7 +12,7 @@ enum class StopBits { ONE_STOP_BIT, TWO_STOP_BITS };
 
 enum class UartModes { CANONICAL, NON_CANONICAL };
 
-enum class BitsPerWord : unsigned int { BITS_5 = 5, BITS_6 = 6, BITS_7 = 7, BITS_8 = 8 };
+enum class BitsPerWord { BITS_5, BITS_6, BITS_7, BITS_8 };
 
 enum class UartBaudRate {
   RATE_50,

hal/src/fsfw_hal/linux/utility.cpp

@@ -3,11 +3,21 @@
 #include <cerrno>
 #include <cstring>
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 void utility::handleIoctlError(const char* const customPrintout) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
   if (customPrintout != nullptr) {
-    FSFW_LOGW(customPrintout);
+    sif::warning << customPrintout << std::endl;
   }
-  FSFW_LOGW("Error code {} | {}\n", errno, strerror(errno));
+  sif::warning << "handleIoctlError: Error code " << errno << ", " << strerror(errno) << std::endl;
+#else
+  if (customPrintout != nullptr) {
+    sif::printWarning("%s\n", customPrintout);
+  }
+  sif::printWarning("handleIoctlError: Error code %d, %s\n", errno, strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
 }

hal/src/fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h

@@ -10,6 +10,10 @@
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_spi.h"
 
+#ifndef STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION
+#define STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION 1
+#endif
+
 enum class TransferStates { IDLE, WAIT, SUCCESS, FAILURE };
 
 class GyroL3GD20H {

scripts/auto-formatter.sh

@@ -4,9 +4,10 @@ if [[ ! -f README.md ]]; then
 fi
 
 cmake_fmt="cmake-format"
+file_selectors="-iname CMakeLists.txt"
 if command -v ${cmake_fmt} &> /dev/null; then
-  cmake_fmt_cmd="${cmake_fmt} -i CMakeLists.txt"
+  ${cmake_fmt} -i CMakeLists.txt
-  eval ${cmake_fmt_cmd}
+  find ./src ${file_selectors} | xargs ${cmake_fmt}  -i
 else
   echo "No ${cmake_fmt} tool found, not formatting CMake files"
 fi
@@ -14,9 +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
-  find ./src ${file_selectors} | xargs clang-format --style=file -i
+  find ./src ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./hal ${file_selectors} | xargs clang-format --style=file -i
+  find ./hal ${file_selectors} | xargs ${cpp_format} --style=file -i
-  find ./tests ${file_selectors} | xargs clang-format --style=file -i
+  find ./tests ${file_selectors} | xargs ${cpp_format} --style=file -i
 else
   echo "No ${cpp_format} tool found, not formatting C++/C files"
 fi

src/CMakeLists.txt

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

src/fsfw/CMakeLists.txt

@@ -1,6 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE version.cpp)
-    version.cpp
-)
 
 # Core
 
@@ -37,22 +35,22 @@ add_subdirectory(tmtcservices)
 # Optional
 
 if(FSFW_ADD_MONITORING)
-add_subdirectory(monitoring)
+  add_subdirectory(monitoring)
 endif()
 if(FSFW_ADD_PUS)
-    add_subdirectory(pus)
+  add_subdirectory(pus)
 endif()
 if(FSFW_ADD_TMSTORAGE)
-    add_subdirectory(tmstorage)
+  add_subdirectory(tmstorage)
 endif()
 if(FSFW_ADD_COORDINATES)
-    add_subdirectory(coordinates)
+  add_subdirectory(coordinates)
 endif()
 if(FSFW_ADD_RMAP)
-    add_subdirectory(rmap)
+  add_subdirectory(rmap)
 endif()
 if(FSFW_ADD_DATALINKLAYER)
-    add_subdirectory(datalinklayer)
+  add_subdirectory(datalinklayer)
 endif()
 
 # OSAL

src/fsfw/action/ActionHelper.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/action.h"
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue)
     : owner(setOwner), queueToUse(useThisQueue) {}
@@ -28,7 +28,13 @@ ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
   }
 
   if (queueToUse == nullptr) {
-    FSFW_LOGW("{}", "initialize: No queue set\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "ActionHelper::initialize: No queue set" << std::endl;
+#else
+    sif::printWarning("ActionHelper::initialize: No queue set\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -90,7 +96,14 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   size_t size = 0;
   ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize, &dataPtr);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("{}", "reportData: Getting free element from IPC store failed\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "ActionHelper::reportData: Getting free element from IPC "
+        "store failed!\n");
+#endif
     return result;
   }
   result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
@@ -125,7 +138,11 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   store_address_t storeAddress;
   ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("{}", "reportData: Adding data to IPC store failed\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
+#else
+    sif::printWarning("ActionHelper::reportData: Adding data to IPC store failed!\n");
+#endif
     return result;
   }
 

src/fsfw/action/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-    PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
-        ActionHelper.cpp
+                           CommandActionHelper.cpp SimpleActionHelper.cpp)
-        ActionMessage.cpp
-        CommandActionHelper.cpp
-        SimpleActionHelper.cpp
-)

src/fsfw/cfdp/CFDPHandler.cpp

@@ -4,7 +4,6 @@
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface.h"
 #include "fsfw/storagemanager/storeAddress.h"
 #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
 
@@ -29,7 +28,13 @@ ReturnValue_t CFDPHandler::initialize() {
 }
 
 ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
-  FSFW_LOGDT("{}", "CFDPHandler::handleRequest\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::debug << "CFDPHandler::handleRequest" << std::endl;
+#else
+  sif::printDebug("CFDPHandler::handleRequest\n");
+#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif
 
   // TODO read out packet from store using storeId
 

src/fsfw/cfdp/CMakeLists.txt

@@ -1,7 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp)
-    CFDPHandler.cpp
-    CFDPMessage.cpp
-)
 
 add_subdirectory(pdu)
 add_subdirectory(tlv)

src/fsfw/cfdp/pdu/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    PduConfig.cpp
+  ${LIB_FSFW_NAME}
-    VarLenField.cpp
+  PRIVATE PduConfig.cpp
-    HeaderSerializer.cpp
+          VarLenField.cpp
-    HeaderDeserializer.cpp
+          HeaderSerializer.cpp
-    FileDirectiveDeserializer.cpp
+          HeaderDeserializer.cpp
-    FileDirectiveSerializer.cpp
+          FileDirectiveDeserializer.cpp
- 
+          FileDirectiveSerializer.cpp
-    AckInfo.cpp
+          AckInfo.cpp
-    AckPduSerializer.cpp
+          AckPduSerializer.cpp
-    AckPduDeserializer.cpp
+          AckPduDeserializer.cpp
-    EofInfo.cpp
+          EofInfo.cpp
-    EofPduSerializer.cpp
+          EofPduSerializer.cpp
-    EofPduDeserializer.cpp
+          EofPduDeserializer.cpp
-    NakInfo.cpp
+          NakInfo.cpp
-    NakPduSerializer.cpp
+          NakPduSerializer.cpp
-    NakPduDeserializer.cpp
+          NakPduDeserializer.cpp
-    FinishedInfo.cpp
+          FinishedInfo.cpp
-    FinishedPduSerializer.cpp
+          FinishedPduSerializer.cpp
-    FinishedPduDeserializer.cpp
+          FinishedPduDeserializer.cpp
-    MetadataInfo.cpp
+          MetadataInfo.cpp
-    MetadataPduSerializer.cpp
+          MetadataPduSerializer.cpp
-    MetadataPduDeserializer.cpp
+          MetadataPduDeserializer.cpp
-    KeepAlivePduSerializer.cpp
+          KeepAlivePduSerializer.cpp
-    KeepAlivePduDeserializer.cpp
+          KeepAlivePduDeserializer.cpp
-    PromptPduSerializer.cpp
+          PromptPduSerializer.cpp
-    PromptPduDeserializer.cpp
+          PromptPduDeserializer.cpp
-
+          FileDataSerializer.cpp
-    FileDataSerializer.cpp
+          FileDataDeserializer.cpp
-    FileDataDeserializer.cpp
+          FileDataInfo.cpp)
-    FileDataInfo.cpp
-)

src/fsfw/cfdp/pdu/EofPduDeserializer.cpp

@@ -50,9 +50,17 @@ ReturnValue_t EofPduDeserializer::parseData() {
   if (info.getConditionCode() != cfdp::ConditionCode::NO_ERROR) {
     EntityIdTlv* tlvPtr = info.getFaultLoc();
     if (tlvPtr == nullptr) {
-      FSFW_LOGW("{}",
+#if FSFW_VERBOSE_LEVEL >= 1
-                "parseData: Ca not deserialize fault location,"
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                " given TLV pointer invalid\n");
+      sif::warning << "EofPduDeserializer::parseData: Ca not deserialize fault location,"
+                      " given TLV pointer invalid"
+                   << std::endl;
+#else
+      sif::printWarning(
+          "EofPduDeserializer::parseData: Ca not deserialize fault location,"
+          " given TLV pointer invalid");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
       return HasReturnvaluesIF::RETURN_FAILED;
     }
     result = tlvPtr->deSerialize(&bufPtr, &deserLen, endianness);

src/fsfw/cfdp/pdu/VarLenField.cpp

@@ -7,7 +7,13 @@
 cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
   ReturnValue_t result = this->setValue(width, value);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGW("{}", "cfdp::VarLenField: Setting value failed\n");
+#if FSFW_DISABLE_PRINTOUT == 0
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::VarLenField: Setting value failed" << std::endl;
+#else
+    sif::printWarning("cfdp::VarLenField: Setting value failed\n");
+#endif
+#endif
   }
 }
 

src/fsfw/cfdp/tlv/CMakeLists.txt

@@ -1,10 +1,10 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    EntityIdTlv.cpp
+  ${LIB_FSFW_NAME}
-    FilestoreRequestTlv.cpp
+  PRIVATE EntityIdTlv.cpp
-    FilestoreResponseTlv.cpp
+          FilestoreRequestTlv.cpp
-    Lv.cpp
+          FilestoreResponseTlv.cpp
-    Tlv.cpp
+          Lv.cpp
-    FlowLabelTlv.cpp
+          Tlv.cpp
-    MessageToUserTlv.cpp
+          FlowLabelTlv.cpp
-    FaultHandlerOverrideTlv.cpp
+          MessageToUserTlv.cpp
-)
+          FaultHandlerOverrideTlv.cpp)

src/fsfw/cfdp/tlv/FilestoreTlvBase.h

@@ -6,7 +6,7 @@
 #include <fsfw/cfdp/tlv/Tlv.h>
 #include <fsfw/cfdp/tlv/TlvIF.h>
 #include <fsfw/serialize/SerializeIF.h>
-#include <fsfw/serviceinterface.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -128,7 +128,17 @@ class FilestoreTlvBase : public TlvIF {
   }
 
   void secondFileNameMissing() const {
-    FSFW_LOGWT("{}", "secondFileNameMissing: Second file name required but TLV pointer not set\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "FilestoreRequestTlv::deSerialize: Second file name required"
+                    " but TLV pointer not set"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "FilestoreRequestTlv::deSerialize: Second file name required"
+        " but TLV pointer not set\n");
+#endif
+#endif
   }
 
   FilestoreActionCode getActionCode() const { return actionCode; }

src/fsfw/container/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE SharedRingBuffer.cpp
-    PRIVATE 
+                                        SimpleRingBuffer.cpp)
-        SharedRingBuffer.cpp
-        SimpleRingBuffer.cpp
-)

src/fsfw/controller/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE ControllerBase.cpp
-    ControllerBase.cpp
+                                        ExtendedControllerBase.cpp)
-    ExtendedControllerBase.cpp
-)

src/fsfw/controller/ExtendedControllerBase.h

@@ -46,18 +46,14 @@ class ExtendedControllerBase : public ControllerBase,
    */
   virtual void performControlOperation() = 0;
 
-  /* Handle the four messages mentioned above */
+  // Handle the four messages mentioned above
   void handleQueue() override;
 
-  /* HasActionsIF overrides */
+  // HasActionsIF overrides
   virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                       const uint8_t* data, size_t size) override;
 
-  /* HasLocalDatapoolIF overrides */
+  // HasLocalDatapoolIF overrides
-  virtual LocalDataPoolManager* getHkManagerHandle() override;
-  virtual object_id_t getObjectId() const override;
-  virtual uint32_t getPeriodicOperationFrequency() const override;
-
   virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                 LocalDataPoolManager& poolManager) override = 0;
   virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
@@ -65,6 +61,12 @@ class ExtendedControllerBase : public ControllerBase,
   // Mode abstract functions
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                          uint32_t* msToReachTheMode) override = 0;
+
+  virtual LocalDataPoolManager* getHkManagerHandle() override;
+  virtual object_id_t getObjectId() const override;
+  virtual uint32_t getPeriodicOperationFrequency() const override;
+
+
 };
 
 #endif /* FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_ */

src/fsfw/coordinates/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE CoordinateTransformations.cpp
-	PRIVATE 
+                                        Sgp4Propagator.cpp)
-		CoordinateTransformations.cpp
-		Sgp4Propagator.cpp
-)

src/fsfw/datalinklayer/CMakeLists.txt

@@ -1,12 +1,11 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		Clcw.cpp
+  PRIVATE Clcw.cpp
-		DataLinkLayer.cpp
+          DataLinkLayer.cpp
-		Farm1StateLockout.cpp
+          Farm1StateLockout.cpp
-		Farm1StateOpen.cpp
+          Farm1StateOpen.cpp
-		Farm1StateWait.cpp
+          Farm1StateWait.cpp
-		MapPacketExtraction.cpp
+          MapPacketExtraction.cpp
-		TcTransferFrame.cpp
+          TcTransferFrame.cpp
-		TcTransferFrameLocal.cpp
+          TcTransferFrameLocal.cpp
-		VirtualChannelReception.cpp
+          VirtualChannelReception.cpp)
-)

src/fsfw/datalinklayer/Clcw.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/datalinklayer/Clcw.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 Clcw::Clcw() {
   content.raw = 0;

src/fsfw/datalinklayer/DataLinkLayer.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/datalinklayer/DataLinkLayer.h"
 
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw,
                              uint8_t set_start_sequence_length, uint16_t set_scid)

src/fsfw/datalinklayer/MapPacketExtraction.cpp

@@ -4,7 +4,7 @@
 
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/tmtcpacket/SpacePacketBase.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"

src/fsfw/datalinklayer/TcTransferFrame.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/datalinklayer/TcTransferFrame.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 TcTransferFrame::TcTransferFrame() { frame = nullptr; }
 

src/fsfw/datalinklayer/TcTransferFrameLocal.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid,
                                            uint8_t vcId, uint8_t sequenceNumber,

src/fsfw/datalinklayer/VirtualChannelReception.cpp

@@ -8,7 +8,7 @@
 #include "fsfw/datalinklayer/VirtualChannelReception.h"
 
 #include "fsfw/datalinklayer/BCFrame.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId,
                                                  uint8_t setSlidingWindowWidth)

src/fsfw/datapool/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE PoolDataSetBase.cpp PoolEntry.cpp)
-	PoolDataSetBase.cpp
-	PoolEntry.cpp
-)

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 #include "fsfw/datapool/ReadCommitIFAttorney.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
                                  const size_t maxFillCount)
@@ -17,15 +17,27 @@ ReturnValue_t PoolDataSetBase::registerVariable(PoolVariableIF* variable) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   if (state != States::STATE_SET_UNINITIALISED) {
-    FSFW_LOGW("{}", "registerVariable: Call made in wrong position\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DataSet::registerVariable: Call made in wrong position." << std::endl;
+#else
+    sif::printError("DataSet::registerVariable: Call made in wrong position.");
+#endif
     return DataSetIF::DATA_SET_UNINITIALISED;
   }
   if (variable == nullptr) {
-    FSFW_LOGW("{}", "registerVariable: Pool variable is nullptr\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DataSet::registerVariable: Pool variable is nullptr." << std::endl;
+#else
+    sif::printError("DataSet::registerVariable: Pool variable is nullptr.\n");
+#endif
     return DataSetIF::POOL_VAR_NULL;
   }
   if (fillCount >= maxFillCount) {
-    FSFW_LOGW("{}", "registerVariable: DataSet is full\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DataSet::registerVariable: DataSet is full." << std::endl;
+#else
+    sif::printError("DataSet::registerVariable: DataSet is full.\n");
+#endif
     return DataSetIF::DATA_SET_FULL;
   }
   registeredVariables[fillCount] = variable;
@@ -47,7 +59,15 @@ ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t l
     state = States::STATE_SET_WAS_READ;
     unlockDataPool();
   } else {
-    FSFW_LOGWT("{}", "read: Call made in wrong position. commit call might be missing\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "PoolDataSetBase::read: Call made in wrong position. Don't forget to "
+                    "commit member datasets!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "PoolDataSetBase::read: Call made in wrong position. Don't forget to "
+        "commit member datasets!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
     result = SET_WAS_ALREADY_READ;
   }
 

src/fsfw/datapool/PoolEntry.cpp

@@ -4,7 +4,7 @@
 #include <cstring>
 
 #include "fsfw/globalfunctions/arrayprinter.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 template <typename T>
 PoolEntry<T>::PoolEntry(std::initializer_list<T> initValue, bool setValid)
@@ -68,7 +68,13 @@ void PoolEntry<T>::print() {
   } else {
     validString = "Invalid";
   }
-  FSFW_LOGI("PoolEntry Info. Validity {}\n", validString);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "PoolEntry information." << std::endl;
+  sif::info << "PoolEntry validity: " << validString << std::endl;
+#else
+  sif::printInfo("PoolEntry information.\n");
+  sif::printInfo("PoolEntry validity: %s\n", validString);
+#endif
   arrayprinter::print(reinterpret_cast<uint8_t*>(address), getByteSize());
 }
 

src/fsfw/datapool/PoolReadGuard.h

@@ -1,9 +1,10 @@
 #ifndef FSFW_DATAPOOL_POOLREADHELPER_H_
 #define FSFW_DATAPOOL_POOLREADHELPER_H_
 
+#include <FSFWConfig.h>
+
+#include "../serviceinterface/ServiceInterface.h"
 #include "ReadCommitIF.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"
 
 /**
  * @brief 	Helper class to read data sets or pool variables
@@ -17,7 +18,13 @@ class PoolReadGuard {
     if (readObject != nullptr) {
       readResult = readObject->read(timeoutType, mutexTimeout);
       if (readResult != HasReturnvaluesIF::RETURN_OK) {
-        FSFW_LOGW("{}", "ctor: Read failed\n");
+#if FSFW_VERBOSE_LEVEL == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PoolReadHelper: Read failed!" << std::endl;
+#else
+        sif::printError("PoolReadHelper: Read failed!\n");
+#endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
       }
     }
   }

src/fsfw/datapoollocal/CMakeLists.txt

@@ -1,10 +1,6 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		LocalDataPoolManager.cpp
+  PRIVATE LocalDataPoolManager.cpp LocalDataSet.cpp LocalPoolDataSetBase.cpp
-		LocalDataSet.cpp
+          LocalPoolObjectBase.cpp SharedLocalDataSet.cpp)
-		LocalPoolDataSetBase.cpp
-		LocalPoolObjectBase.cpp
-		SharedLocalDataSet.cpp
-)
 
-add_subdirectory(internal)
+add_subdirectory(internal)

src/fsfw/datapoollocal/HasLocalDataPoolIF.h

@@ -6,8 +6,8 @@
 #include "../datapool/PoolEntryIF.h"
 #include "../housekeeping/HousekeepingMessage.h"
 #include "../ipc/MessageQueueSenderIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "LocalDataPoolManager.h"
-#include "fsfw/serviceinterface.h"
 #include "localPoolDefinitions.h"
 
 class AccessPoolManagerIF;
@@ -166,7 +166,15 @@ class HasLocalDataPoolIF {
    * @return
    */
   virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-    FSFW_LOGW("{}", "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. Returning nullptr\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
+                    "Returning nullptr!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "HasLocalDataPoolIF::getPoolObjectHandle: "
+        "Not overriden. Returning nullptr!\n");
+#endif
     return nullptr;
   }
 };

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -3,7 +3,6 @@
 #include <array>
 #include <cmath>
 
-#include "fsfw/FSFW.h"
 #include "fsfw/datapoollocal.h"
 #include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
 #include "fsfw/housekeeping/HousekeepingSetPacket.h"
@@ -22,15 +21,15 @@ LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQue
                                            bool appendValidityBuffer)
     : appendValidityBuffer(appendValidityBuffer) {
   if (owner == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "ctor", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager",
-                        "Invalid supplied owner");
+                        HasReturnvaluesIF::RETURN_FAILED, "Invalid supplied owner");
     return;
   }
   this->owner = owner;
   mutex = MutexFactory::instance()->createMutex();
   if (mutex == nullptr) {
-    printWarningOrError(sif::LogLevel::ERROR, "ctor", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "LocalDataPoolManager",
-                        "Could not create mutex");
+                        HasReturnvaluesIF::RETURN_FAILED, "Could not create mutex");
   }
 
   hkQueue = queueToUse;
@@ -45,25 +44,25 @@ LocalDataPoolManager::~LocalDataPoolManager() {
 ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   if (queueToUse == nullptr) {
     /* Error, all destinations invalid */
-    printWarningOrError(sif::LogLevel::ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
   }
   hkQueue = queueToUse;
 
   ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (ipcStore == nullptr) {
     /* Error, all destinations invalid */
-    printWarningOrError(sif::LogLevel::ERROR, "initialize", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", HasReturnvaluesIF::RETURN_FAILED,
                         "Could not set IPC store.");
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   if (defaultHkDestination != objects::NO_OBJECT) {
-    auto* hkPacketReceiver =
+    AcceptsHkPacketsIF* hkPacketReceiver =
         ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
     if (hkPacketReceiver != nullptr) {
       hkDestinationId = hkPacketReceiver->getHkQueue();
     } else {
-      printWarningOrError(sif::LogLevel::ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
       return QUEUE_OR_DESTINATION_INVALID;
     }
   }
@@ -85,7 +84,7 @@ ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
     return result;
   }
 
-  printWarningOrError(sif::LogLevel::WARNING, "initializeHousekeepingPoolEntriesOnce",
+  printWarningOrError(sif::OutputTypes::OUT_WARNING, "initializeHousekeepingPoolEntriesOnce",
                       HasReturnvaluesIF::RETURN_FAILED, "The map should only be initialized once");
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -151,7 +150,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
     LocalPoolObjectBase* poolObj =
         HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
     if (poolObj == nullptr) {
-      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
+                          POOLOBJECT_NOT_FOUND);
       return POOLOBJECT_NOT_FOUND;
     }
     if (poolObj->hasChanged()) {
@@ -170,7 +170,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive
     LocalPoolDataSetBase* dataSet =
         HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
     if (dataSet == nullptr) {
-      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationUpdate", DATASET_NOT_FOUND);
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
+                          DATASET_NOT_FOUND);
       return DATASET_NOT_FOUND;
     }
     if (dataSet->hasChanged()) {
@@ -198,7 +199,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     LocalPoolObjectBase* poolObj =
         HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
     if (poolObj == nullptr) {
-      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationSnapshot",
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
                           POOLOBJECT_NOT_FOUND);
       return POOLOBJECT_NOT_FOUND;
     }
@@ -234,7 +235,8 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     LocalPoolDataSetBase* dataSet =
         HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
     if (dataSet == nullptr) {
-      printWarningOrError(sif::LogLevel::WARNING, "handleNotificationSnapshot", DATASET_NOT_FOUND);
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
+                          DATASET_NOT_FOUND);
       return DATASET_NOT_FOUND;
     }
 
@@ -243,9 +245,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
     }
 
     /* Prepare and send update snapshot */
-    timeval now{};
+    timeval now;
     Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds{};
+    CCSDSTime::CDS_short cds;
     CCSDSTime::convertToCcsds(&cds, &now);
     HousekeepingSnapshot updatePacket(
         reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@@ -340,7 +342,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
   AcceptsHkPacketsIF* hkReceiverObject =
       ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "subscribeForPeriodicPacket",
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
@@ -366,9 +368,10 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
 ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics,
                                                              bool reportingEnabled,
                                                              object_id_t packetDestination) {
-  auto* hkReceiverObject = ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
+  AcceptsHkPacketsIF* hkReceiverObject =
+      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
   if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "subscribeForPeriodicPacket",
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
@@ -521,7 +524,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
     case (HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
       LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
       if (dataSet == nullptr) {
-        printWarningOrError(sif::LogLevel::WARNING, "handleHousekeepingMessage", DATASET_NOT_FOUND);
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
+                            DATASET_NOT_FOUND);
         return DATASET_NOT_FOUND;
       }
       if (command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT and
@@ -584,7 +588,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me
 ReturnValue_t LocalDataPoolManager::printPoolEntry(lp_id_t localPoolId) {
   auto poolIter = localPoolMap.find(localPoolId);
   if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::LogLevel::WARNING, "printPoolEntry", localpool::POOL_ENTRY_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
+                        localpool::POOL_ENTRY_NOT_FOUND);
     return localpool::POOL_ENTRY_NOT_FOUND;
   }
   poolIter->second->print();
@@ -601,7 +606,8 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
                                                                MessageQueueId_t destination) {
   if (dataSet == nullptr) {
     /* Configuration error. */
-    printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket", DATASET_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
+                        DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -624,14 +630,14 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
 
   if (hkQueue == nullptr) {
     /* Error, no queue available to send packet with. */
-    printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket",
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
                         QUEUE_OR_DESTINATION_INVALID);
     return QUEUE_OR_DESTINATION_INVALID;
   }
   if (destination == MessageQueueIF::NO_QUEUE) {
     if (hkDestinationId == MessageQueueIF::NO_QUEUE) {
       /* Error, all destinations invalid */
-      printWarningOrError(sif::LogLevel::WARNING, "generateHousekeepingPacket",
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
                           QUEUE_OR_DESTINATION_INVALID);
     }
     destination = hkDestinationId;
@@ -665,7 +671,8 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   sid_t sid = receiver.dataId.sid;
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "performPeriodicHkGeneration", DATASET_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
+                        DATASET_NOT_FOUND);
     return;
   }
 
@@ -688,7 +695,11 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   ReturnValue_t result = generateHousekeepingPacket(sid, dataSet, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     /* Configuration error */
-    FSFW_LOGWT("{}", "performHkOperation: HK generation failed");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed." << std::endl;
+#else
+    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
+#endif
   }
 }
 
@@ -696,7 +707,8 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool ena
                                                              bool isDiagnostics) {
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "togglePeriodicGeneration", DATASET_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "togglePeriodicGeneration",
+                        DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -718,7 +730,8 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float ne
                                                              bool isDiagnostics) {
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "changeCollectionInterval", DATASET_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "changeCollectionInterval",
+                        DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -743,7 +756,8 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   /* Get and check dataset first. */
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
   if (dataSet == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "performPeriodicHkGeneration", DATASET_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
+                        DATASET_NOT_FOUND);
     return DATASET_NOT_FOUND;
   }
 
@@ -764,7 +778,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   store_address_t storeId;
   ReturnValue_t result = ipcStore->getFreeElement(&storeId, expectedSize, &storePtr);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    printWarningOrError(sif::LogLevel::ERROR, "generateSetStructurePacket",
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "generateSetStructurePacket",
                         HasReturnvaluesIF::RETURN_FAILED,
                         "Could not get free element from IPC store.");
     return result;
@@ -778,7 +792,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
     return result;
   }
   if (expectedSize != size) {
-    printWarningOrError(sif::LogLevel::WARNING, "generateSetStructurePacket",
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
                         HasReturnvaluesIF::RETURN_FAILED,
                         "Expected size is not equal to serialized size");
   }
@@ -811,8 +825,9 @@ MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; }
 
 object_id_t LocalDataPoolManager::getCreatorObjectId() const { return owner->getObjectId(); }
 
-void LocalDataPoolManager::printWarningOrError(sif::LogLevel outputType, const char* functionName,
+void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
-                                               ReturnValue_t error, const char* errorPrint) {
+                                               const char* functionName, ReturnValue_t error,
+                                               const char* errorPrint) {
 #if FSFW_VERBOSE_LEVEL >= 1
   if (errorPrint == nullptr) {
     if (error == DATASET_NOT_FOUND) {
@@ -820,7 +835,7 @@ void LocalDataPoolManager::printWarningOrError(sif::LogLevel outputType, const c
     } else if (error == POOLOBJECT_NOT_FOUND) {
       errorPrint = "Pool Object not found";
     } else if (error == HasReturnvaluesIF::RETURN_FAILED) {
-      if (outputType == sif::LogLevel::WARNING) {
+      if (outputType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";
       } else {
         errorPrint = "Generic error";
@@ -840,10 +855,24 @@ void LocalDataPoolManager::printWarningOrError(sif::LogLevel outputType, const c
     objectId = owner->getObjectId();
   }
 
-  if (outputType == sif::LogLevel::WARNING) {
+  if (outputType == sif::OutputTypes::OUT_WARNING) {
-    FSFW_LOGWT("{} | Object ID {} | {}\n", functionName, objectId, errorPrint);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-  } else if (outputType == sif::LogLevel::ERROR) {
+    sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
-    FSFW_LOGET("{} | Object ID {} | {}\n", functionName, objectId, errorPrint);
+                 << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
+                 << std::setfill(' ') << std::endl;
+#else
+    sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
+                      errorPrint);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+  } else if (outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
+               << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
+               << std::setfill(' ') << std::endl;
+#else
+    sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
+                    errorPrint);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
   }
 #endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
 }

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -16,7 +16,7 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -375,7 +375,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver, ReturnValue_t& status);
   ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
 
-  void printWarningOrError(sif::LogLevel outputType, const char* functionName,
+  void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
                            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
                            const char* errorPrint = nullptr);
 };
@@ -389,13 +389,14 @@ inline ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
 
   auto poolIter = localPoolMap.find(localPoolId);
   if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::LogLevel::WARNING, "fetchPoolEntry", localpool::POOL_ENTRY_NOT_FOUND);
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
+                        localpool::POOL_ENTRY_NOT_FOUND);
     return localpool::POOL_ENTRY_NOT_FOUND;
   }
 
   *poolEntry = dynamic_cast<PoolEntry<T>*>(poolIter->second);
   if (*poolEntry == nullptr) {
-    printWarningOrError(sif::LogLevel::WARNING, "fetchPoolEntry",
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
                         localpool::POOL_ENTRY_TYPE_CONFLICT);
     return localpool::POOL_ENTRY_TYPE_CONFLICT;
   }

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -7,7 +7,7 @@
 #include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/SerializeAdapter.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t setId,
@@ -16,7 +16,14 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t
     : PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
   if (hkOwner == nullptr) {
     // Configuration error.
-    FSFW_LOGW("{}", "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner invalid\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+               << "invalid!" << std::endl;
+#else
+    sif::printError(
+        "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
+        "invalid!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
     return;
   }
   AccessPoolManagerIF *accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
@@ -179,7 +186,14 @@ ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size
     auto result =
         SerializeAdapter::serialize(&currentPoolId, buffer, size, maxSize, streamEndianness);
     if (result != HasReturnvaluesIF::RETURN_OK) {
-      FSFW_LOGW("{}", "serializeLocalPoolIds: Serialization error\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: "
+                   << "Serialization error!" << std::endl;
+#else
+      sif::printWarning(
+          "LocalPoolDataSetBase::serializeLocalPoolIds: "
+          "Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
       return result;
     }
   }

src/fsfw/datapoollocal/LocalPoolObjectBase.cpp

@@ -4,17 +4,22 @@
 #include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
                                          DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
     : localPoolId(poolId), readWriteMode(setReadWriteMode) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
-    FSFW_LOGWT("{}", "ctor: Invalid pool ID, has NO_PARAMETER value\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                 << "which is the NO_PARAMETER value!" << std::endl;
+#endif
   }
   if (hkOwner == nullptr) {
-    FSFW_LOGET("{}", "ctor: Supplied pool owner is a invalid\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool "
+               << "owner is a invalid!" << std::endl;
+#endif
     return;
   }
   AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
@@ -29,14 +34,28 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
                                          pool_rwm_t setReadWriteMode)
     : localPoolId(poolId), readWriteMode(setReadWriteMode) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
-    FSFW_LOGWT("{}", "ctor: Invalid pool ID, has NO_PARAMETER value\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                    "which is the NO_PARAMETER value!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+        "which is the NO_PARAMETER value!\n");
+#endif
   }
-  auto* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
+  HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
   if (hkOwner == nullptr) {
-    FSFW_LOGWT(
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-        "ctor: The supplied pool owner {:#010x} did not implement the correct interface "
+    sif::error << "LocalPoolVariable: The supplied pool owner 0x" << std::hex << poolOwner
-        "HasLocalDataPoolIF\n",
+               << std::dec << " did not implement the correct interface "
+               << "HasLocalDataPoolIF" << std::endl;
+#else
+    sif::printError(
+        "LocalPoolVariable: The supplied pool owner 0x%08x did not implement the correct "
+        "interface HasLocalDataPoolIF\n",
         poolOwner);
+#endif
     return;
   }
 
@@ -70,6 +89,7 @@ void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
 
 void LocalPoolObjectBase::reportReadCommitError(const char* variableType, ReturnValue_t error,
                                                 bool read, object_id_t objectId, lp_id_t lpId) {
+#if FSFW_DISABLE_PRINTOUT == 0
   const char* variablePrintout = variableType;
   if (variablePrintout == nullptr) {
     variablePrintout = "Unknown Type";
@@ -94,6 +114,13 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType, Return
     errMsg = "Unknown error code";
   }
 
-  FSFW_LOGW("{}: {} call | {} | Owner: {:#010x} | LPID: \n", variablePrintout, type, errMsg,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-            objectId, lpId);
+  sif::warning << variablePrintout << ": " << type << " call | " << errMsg << " | Owner: 0x"
+               << std::hex << std::setw(8) << std::setfill('0') << objectId << std::dec
+               << " LPID: " << lpId << std::endl;
+#else
+  sif::printWarning("%s: %s call | %s | Owner: 0x%08x LPID: %lu\n", variablePrintout, type, errMsg,
+                    objectId, lpId);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
 }

src/fsfw/datapoollocal/LocalPoolVariable.h

@@ -5,11 +5,11 @@
 #include "../datapool/PoolVariableIF.h"
 #include "../objectmanager/ObjectManagerIF.h"
 #include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "AccessLocalPoolF.h"
 #include "HasLocalDataPoolIF.h"
 #include "LocalDataPoolManager.h"
 #include "LocalPoolObjectBase.h"
-#include "fsfw/serviceinterface.h"
 #include "internal/LocalDpManagerAttorney.h"
 
 /**

src/fsfw/datapoollocal/LocalPoolVector.h

@@ -6,8 +6,8 @@
 #include "../datapool/PoolVariableIF.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../serialize/SerializeAdapter.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "LocalPoolObjectBase.h"
-#include "fsfw/serviceinterface.h"
 #include "internal/LocalDpManagerAttorney.h"
 
 /**

src/fsfw/datapoollocal/LocalPoolVector.tpp

@@ -5,162 +5,172 @@
 #error Include LocalPoolVector.h before LocalPoolVector.tpp!
 #endif
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-        HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet,
+                                                       DataSetIF* dataSet,
-        pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
+    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-        lp_id_t poolId, DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       DataSetIF* dataSet,
-        LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+                                                       pool_rwm_t setReadWriteMode)
+    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId,
+inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
-        DataSetIF *dataSet, pool_rwm_t setReadWriteMode):
+                                                       pool_rwm_t setReadWriteMode)
-        LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId,
+    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                dataSet, setReadWriteMode) {}
+                          setReadWriteMode) {}
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                          uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+  return readWithoutLock();
 }
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_WRITE) {
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, true, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
 
-    PoolEntry<T>* poolEntry = nullptr;
+  PoolEntry<T>* poolEntry = nullptr;
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+  ReturnValue_t result =
-            &poolEntry);
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-    memset(this->value, 0, vectorSize * sizeof(T));
+  memset(this->value, 0, vectorSize * sizeof(T));
 
-    if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector", result, true, targetObjectId,
+    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
-                localPoolId);
+    return result;
-        return result;
+  }
-    }
+  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+  this->valid = poolEntry->getValid();
-    this->valid = poolEntry->getValid();
+  return RETURN_OK;
-    return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                            MutexIF::TimeoutType timeoutType,
-    this->setValid(valid);
+                                                            uint32_t timeoutMs) {
-    return commit(timeoutType, timeoutMs);
+  this->setValid(valid);
+  return commit(timeoutType, timeoutMs);
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
-        MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+                                                            uint32_t timeoutMs) {
-    MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
+  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+  return commitWithoutLock();
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-    if(readWriteMode == pool_rwm_t::VAR_READ) {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        reportReadCommitError("LocalPoolVector",
+    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                PoolVariableIF::INVALID_READ_WRITE_MODE, false, targetObjectId,
+                          targetObjectId, localPoolId);
-                localPoolId);
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-        return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
-    }
+  PoolEntry<T>* poolEntry = nullptr;
-    PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result =
-    ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
+      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-            &poolEntry);
+  if (result != RETURN_OK) {
-    if(result != RETURN_OK) {
+    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-        object_id_t targetObjectId = hkManager->getCreatorObjectId();
+    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
-        reportReadCommitError("LocalPoolVector", result, false, targetObjectId,
-                localPoolId);
-        return result;
-    }
-    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-    poolEntry->setValid(this->valid);
-    return RETURN_OK;
-}
-
-template<typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator [](size_t i) {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-    FSFW_LOGW("LocalPoolVector: Invalid index. Setting or returning last value\n");
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator [](size_t i) const {
-    if(i < vectorSize) {
-        return value[i];
-    }
-    // If this happens, I have to set some value. I consider this
-    // a configuration error, but I wont exit here.
-    FSFW_LOGW("LocalPoolVector: Invalid index. Setting or returning last value\n");
-    return value[vectorSize - 1];
-}
-
-template<typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
-        size_t* size, size_t maxSize,
-        SerializeIF::Endianness streamEndianness) const {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    for (uint16_t i = 0; i < vectorSize; i++) {
-        result = SerializeAdapter::serialize(&(value[i]), buffer, size,
-                maxSize, streamEndianness);
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
-    }
     return result;
+  }
+  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+  poolEntry->setValid(this->valid);
+  return RETURN_OK;
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
+inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
+  if (i < vectorSize) {
+    return value[i];
+  }
+  // If this happens, I have to set some value. I consider this
+  // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
+                  " last value!"
+               << std::endl;
+#else
+  sif::printWarning(
+      "LocalPoolVector: Invalid index. Setting or returning"
+      " last value!\n");
+#endif
+  return value[vectorSize - 1];
+}
+
+template <typename T, uint16_t vectorSize>
+inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
+    uint8_t** buffer, size_t* size, size_t maxSize,
+    SerializeIF::Endianness streamEndianness) const {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      break;
+    }
+  }
+  return result;
+}
+
+template <typename T, uint16_t vectorSize>
 inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-    return vectorSize * SerializeAdapter::getSerializedSize(value);
+  return vectorSize * SerializeAdapter::getSerializedSize(value);
 }
 
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
 inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-        const uint8_t** buffer, size_t* size,
+    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-        SerializeIF::Endianness streamEndianness) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  for (uint16_t i = 0; i < vectorSize; i++) {
-    for (uint16_t i = 0; i < vectorSize; i++) {
+    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-        result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
+    if (result != HasReturnvaluesIF::RETURN_OK) {
-                streamEndianness);
+      break;
-        if (result != HasReturnvaluesIF::RETURN_OK) {
-            break;
-        }
     }
-    return result;
+  }
+  return result;
 }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-template<typename T, uint16_t vectorSize>
+template <typename T, uint16_t vectorSize>
-inline std::ostream& operator<< (std::ostream &out,
+inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
-        const LocalPoolVector<T, vectorSize> &var) {
+  out << "Vector: [";
-    out << "Vector: [";
+  for (int i = 0; i < vectorSize; i++) {
-    for(int i = 0;i < vectorSize; i++) {
+    out << var.value[i];
-        out << var.value[i];
+    if (i < vectorSize - 1) {
-        if(i < vectorSize - 1) {
+      out << ", ";
-            out << ", ";
-        }
     }
-    out << "]";
+  }
-    return out;
+  out << "]";
+  return out;
 }
 #endif
 

src/fsfw/datapoollocal/internal/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HasLocalDpIFUserAttorney.cpp
-	PRIVATE 
+                                        HasLocalDpIFManagerAttorney.cpp)
-		HasLocalDpIFUserAttorney.cpp
-		HasLocalDpIFManagerAttorney.cpp
-)

src/fsfw/devicehandlers/CMakeLists.txt

@@ -1,11 +1,10 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		AssemblyBase.cpp
+  PRIVATE AssemblyBase.cpp
-		ChildHandlerBase.cpp
+          ChildHandlerBase.cpp
-		ChildHandlerFDIR.cpp
+          ChildHandlerFDIR.cpp
-		DeviceHandlerBase.cpp
+          DeviceHandlerBase.cpp
-		DeviceHandlerFailureIsolation.cpp
+          DeviceHandlerFailureIsolation.cpp
-		DeviceHandlerMessage.cpp
+          DeviceHandlerMessage.cpp
-		DeviceTmReportingWrapper.cpp
+          DeviceTmReportingWrapper.cpp
-		HealthDevice.cpp
+          HealthDevice.cpp)
-)

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -8,7 +8,7 @@
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/subsystem/SubsystemBase.h"
 #include "fsfw/thermal/ThermalComponentIF.h"
@@ -45,16 +45,16 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
   cookieInfo.state = COOKIE_UNUSED;
   cookieInfo.pendingCommand = deviceCommandMap.end();
   if (comCookie == nullptr) {
-    printWarningOrError(sif::LogLevel::ERROR, "DeviceHandlerBase", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase",
-                        "Invalid cookie");
+                        HasReturnvaluesIF::RETURN_FAILED, "Invalid cookie");
   }
   if (this->fdirInstance == nullptr) {
     this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
   }
 }
 
-void DeviceHandlerBase::setHkDestination(object_id_t hkDestination_) {
+void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
-  this->hkDestination = hkDestination_;
+  this->hkDestination = hkDestination;
 }
 
 void DeviceHandlerBase::setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId,
@@ -130,34 +130,42 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   communicationInterface =
       ObjectManager::instance()->get<DeviceCommunicationIF>(deviceCommunicationId);
   if (communicationInterface == nullptr) {
-    printWarningOrError(sif::LogLevel::ERROR, "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-                        "Passed communication IF invalid");
+                        ObjectManagerIF::CHILD_INIT_FAILED, "Passed communication IF invalid");
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
   result = communicationInterface->initializeInterface(comCookie);
   if (result != RETURN_OK) {
-    printWarningOrError(sif::LogLevel::ERROR, "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-                        "ComIF initialization failed");
+                        ObjectManagerIF::CHILD_INIT_FAILED, "ComIF initialization failed");
     return result;
   }
 
   IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   if (IPCStore == nullptr) {
-    printWarningOrError(sif::LogLevel::ERROR, "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
-                        "IPC Store not set up");
+                        ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
   if (rawDataReceiverId != objects::NO_OBJECT) {
-    auto* rawReceiver = ObjectManager::instance()->get<AcceptsDeviceResponsesIF>(rawDataReceiverId);
+    AcceptsDeviceResponsesIF* rawReceiver =
+        ObjectManager::instance()->get<AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
     if (rawReceiver == nullptr) {
-      printWarningOrError(sif::LogLevel::ERROR, "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+                          ObjectManagerIF::CHILD_INIT_FAILED,
                           "Raw receiver object ID set but no valid object found.");
-      FSFW_LOGE("{}",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                "Make sure the raw receiver object is set up properly "
+      sif::error << "Make sure the raw receiver object is set up properly"
-                "and implements AcceptsDeviceResponsesIF");
+                    " and implements AcceptsDeviceResponsesIF"
+                 << std::endl;
+#else
+      sif::printError(
+          "Make sure the raw receiver object is set up "
+          "properly and implements AcceptsDeviceResponsesIF\n");
+#endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
     defaultRawReceiver = rawReceiver->getDeviceQueue();
@@ -166,11 +174,17 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   if (powerSwitcherId != objects::NO_OBJECT) {
     powerSwitcher = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitcherId);
     if (powerSwitcher == nullptr) {
-      printWarningOrError(sif::LogLevel::ERROR, "initialize", ObjectManagerIF::CHILD_INIT_FAILED,
+      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
+                          ObjectManagerIF::CHILD_INIT_FAILED,
                           "Power switcher set but no valid object found.");
-      FSFW_LOGE("{}",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                "Make sure the power switcher object is set up "
+      sif::error << "Make sure the power switcher object is set up "
-                "properly and implements PowerSwitchIF\n");
+                 << "properly and implements PowerSwitchIF" << std::endl;
+#else
+      sif::printError(
+          "Make sure the power switcher object is set up "
+          "properly and implements PowerSwitchIF\n");
+#endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
   }
@@ -303,7 +317,8 @@ void DeviceHandlerBase::doStateMachine() {
         sprintf(printout, "Transition timeout (%lu) occured !",
                 static_cast<unsigned long>(childTransitionDelay));
         /* Common configuration error for development, so print it */
-        printWarningOrError(sif::LogLevel::WARNING, "doStateMachine", RETURN_FAILED, printout);
+        printWarningOrError(sif::OutputTypes::OUT_WARNING, "doStateMachine", RETURN_FAILED,
+                            printout);
 #endif
         triggerEvent(MODE_TRANSITION_FAILED, childTransitionFailure, 0);
         setMode(transitionSourceMode, transitionSourceSubMode);
@@ -595,8 +610,8 @@ void DeviceHandlerBase::replyToReply(const DeviceCommandId_t command, DeviceRepl
   }
   DeviceCommandInfo* info = &replyInfo.command->second;
   if (info == nullptr) {
-    printWarningOrError(sif::LogLevel::ERROR, "replyToReply", HasReturnvaluesIF::RETURN_FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "replyToReply",
-                        "Command pointer not found");
+                        HasReturnvaluesIF::RETURN_FAILED, "Command pointer not found");
     return;
   }
 
@@ -737,7 +752,7 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData, size_t receivedD
       case RETURN_OK:
         handleReply(receivedData, foundId, foundLen);
         if (foundLen == 0) {
-          printWarningOrError(sif::LogLevel::WARNING, "parseReply",
+          printWarningOrError(sif::OutputTypes::OUT_WARNING, "parseReply",
                               ObjectManagerIF::CHILD_INIT_FAILED,
                               "Found length is one, parsing might be stuck");
         }
@@ -749,12 +764,14 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData, size_t receivedD
           triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
         }
         if (foundLen == 0) {
-          printWarningOrError(sif::LogLevel::ERROR, "parseReply",
+          printWarningOrError(sif::OutputTypes::OUT_ERROR, "parseReply",
                               ObjectManagerIF::CHILD_INIT_FAILED,
                               "Power switcher set but no valid object found.");
-          FSFW_LOGW("{}",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                    "DeviceHandlerBase::parseReply: foundLen is 0! "
+          sif::warning << "DeviceHandlerBase::parseReply: foundLen is 0!"
-                    "Packet parsing will be stuck\n");
+                          " Packet parsing will be stuck."
+                       << std::endl;
+#endif
         }
         break;
       }
@@ -1269,7 +1286,7 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
   return result;
 }
 
-void DeviceHandlerBase::buildInternalCommand() {
+void DeviceHandlerBase::buildInternalCommand(void) {
   /* Neither raw nor direct could build a command */
   ReturnValue_t result = NOTHING_TO_SEND;
   DeviceCommandId_t deviceCommandId = NO_COMMAND_ID;
@@ -1277,7 +1294,7 @@ void DeviceHandlerBase::buildInternalCommand() {
     result = buildNormalDeviceCommand(&deviceCommandId);
     if (result == BUSY) {
       /* So we can track misconfigurations */
-      printWarningOrError(sif::LogLevel::WARNING, "buildInternalCommand",
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
                           HasReturnvaluesIF::RETURN_FAILED, "Busy.");
       /* No need to report this */
       result = NOTHING_TO_SEND;
@@ -1295,14 +1312,14 @@ void DeviceHandlerBase::buildInternalCommand() {
     return;
   }
   if (result == RETURN_OK) {
-    auto iter = deviceCommandMap.find(deviceCommandId);
+    DeviceCommandMap::iterator iter = deviceCommandMap.find(deviceCommandId);
     if (iter == deviceCommandMap.end()) {
 #if FSFW_VERBOSE_LEVEL >= 1
       char output[36];
       sprintf(output, "Command 0x%08x unknown", static_cast<unsigned int>(deviceCommandId));
       // so we can track misconfigurations
-      printWarningOrError(sif::LogLevel::WARNING, "buildInternalCommand", COMMAND_NOT_SUPPORTED,
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
-                          output);
+                          COMMAND_NOT_SUPPORTED, output);
 #endif
       result = COMMAND_NOT_SUPPORTED;
     } else if (iter->second.isExecuting) {
@@ -1310,7 +1327,7 @@ void DeviceHandlerBase::buildInternalCommand() {
       char output[36];
       sprintf(output, "Command 0x%08x is executing", static_cast<unsigned int>(deviceCommandId));
       // so we can track misconfigurations
-      printWarningOrError(sif::LogLevel::WARNING, "buildInternalCommand",
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "buildInternalCommand",
                           HasReturnvaluesIF::RETURN_FAILED, output);
 #endif
       // this is an internal command, no need to report a failure here,
@@ -1331,7 +1348,7 @@ void DeviceHandlerBase::buildInternalCommand() {
 ReturnValue_t DeviceHandlerBase::buildChildRawCommand() { return NOTHING_TO_SEND; }
 
 uint8_t DeviceHandlerBase::getReplyDelayCycles(DeviceCommandId_t deviceCommand) {
-  auto iter = deviceReplyMap.find(deviceCommand);
+  DeviceReplyMap::iterator iter = deviceReplyMap.find(deviceCommand);
   if (iter == deviceReplyMap.end()) {
     return 0;
   }
@@ -1439,13 +1456,13 @@ void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
   }
 }
 
-void DeviceHandlerBase::printWarningOrError(sif::LogLevel errorType, const char* functionName,
+void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const char* functionName,
                                             ReturnValue_t errorCode, const char* errorPrint) {
   if (errorPrint == nullptr) {
     if (errorCode == ObjectManagerIF::CHILD_INIT_FAILED) {
       errorPrint = "Initialization error";
     } else if (errorCode == HasReturnvaluesIF::RETURN_FAILED) {
-      if (errorType == sif::LogLevel::WARNING) {
+      if (errorType == sif::OutputTypes::OUT_WARNING) {
         errorPrint = "Generic Warning";
       } else {
         errorPrint = "Generic Error";
@@ -1458,12 +1475,24 @@ void DeviceHandlerBase::printWarningOrError(sif::LogLevel errorType, const char*
     functionName = "unknown function";
   }
 
-  if (errorType == sif::LogLevel::WARNING) {
+  if (errorType == sif::OutputTypes::OUT_WARNING) {
-    FSFW_LOGWT("{} | Object ID {:#010x} | {}", functionName, SystemObject::getObjectId(),
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-               errorPrint);
+    sif::warning << "DeviceHandlerBase::" << functionName << ": Object ID 0x" << std::hex
-  } else if (errorType == sif::LogLevel::ERROR) {
+                 << std::setw(8) << std::setfill('0') << this->getObjectId() << " | " << errorPrint
-    FSFW_LOGET("{} | Object ID {:#010x} | {}", functionName, SystemObject::getObjectId(),
+                 << std::dec << std::setfill(' ') << std::endl;
-               errorPrint);
+#else
+    sif::printWarning("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n", functionName,
+                      this->getObjectId(), errorPrint);
+#endif
+  } else if (errorType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DeviceHandlerBase::" << functionName << ": Object ID 0x" << std::hex
+               << std::setw(8) << std::setfill('0') << this->getObjectId() << " | " << errorPrint
+               << std::dec << std::setfill(' ') << std::endl;
+#else
+    sif::printError("DeviceHandlerBase::%s: Object ID 0x%08x | %s\n", functionName,
+                    this->getObjectId(), errorPrint);
+#endif
   }
 }
 

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -19,7 +19,8 @@
 #include "fsfw/parameters/ParameterHelper.h"
 #include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
 
@@ -1281,7 +1282,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param errorCode
    * @param errorPrint
    */
-  void printWarningOrError(sif::LogLevel errorType, const char *functionName,
+  void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                            ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
                            const char *errorPrint = nullptr);
 };

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -5,7 +5,7 @@
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/power/Fuse.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 #include "fsfw/thermal/ThermalComponentIF.h"
 
 object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
@@ -163,10 +163,15 @@ void DeviceHandlerFailureIsolation::clearFaultCounters() {
 ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
   ReturnValue_t result = FailureIsolationBase::initialize();
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGE("{}", "initialize: Could not initialize FailureIsolationBase\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DeviceHandlerFailureIsolation::initialize: Could not"
+                  " initialize FailureIsolationBase."
+               << std::endl;
+#endif
     return result;
   }
-  auto* power = ObjectManager::instance()->get<ConfirmsFailuresIF>(powerConfirmationId);
+  ConfirmsFailuresIF* power =
+      ObjectManager::instance()->get<ConfirmsFailuresIF>(powerConfirmationId);
   if (power != nullptr) {
     powerConfirmation = power->getEventReceptionQueue();
   }
@@ -239,7 +244,10 @@ bool DeviceHandlerFailureIsolation::isFdirInActionOrAreWeFaulty(EventMessage* ev
 
   if (owner == nullptr) {
     // Configuration error.
-    FSFW_LOGE("isFdirInActionOrAreWeFaulty: Owner not set\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "DeviceHandlerFailureIsolation::"
+               << "isFdirInActionOrAreWeFaulty: Owner not set!" << std::endl;
+#endif
     return false;
   }
 

src/fsfw/events/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE 
+target_sources(${LIB_FSFW_NAME} PRIVATE EventManager.cpp EventMessage.cpp)
-    EventManager.cpp
-    EventMessage.cpp
-)
 
 add_subdirectory(eventmatching)

src/fsfw/events/EventManager.cpp

@@ -119,17 +119,17 @@ void EventManager::printEvent(EventMessage* message) {
   switch (message->getSeverity()) {
     case severity::INFO: {
 #if FSFW_DEBUG_INFO == 1
-      printUtility(sif::LogLevel::INFO, message);
+      printUtility(sif::OutputTypes::OUT_INFO, message);
 #endif /* DEBUG_INFO_EVENT == 1 */
       break;
     }
     default:
-      printUtility(sif::LogLevel::DEBUG, message);
+      printUtility(sif::OutputTypes::OUT_DEBUG, message);
       break;
   }
 }
 
-void EventManager::printUtility(sif::LogLevel printType, EventMessage* message) {
+void EventManager::printUtility(sif::OutputTypes printType, EventMessage* message) {
   const char* string = 0;
   if (printType == sif::OutputTypes::OUT_INFO) {
     string = translateObject(message->getReporter());

src/fsfw/events/EventManager.h

@@ -6,12 +6,12 @@
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MutexIF.h"
 #include "../objectmanager/SystemObject.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../storagemanager/LocalPool.h"
 #include "../tasks/ExecutableObjectIF.h"
 #include "EventManagerIF.h"
 #include "FSFWConfig.h"
 #include "eventmatching/EventMatchTree.h"
-#include "fsfw/serviceinterface.h"
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
 // forward declaration, should be implemented by mission
@@ -63,7 +63,7 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
   void printEvent(EventMessage* message);
-  void printUtility(sif::LogLevel printType, EventMessage* message);
+  void printUtility(sif::OutputTypes printType, EventMessage* message);
 #endif
 
   void lockMutex();

src/fsfw/events/EventManagerIF.h

@@ -4,9 +4,9 @@
 #include "../ipc/MessageQueueIF.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "EventMessage.h"
 #include "eventmatching/eventmatching.h"
-#include "fsfw/serviceinterface.h"
 
 class EventManagerIF {
  public:
@@ -39,9 +39,19 @@ class EventManagerIF {
 
   static void triggerEvent(EventMessage* message, MessageQueueId_t sentFrom = 0) {
     if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
-      auto* eventmanager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+      EventManagerIF* eventmanager =
+          ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
       if (eventmanager == nullptr) {
-        FSFW_LOGW("{}", "EventManagerIF::triggerEvent: EventManager invalid or not found\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "EventManagerIF::triggerEvent: EventManager invalid or not found!"
+                     << std::endl;
+#else
+        sif::printWarning(
+            "EventManagerIF::triggerEvent: "
+            "EventManager invalid or not found!");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
         return;
       }
       eventmanagerQueue = eventmanager->getEventReportQueue();

src/fsfw/events/eventmatching/CMakeLists.txt

@@ -1,7 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE EventIdRangeMatcher.cpp EventMatchTree.cpp
-		EventIdRangeMatcher.cpp
+                           ReporterRangeMatcher.cpp SeverityRangeMatcher.cpp)
-		EventMatchTree.cpp
-		ReporterRangeMatcher.cpp
-		SeverityRangeMatcher.cpp
-)

src/fsfw/events/fwSubsystemIdRanges.h

@@ -27,6 +27,7 @@ enum : uint8_t {
   PUS_SERVICE_6 = 86,
   PUS_SERVICE_8 = 88,
   PUS_SERVICE_9 = 89,
+  PUS_SERVICE_11 = 91,
   PUS_SERVICE_17 = 97,
   PUS_SERVICE_23 = 103,
   MGM_LIS3MDL = 106,

src/fsfw/fdir/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME} PRIVATE EventCorrelation.cpp FailureIsolationBase.cpp
-		EventCorrelation.cpp
+                           FaultCounter.cpp)
-		FailureIsolationBase.cpp
-		FaultCounter.cpp
-)

src/fsfw/fdir/FailureIsolationBase.cpp

@@ -18,9 +18,13 @@ FailureIsolationBase::~FailureIsolationBase() {
 }
 
 ReturnValue_t FailureIsolationBase::initialize() {
-  auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (manager == nullptr) {
-    FSFW_LOGE("{}", "initialize: Event Manager has not been initialized\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "FailureIsolationBase::initialize: Event Manager has not"
+                  " been initialized!"
+               << std::endl;
+#endif
     return RETURN_FAILED;
   }
   ReturnValue_t result = manager->registerListener(eventQueue->getId());
@@ -34,20 +38,27 @@ ReturnValue_t FailureIsolationBase::initialize() {
     }
     owner = ObjectManager::instance()->get<HasHealthIF>(ownerId);
     if (owner == nullptr) {
-      FSFW_LOGE(
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-          "FailureIsolationBase::intialize: Owner object {:#010x} invalid. "
+      sif::error << "FailureIsolationBase::intialize: Owner object "
-          "Does it implement HasHealthIF?\n",
+                    "invalid. Make sure it implements HasHealthIF"
-          ownerId);
+                 << std::endl;
+#endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
   }
   if (faultTreeParent != objects::NO_OBJECT) {
-    auto* parentIF = ObjectManager::instance()->get<ConfirmsFailuresIF>(faultTreeParent);
+    ConfirmsFailuresIF* parentIF =
+        ObjectManager::instance()->get<ConfirmsFailuresIF>(faultTreeParent);
     if (parentIF == nullptr) {
-      FSFW_LOGW(
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-          "intialize: Parent object {:#010x} invalid. Does it implement ConfirmsFailuresIF?\n",
+      sif::error << "FailureIsolationBase::intialize: Parent object"
-          faultTreeParent);
+                 << "invalid." << std::endl;
+#endif
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
+#endif
       return ObjectManagerIF::CHILD_INIT_FAILED;
+      return RETURN_FAILED;
     }
     eventQueue->setDefaultDestination(parentIF->getEventReceptionQueue());
   }

src/fsfw/globalfunctions/CMakeLists.txt

@@ -1,13 +1,12 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		arrayprinter.cpp
+  PRIVATE arrayprinter.cpp
-		AsciiConverter.cpp
+          AsciiConverter.cpp
-		CRC.cpp
+          CRC.cpp
-		DleEncoder.cpp
+          DleEncoder.cpp
-		PeriodicOperationDivider.cpp
+          PeriodicOperationDivider.cpp
-		timevalOperations.cpp
+          timevalOperations.cpp
-		Type.cpp
+          Type.cpp
-		bitutility.cpp
+          bitutility.cpp)
-)
 
 add_subdirectory(math)

src/fsfw/globalfunctions/arrayprinter.cpp

@@ -3,16 +3,31 @@
 #include <bitset>
 #include <cmath>
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 void arrayprinter::print(const uint8_t *data, size_t size, OutputType type, bool printInfo,
                          size_t maxCharPerLine) {
   if (size == 0) {
-    FSFW_LOGI("{}", "Size is zero, nothing to print\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Size is zero, nothing to print" << std::endl;
+#else
+    sif::printInfo("Size is zero, nothing to print\n");
+#endif
     return;
   }
 
-  FSFW_LOGI("Printing data with size {}:\n", size);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  if (printInfo) {
+    sif::info << "Printing data with size " << size << ": " << std::endl;
+  }
+#else
+#if FSFW_NO_C99_IO == 1
+  sif::printInfo("Printing data with size %lu: \n", static_cast<unsigned long>(size));
+#else
+  sif::printInfo("Printing data with size %zu: \n", size);
+#endif /* FSFW_NO_C99_IO == 1 */
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
   if (type == OutputType::HEX) {
     arrayprinter::printHex(data, size, maxCharPerLine);
   } else if (type == OutputType::DEC) {
@@ -23,99 +38,99 @@ void arrayprinter::print(const uint8_t *data, size_t size, OutputType type, bool
 }
 
 void arrayprinter::printHex(const uint8_t *data, size_t size, size_t maxCharPerLine) {
-  //#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-  //  if (sif::info.crAdditionEnabled()) {
+  if (sif::info.crAdditionEnabled()) {
-  //    std::cout << "\r" << std::endl;
+    std::cout << "\r" << std::endl;
-  //  }
+  }
-  //
+
-  //  std::cout << "hex [" << std::setfill('0') << std::hex;
+  std::cout << "hex [" << std::setfill('0') << std::hex;
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    std::cout << std::setw(2) << static_cast<int>(data[i]);
+    std::cout << std::setw(2) << static_cast<int>(data[i]);
-  //    if (i < size - 1) {
+    if (i < size - 1) {
-  //      std::cout << ",";
+      std::cout << ",";
-  //      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
+      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
-  //        std::cout << std::endl;
+        std::cout << std::endl;
-  //      }
+      }
-  //    }
+    }
-  //  }
+  }
-  //  std::cout << std::dec << std::setfill(' ');
+  std::cout << std::dec << std::setfill(' ');
-  //  std::cout << "]" << std::endl;
+  std::cout << "]" << std::endl;
-  //#else
+#else
-  //  // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
+  // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
-  //  // plus line break plus small safety margin.
+  // plus line break plus small safety margin.
-  //  char printBuffer[(size + 1) * 7 + 1] = {};
+  char printBuffer[(size + 1) * 7 + 1] = {};
-  //  size_t currentPos = 0;
+  size_t currentPos = 0;
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    // To avoid buffer overflows.
+    // To avoid buffer overflows.
-  //    if (sizeof(printBuffer) - currentPos <= 7) {
+    if (sizeof(printBuffer) - currentPos <= 7) {
-  //      break;
+      break;
-  //    }
+    }
-  //
+
-  //    currentPos += snprintf(printBuffer + currentPos, 6, "%02x", data[i]);
+    currentPos += snprintf(printBuffer + currentPos, 6, "%02x", data[i]);
-  //    if (i < size - 1) {
+    if (i < size - 1) {
-  //      currentPos += sprintf(printBuffer + currentPos, ",");
+      currentPos += sprintf(printBuffer + currentPos, ",");
-  //      if ((i + 1) % maxCharPerLine == 0) {
+      if ((i + 1) % maxCharPerLine == 0) {
-  //        currentPos += sprintf(printBuffer + currentPos, "\n");
+        currentPos += sprintf(printBuffer + currentPos, "\n");
-  //      }
+      }
-  //    }
+    }
-  //  }
+  }
-  //#if FSFW_DISABLE_PRINTOUT == 0
+#if FSFW_DISABLE_PRINTOUT == 0
-  //  printf("hex [%s]\n", printBuffer);
+  printf("hex [%s]\n", printBuffer);
-  //#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
-  //#endif
+#endif
 }
 
 void arrayprinter::printDec(const uint8_t *data, size_t size, size_t maxCharPerLine) {
-  //#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-  //  if (sif::info.crAdditionEnabled()) {
+  if (sif::info.crAdditionEnabled()) {
-  //    std::cout << "\r" << std::endl;
+    std::cout << "\r" << std::endl;
-  //  }
+  }
-  //
+
-  //  std::cout << "dec [" << std::dec;
+  std::cout << "dec [" << std::dec;
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    std::cout << static_cast<int>(data[i]);
+    std::cout << static_cast<int>(data[i]);
-  //    if (i < size - 1) {
+    if (i < size - 1) {
-  //      std::cout << ",";
+      std::cout << ",";
-  //      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
+      if (i > 0 and (i + 1) % maxCharPerLine == 0) {
-  //        std::cout << std::endl;
+        std::cout << std::endl;
-  //      }
+      }
-  //    }
+    }
-  //  }
+  }
-  //  std::cout << "]" << std::endl;
+  std::cout << "]" << std::endl;
-  //#else
+#else
-  //  // General format: 32,243,-12 so it is number of chars times 4
+  // General format: 32,243,-12 so it is number of chars times 4
-  //  // plus line break plus small safety margin.
+  // plus line break plus small safety margin.
-  //  uint16_t expectedLines = ceil((double)size / maxCharPerLine);
+  uint16_t expectedLines = ceil((double)size / maxCharPerLine);
-  //  char printBuffer[size * 4 + 1 + expectedLines] = {};
+  char printBuffer[size * 4 + 1 + expectedLines] = {};
-  //  size_t currentPos = 0;
+  size_t currentPos = 0;
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    // To avoid buffer overflows.
+    // To avoid buffer overflows.
-  //    if (sizeof(printBuffer) - currentPos <= 4) {
+    if (sizeof(printBuffer) - currentPos <= 4) {
-  //      break;
+      break;
-  //    }
+    }
-  //
+
-  //    currentPos += snprintf(printBuffer + currentPos, 4, "%d", data[i]);
+    currentPos += snprintf(printBuffer + currentPos, 4, "%d", data[i]);
-  //    if (i < size - 1) {
+    if (i < size - 1) {
-  //      currentPos += sprintf(printBuffer + currentPos, ",");
+      currentPos += sprintf(printBuffer + currentPos, ",");
-  //      if ((i + 1) % maxCharPerLine == 0) {
+      if ((i + 1) % maxCharPerLine == 0) {
-  //        currentPos += sprintf(printBuffer + currentPos, "\n");
+        currentPos += sprintf(printBuffer + currentPos, "\n");
-  //      }
+      }
-  //    }
+    }
-  //  }
+  }
-  //#if FSFW_DISABLE_PRINTOUT == 0
+#if FSFW_DISABLE_PRINTOUT == 0
-  //  printf("dec [%s]\n", printBuffer);
+  printf("dec [%s]\n", printBuffer);
-  //#endif /* FSFW_DISABLE_PRINTOUT == 0 */
+#endif /* FSFW_DISABLE_PRINTOUT == 0 */
-  //#endif
+#endif
 }
 
 void arrayprinter::printBin(const uint8_t *data, size_t size) {
-  //#if FSFW_CPP_OSTREAM_ENABLED == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    sif::info << "Byte " << i + 1 << ": 0b" << std::bitset<8>(data[i]) << std::endl;
+    sif::info << "Byte " << i + 1 << ": 0b" << std::bitset<8>(data[i]) << std::endl;
-  //  }
+  }
-  //#else
+#else
-  //  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; i++) {
-  //    sif::printInfo("Byte %d: 0b" BYTE_TO_BINARY_PATTERN "\n", i + 1, BYTE_TO_BINARY(data[i]));
+    sif::printInfo("Byte %d: 0b" BYTE_TO_BINARY_PATTERN "\n", i + 1, BYTE_TO_BINARY(data[i]));
-  //  }
+  }
-  //#endif
+#endif
 }

src/fsfw/globalfunctions/math/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE QuaternionOperations.cpp)
-	PRIVATE 
-		QuaternionOperations.cpp
-)

src/fsfw/health/CMakeLists.txt

@@ -1,6 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HealthHelper.cpp HealthMessage.cpp
-	PRIVATE 
+                                        HealthTable.cpp)
-		HealthHelper.cpp
-		HealthMessage.cpp
-		HealthTable.cpp	
-)

src/fsfw/health/HealthHelper.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/health/HealthHelper.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId)
     : objectId(objectId), owner(owner) {}
@@ -35,12 +35,20 @@ ReturnValue_t HealthHelper::initialize() {
   eventSender = ObjectManager::instance()->get<EventReportingProxyIF>(objectId);
 
   if (healthTable == nullptr) {
-    FSFW_LOGE("{}", "initialize: Health table object needs to be created in factory\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "HealthHelper::initialize: Health table object needs"
+                  "to be created in factory."
+               << std::endl;
+#endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
   if (eventSender == nullptr) {
-    FSFW_LOGE("{}", "initialize: Owner has to implement ReportingProxyIF\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "HealthHelper::initialize: Owner has to implement "
+                  "ReportingProxyIF."
+               << std::endl;
+#endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
@@ -69,7 +77,9 @@ void HealthHelper::informParent(HasHealthIF::HealthState health,
   HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO, health, oldHealth);
   if (MessageQueueSenderIF::sendMessage(parentQueue, &information, owner->getCommandQueue()) !=
       HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("informParent: Object ID {:#010x} | Sending health reply failed\n", objectId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "HealthHelper::informParent: sending health reply failed." << std::endl;
+#endif
   }
 }
 
@@ -86,7 +96,10 @@ void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
   }
   if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply, owner->getCommandQueue()) !=
       HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("handleSetHealthCommand: Object ID {:#010x} | Sending health reply failed\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-               objectId);
+    sif::debug << "HealthHelper::handleHealthCommand: sending health "
+                  "reply failed."
+               << std::endl;
+#endif
   }
 }

src/fsfw/health/HealthTable.cpp

@@ -3,7 +3,6 @@
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serialize/SerializeAdapter.h"
-#include "fsfw/serviceinterface.h"
 
 HealthTable::HealthTable(object_id_t objectid) : SystemObject(objectid) {
   mutex = MutexFactory::instance()->createMutex();
@@ -69,7 +68,13 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
   ReturnValue_t result =
       SerializeAdapter::serialize(&count, &pointer, &size, maxSize, SerializeIF::Endianness::BIG);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGW("{}", "printAll: Serialization of health table failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "HealthTable::printAll: Serialization of health table failed" << std::endl;
+#else
+    sif::printWarning("HealthTable::printAll: Serialization of health table failed\n");
+#endif
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return;
   }
   for (const auto& health : healthMap) {

src/fsfw/housekeeping/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE HousekeepingMessage.cpp
-	PRIVATE 
+                                        PeriodicHousekeepingHelper.cpp)
-		HousekeepingMessage.cpp
-		PeriodicHousekeepingHelper.cpp
-)

src/fsfw/internalerror/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE InternalErrorReporter.cpp)
-	PRIVATE 
-		InternalErrorReporter.cpp
-)

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -3,7 +3,7 @@
 #include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
     : SystemObject(setObjectId),
@@ -34,8 +34,18 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
 #if FSFW_VERBOSE_LEVEL >= 1
   if (diagnosticPrintout) {
     if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
-      FSFW_LOGW("performOperation: Errors occured\nQueue {} | TM {} | Store {}\n", newQueueHits,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                newTmHits, newStoreHits);
+      sif::debug << "InternalErrorReporter::performOperation: Errors "
+                 << "occured!" << std::endl;
+      sif::debug << "Queue errors: " << newQueueHits << std::endl;
+      sif::debug << "TM errors: " << newTmHits << std::endl;
+      sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
+#endif
     }
   }
 #endif

src/fsfw/ipc/CMakeLists.txt

@@ -1,6 +1,3 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(
-    CommandMessage.cpp
+  ${LIB_FSFW_NAME} PRIVATE CommandMessage.cpp CommandMessageCleaner.cpp
-    CommandMessageCleaner.cpp
+                           MessageQueueMessage.cpp MessageQueueBase.cpp)
-    MessageQueueMessage.cpp
-    MessageQueueBase.cpp
-)

src/fsfw/ipc/MessageQueueMessage.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 #include "fsfw/globalfunctions/arrayprinter.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 MessageQueueMessage::MessageQueueMessage() : messageSize(getMinimumMessageSize()) {
   memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
@@ -15,7 +15,11 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
     memcpy(this->getData(), data, size);
     this->messageSize = this->HEADER_SIZE + size;
   } else {
-    FSFW_LOGW("{}", "ctor: Passed size larger than maximum allowed size! Setting content to 0\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "MessageQueueMessage: Passed size larger than maximum"
+                    "allowed size! Setting content to 0"
+                 << std::endl;
+#endif
     memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
     this->messageSize = this->HEADER_SIZE;
   }

src/fsfw/ipc/MutexGuard.h

@@ -1,10 +1,8 @@
 #ifndef FRAMEWORK_IPC_MUTEXGUARD_H_
 #define FRAMEWORK_IPC_MUTEXGUARD_H_
 
-#include <fmt/core.h>
+#include "../serviceinterface/ServiceInterface.h"
-
+#include "MutexFactory.h"
-#include "fsfw/ipc/MutexIF.h"
-#include "fsfw/serviceinterface.h"
 
 class MutexGuard {
  public:
@@ -12,17 +10,35 @@ class MutexGuard {
              uint32_t timeoutMs = 0)
       : internalMutex(mutex) {
     if (mutex == nullptr) {
-      // It's tricky to use the error functions defined in the service interface
+#if FSFW_VERBOSE_LEVEL >= 1
-      // because those functions require the mutex guard themselves
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-      fmt::print("ERROR | Passed mutex is invalid\n");
+      sif::error << "MutexGuard: Passed mutex is invalid!" << std::endl;
+#else
+      sif::printError("MutexGuard: Passed mutex is invalid!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
       return;
     }
     result = mutex->lockMutex(timeoutType, timeoutMs);
+#if FSFW_VERBOSE_LEVEL >= 1
     if (result == MutexIF::MUTEX_TIMEOUT) {
-      fmt::print("ERROR | Lock of mutex failed with timeout of {} milliseconds\n", timeoutMs);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "MutexGuard: Lock of mutex failed with timeout of " << timeoutMs
+                 << " milliseconds!" << std::endl;
+#else
+      sif::printError("MutexGuard: Lock of mutex failed with timeout of %lu milliseconds\n",
+                      timeoutMs);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
     } else if (result != HasReturnvaluesIF::RETURN_OK) {
-      fmt::print("ERROR | Lock of Mutex failed with code {}\n", result);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "MutexGuard: Lock of Mutex failed with code " << result << std::endl;
+#else
+      sif::printError("MutexGuard: Lock of Mutex failed with code %d\n", result);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
     }
+#else
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
   }
 
   ReturnValue_t getLockResult() const { return result; }

src/fsfw/memory/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
+target_sources(${LIB_FSFW_NAME} PRIVATE MemoryHelper.cpp MemoryMessage.cpp
-    MemoryHelper.cpp
+                                        GenericFileSystemMessage.cpp)
-    MemoryMessage.cpp
-    GenericFileSystemMessage.cpp
-)

src/fsfw/memory/MemoryHelper.cpp

@@ -4,7 +4,7 @@
 #include "fsfw/memory/MemoryMessage.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serialize/EndianConverter.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue)
     : workOnThis(workOnThis),
@@ -17,7 +17,9 @@ ReturnValue_t MemoryHelper::handleMemoryCommand(CommandMessage* message) {
   lastSender = message->getSender();
   lastCommand = message->getCommand();
   if (busy) {
-    FSFW_LOGW("{}", "MemoryHelper: Busy\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "MemHelper: Busy!" << std::endl;
+#endif
   }
   switch (lastCommand) {
     case MemoryMessage::CMD_MEMORY_DUMP:

src/fsfw/modes/CMakeLists.txt

@@ -1,5 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE ModeHelper.cpp ModeMessage.cpp)
-	PRIVATE 
-		ModeHelper.cpp
-		ModeMessage.cpp
-)

src/fsfw/modes/ModeHelper.cpp

@@ -2,7 +2,7 @@
 
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/modes/HasModesIF.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 ModeHelper::ModeHelper(HasModesIF* owner)
     : commandedMode(HasModesIF::MODE_OFF),

src/fsfw/monitoring/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE LimitViolationReporter.cpp
-	PRIVATE 
+                                        MonitoringMessage.cpp)
-		LimitViolationReporter.cpp
-		MonitoringMessage.cpp
-)

src/fsfw/monitoring/MonitoringMessageContent.h

@@ -7,10 +7,10 @@
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../serialize/SerializeElement.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../timemanager/TimeStamperIF.h"
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
-#include "fsfw/serviceinterface.h"
 #include "monitoringConf.h"
 
 namespace Factory {
@@ -81,7 +81,11 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
     if (timeStamper == nullptr) {
       timeStamper = ObjectManager::instance()->get<TimeStamperIF>(timeStamperId);
       if (timeStamper == nullptr) {
-        FSFW_LOGET("{}", "checkAndSetStamper: Stamper not found\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "MonitoringReportContent::checkAndSetStamper: "
+                      "Stamper not found!"
+                   << std::endl;
+#endif
         return false;
       }
     }

src/fsfw/objectmanager/CMakeLists.txt

@@ -1,5 +1 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(${LIB_FSFW_NAME} PRIVATE ObjectManager.cpp SystemObject.cpp)
-	PRIVATE 
-		ObjectManager.cpp
-		SystemObject.cpp
-)

src/fsfw/objectmanager/ObjectManager.cpp

@@ -1,6 +1,6 @@
-#include "ObjectManager.h"
+#include "fsfw/objectmanager/ObjectManager.h"
 
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 #include <iomanip>
@@ -36,10 +36,17 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
     // sif::debug << "ObjectManager::insert: Object " << std::hex
     //            << (int)id << std::dec << " inserted." << std::endl;
 #endif
-    return ObjectManager::RETURN_OK;
+    return this->RETURN_OK;
   } else {
-    FSFW_LOGET("ObjectManager::insert: Object ID {:#010x} is already in use\nTerminating program\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-               static_cast<uint32_t>(id));
+    sif::error << "ObjectManager::insert: Object ID " << std::hex << static_cast<uint32_t>(id)
+               << std::dec << " is already in use!" << std::endl;
+    sif::error << "Terminating program" << std::endl;
+#else
+    sif::printError("ObjectManager::insert: Object ID 0x%08x is already in use!\n",
+                    static_cast<unsigned int>(id));
+    sif::printError("Terminating program");
+#endif
     // This is very severe and difficult to handle in other places.
     std::exit(INSERTION_FAILED);
   }
@@ -54,7 +61,10 @@ ReturnValue_t ObjectManager::remove(object_id_t id) {
 #endif
     return RETURN_OK;
   } else {
-    FSFW_LOGW("removeObject: Requested object {:#010x} not found\n", id);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "ObjectManager::removeObject: Requested object " << std::hex << (int)id
+               << std::dec << " not found." << std::endl;
+#endif
     return NOT_FOUND;
   }
 }
@@ -69,44 +79,64 @@ SystemObjectIF* ObjectManager::getSystemObject(object_id_t id) {
 }
 
 void ObjectManager::initialize() {
-  if (objectFactoryFunction != nullptr) {
+  if (objectFactoryFunction == nullptr) {
-    objectFactoryFunction(factoryArgs);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "ObjectManager::initialize: Passed produceObjects "
+                  "functions is nullptr!"
+               << std::endl;
+#else
+    sif::printError("ObjectManager::initialize: Passed produceObjects functions is nullptr!\n");
+#endif
+    return;
   }
+  objectFactoryFunction(factoryArgs);
   ReturnValue_t result = RETURN_FAILED;
   uint32_t errorCount = 0;
   for (auto const& it : objectList) {
     result = it.second->initialize();
     if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
       object_id_t var = it.first;
-      FSFW_LOGWT("initialize: Object {:#010x} failed to initialize with code {:#06x}\n", var,
+      sif::error << "ObjectManager::initialize: Object 0x" << std::hex << std::setw(8)
-                 result);
+                 << std::setfill('0') << var
+                 << " failed to "
+                    "initialize with code 0x"
+                 << result << std::dec << std::setfill(' ') << std::endl;
+#endif
       errorCount++;
     }
   }
   if (errorCount > 0) {
-    FSFW_LOGWT("{}", "initialize: Counted failed initializations\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+               << " failed initializations." << std::endl;
+#endif
   }
   // Init was successful. Now check successful interconnections.
   errorCount = 0;
   for (auto const& it : objectList) {
     result = it.second->checkObjectConnections();
     if (result != RETURN_OK) {
-      FSFW_LOGE("initialize: Object {:#010x} connection check failed with code {:#06x}\n", it.first,
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-                result);
+      sif::error << "ObjectManager::ObjectManager: Object 0x" << std::hex << (int)it.first
+                 << " connection check failed with code 0x" << result << std::dec << std::endl;
+#endif
       errorCount++;
     }
   }
   if (errorCount > 0) {
-    FSFW_LOGE("{}", "ObjectManager::ObjectManager: Counted {} failed connection checks\n",
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-              errorCount);
+    sif::error << "ObjectManager::ObjectManager: Counted " << errorCount
+               << " failed connection checks." << std::endl;
+#endif
   }
 }
 
 void ObjectManager::printList() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info("ObjectManager: Object List contains:\n");
+  sif::debug << "ObjectManager: Object List contains:" << std::endl;
   for (auto const& it : objectList) {
-    sif::info("{:#010x} | {:#010x}\n", it.first, fmt::ptr(it.second));
+    sif::debug << std::hex << it.first << " | " << it.second << std::endl;
   }
 #endif
 }

src/fsfw/objectmanager/ObjectManagerIF.h

@@ -2,9 +2,9 @@
 #define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
 #include "../returnvalues/HasReturnvaluesIF.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "SystemObjectIF.h"
 #include "frameworkObjects.h"
-#include "fsfw/serviceinterface.h"
 
 /**
  * @brief	This class provides an interface to the global object manager.

src/fsfw/objectmanager/frameworkObjects.h

@@ -14,6 +14,7 @@ enum framework_objects : object_id_t {
   PUS_SERVICE_5_EVENT_REPORTING = 0x53000005,
   PUS_SERVICE_8_FUNCTION_MGMT = 0x53000008,
   PUS_SERVICE_9_TIME_MGMT = 0x53000009,
+  PUS_SERVICE_11_TC_SCHEDULER = 0x53000011,
   PUS_SERVICE_17_TEST = 0x53000017,
   PUS_SERVICE_20_PARAMETERS = 0x53000020,
   PUS_SERVICE_200_MODE_MGMT = 0x53000200,

src/fsfw/osal/CMakeLists.txt

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

src/fsfw/osal/common/CMakeLists.txt

@@ -1,17 +1,10 @@
 if(DEFINED WIN32 OR DEFINED UNIX)
-    target_sources(${LIB_FSFW_NAME} PRIVATE 
+  target_sources(
-        tcpipCommon.cpp
+    ${LIB_FSFW_NAME}
-        TcpIpBase.cpp
+    PRIVATE tcpipCommon.cpp TcpIpBase.cpp UdpTcPollingTask.cpp
-        UdpTcPollingTask.cpp
+            UdpTmTcBridge.cpp TcpTmTcServer.cpp TcpTmTcBridge.cpp)
-        UdpTmTcBridge.cpp
-        TcpTmTcServer.cpp
-        TcpTmTcBridge.cpp
-    )
 endif()
 
 if(WIN32)
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE wsock32 ws2_32)
-        wsock32 
+endif()
-        ws2_32
-    )
-endif()

src/fsfw/osal/common/TcpTmTcBridge.cpp

@@ -3,7 +3,7 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/common/TcpTmTcBridge.h"
 #include "fsfw/platform.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #ifdef PLATFORM_WIN
 
@@ -21,13 +21,17 @@ TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, ob
     : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
   mutex = MutexFactory::instance()->createMutex();
   // Connection is always up, TM is requested by connecting to server and receiving packets
-  TmTcBridge::registerCommConnect();
+  registerCommConnect();
 }
 
 ReturnValue_t TcpTmTcBridge::initialize() {
   ReturnValue_t result = TmTcBridge::initialize();
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGE("TcpTmTcBridge::initialize: TmTcBridge initialization failed\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TcpTmTcBridge::initialize: TmTcBridge initialization failed!" << std::endl;
+#else
+    sif::printError("TcpTmTcBridge::initialize: TmTcBridge initialization failed!\n");
+#endif
     return result;
   }
 

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -8,7 +8,7 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/platform.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/tmtcservices/SpacePacketParser.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
@@ -56,7 +56,11 @@ ReturnValue_t TcpTmTcServer::initialize() {
   }
   tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
   if (tcStore == nullptr) {
-    FSFW_LOGE("TcpTmTcServer::initialize: TC store uninitialized\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TcpTmTcServer::initialize: TC store uninitialized!" << std::endl;
+#else
+    sif::printError("TcpTmTcServer::initialize: TC store uninitialized!\n");
+#endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
@@ -105,8 +109,8 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
   using namespace tcpip;
   // If a connection is accepted, the corresponding socket will be assigned to the new socket
   socket_t connSocket = 0;
-  // sockaddr clientSockAddr = {};
+  sockaddr clientSockAddr = {};
-  // socklen_t connectorSockAddrLen = 0;
+  socklen_t connectorSockAddrLen = 0;
   int retval = 0;
 
   // Listen for connection requests permanently for lifetime of program
@@ -117,8 +121,7 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
       continue;
     }
 
-    // connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
+    connSocket = accept(listenerTcpSocket, &clientSockAddr, &connectorSockAddrLen);
-    connSocket = accept(listenerTcpSocket, nullptr, nullptr);
 
     if (connSocket == INVALID_SOCKET) {
       handleError(Protocol::TCP, ErrorSources::ACCEPT_CALL, 500);
@@ -133,6 +136,7 @@ TcpTmTcServer::~TcpTmTcServer() { closeSocket(listenerTcpSocket); }
     if (retval != 0) {
       handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
     }
+
     closeSocket(connSocket);
     connSocket = 0;
   }
@@ -201,7 +205,11 @@ void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
 
 ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t packetSize) {
   if (wiretappingEnabled) {
-    FSFW_LOGI("Received TC:\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Received TC:" << std::endl;
+#else
+    sif::printInfo("Received TC:\n");
+#endif
     arrayprinter::print(spacePacket, packetSize);
   }
 
@@ -211,7 +219,17 @@ ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t pack
   store_address_t storeId;
   ReturnValue_t result = tcStore->addData(&storeId, spacePacket, packetSize);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("handleTcReception: Data storage with packet size {} failed\n", packetSize);
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TcpTmTcServer::handleServerOperation: Data storage with packet size"
+                 << packetSize << " failed" << std::endl;
+#else
+    sif::printWarning(
+        "TcpTmTcServer::handleServerOperation: Data storage with packet size %d "
+        "failed\n",
+        packetSize);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return result;
   }
 
@@ -219,7 +237,17 @@ ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t pack
 
   result = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("handleTcReception: Sending message to queue failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TcpTmTcServer::handleServerOperation: "
+                    " Sending message to queue failed"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "TcpTmTcServer::handleServerOperation: "
+        " Sending message to queue failed\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     tcStore->deleteData(storeId);
   }
   return result;
@@ -249,7 +277,11 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent)
       return result;
     }
     if (wiretappingEnabled) {
-      FSFW_LOGI("Sending TM:");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::info << "Sending TM:" << std::endl;
+#else
+      sif::printInfo("Sending TM:\n");
+#endif
       arrayprinter::print(storeAccessor.data(), storeAccessor.size());
     }
     ssize_t retval = send(connSocket, reinterpret_cast<const char*>(storeAccessor.data()),
@@ -274,14 +306,31 @@ ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
   size_t readAmount = availableReadData;
   lastRingBufferSize = availableReadData;
   if (readAmount >= ringBuffer.getMaxSize()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     // Possible configuration error, too much data or/and data coming in too fast,
     // requiring larger buffers
-    FSFW_LOGWT("handleTcRingBufferData: Ring buffer reached fill count\n");
+    sif::warning << "TcpTmTcServer::handleServerOperation: Ring buffer reached "
+                 << "fill count" << std::endl;
+#else
+    sif::printWarning(
+        "TcpTmTcServer::handleServerOperation: Ring buffer reached "
+        "fill count");
+#endif
+#endif
   }
   if (readAmount >= receptionBuffer.size()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
     // Possible configuration error, too much data or/and data coming in too fast,
     // requiring larger buffers
-    FSFW_LOGWT("handleTcRingBufferData: Reception buffer too small\n");
+    sif::warning << "TcpTmTcServer::handleServerOperation: "
+                    "Reception buffer too small "
+                 << std::endl;
+#else
+    sif::printWarning("TcpTmTcServer::handleServerOperation: Reception buffer too small\n");
+#endif
+#endif
     readAmount = receptionBuffer.size();
   }
   ringBuffer.readData(receptionBuffer.data(), readAmount, true);

src/fsfw/osal/common/UdpTcPollingTask.cpp

@@ -4,7 +4,7 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/osal/common/tcpipHelpers.h"
 #include "fsfw/platform.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #ifdef PLATFORM_WIN
 #include <winsock2.h>
@@ -51,7 +51,9 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
                  receptionFlags, &senderAddress, &senderAddressSize);
     if (bytesReceived == SOCKET_ERROR) {
       /* Handle error */
-      FSFW_LOGW("performOperation: Reception error\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "UdpTcPollingTask::performOperation: Reception error." << std::endl;
+#endif
       tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::RECVFROM_CALL, 1000);
       continue;
     }
@@ -79,7 +81,12 @@ ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
   ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRead);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("handleSuccessfullTcRead: Data storage failed. Packet size {}\n", bytesRead);
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UdpTcPollingTask::transferPusToSoftwareBus: Data storage failed." << std::endl;
+    sif::warning << "Packet size: " << bytesRead << std::endl;
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
@@ -87,7 +94,13 @@ ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 
   result = MessageQueueSenderIF::sendMessage(targetTcDestination, &message);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGWT("handleSuccessfullTcRead: Sending message to queue failed\n");
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UdpTcPollingTask::handleSuccessfullTcRead: "
+                    " Sending message to queue failed"
+                 << std::endl;
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
     tcStore->deleteData(storeId);
   }
   return result;
@@ -96,13 +109,17 @@ ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 ReturnValue_t UdpTcPollingTask::initialize() {
   tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
   if (tcStore == nullptr) {
-    FSFW_LOGE("initialize: TC store uninitialized\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UdpTcPollingTask::initialize: TC store uninitialized!" << std::endl;
+#endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
   tmtcBridge = ObjectManager::instance()->get<UdpTmTcBridge>(tmtcBridgeId);
   if (tmtcBridge == nullptr) {
-    FSFW_LOGE("initialize: Invalid TMTC bridge object\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UdpTcPollingTask::initialize: Invalid TMTC bridge object!" << std::endl;
+#endif
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
@@ -141,7 +158,11 @@ void UdpTcPollingTask::setTimeout(double timeoutSeconds) {
   tval = timevalOperations::toTimeval(timeoutSeconds);
   int result = setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof(receptionTimeout));
   if (result == -1) {
-    FSFW_LOGW("setTimeout: Setting receive timeout failed with {} | {}", errno, strerror(errno));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting "
+                  "receive timeout failed with "
+               << strerror(errno) << std::endl;
+#endif
   }
 #endif
 }

src/fsfw/osal/common/UdpTmTcBridge.cpp

@@ -3,7 +3,7 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/common/tcpipHelpers.h"
 #include "fsfw/platform.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #ifdef PLATFORM_WIN
 #include <ws2tcpip.h>
@@ -36,11 +36,13 @@ UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
 ReturnValue_t UdpTmTcBridge::initialize() {
   ReturnValue_t result = TmTcBridge::initialize();
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    FSFW_LOGE("initialize: TmTcBridge initialization failed\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UdpTmTcBridge::initialize: TmTcBridge initialization failed!" << std::endl;
+#endif
     return result;
   }
 
-#ifdef PLATFORM_WIN
+#ifdef _WIN32
   /* Initiates Winsock DLL. */
   WSAData wsaData;
   WORD wVersionRequested = MAKEWORD(2, 2);
@@ -118,7 +120,9 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
   ssize_t bytesSent = sendto(serverSocket, reinterpret_cast<const char *>(data), dataLen, flags,
                              &clientAddress, clientAddressLen);
   if (bytesSent == SOCKET_ERROR) {
-    FSFW_LOGWT("sendTm: Send operation failed\n");
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TmTcUdpBridge::sendTm: Send operation failed." << std::endl;
+#endif
     tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
   }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1

src/fsfw/osal/common/tcpipCommon.cpp

@@ -1,9 +1,7 @@
 #include "fsfw/osal/common/tcpipCommon.h"
 
-#include <cerrno>
-
 #include "fsfw/platform.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #ifdef PLATFORM_WIN
 #include <ws2tcpip.h>
@@ -50,20 +48,28 @@ void tcpip::printAddress(struct sockaddr *addr) {
   const char *stringPtr = NULL;
   switch (addr->sa_family) {
     case AF_INET: {
-      auto *addrIn = reinterpret_cast<struct sockaddr_in *>(addr);
+      struct sockaddr_in *addrIn = reinterpret_cast<struct sockaddr_in *>(addr);
       stringPtr = inet_ntop(AF_INET, &(addrIn->sin_addr), ipAddress, INET_ADDRSTRLEN);
       break;
     }
     case AF_INET6: {
-      auto *addrIn = reinterpret_cast<struct sockaddr_in6 *>(addr);
+      struct sockaddr_in6 *addrIn = reinterpret_cast<struct sockaddr_in6 *>(addr);
       stringPtr = inet_ntop(AF_INET6, &(addrIn->sin6_addr), ipAddress, INET6_ADDRSTRLEN);
       break;
     }
   }
-  if (stringPtr == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-    FSFW_LOGDT("Could not convert IP address to text representation, error code {} | {}", errno,
+  if (stringPtr == NULL) {
-               strerror(errno));
+    sif::debug << "Could not convert IP address to text representation, error code " << errno
+               << std::endl;
   } else {
-    FSFW_LOGDT("IP Address Sender {}\n", ipAddress);
+    sif::debug << "IP Address Sender: " << ipAddress << std::endl;
   }
+#else
+  if (stringPtr == NULL) {
+    sif::printDebug("Could not convert IP address to text representation, error code %d\n", errno);
+  } else {
+    sif::printDebug("IP Address Sender: %s\n", ipAddress);
+  }
+#endif
 }

src/fsfw/osal/freertos/BinSemaphUsingTask.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/osal/freertos/BinSemaphUsingTask.h"
 
 #include "fsfw/osal/freertos/TaskManagement.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || tskKERNEL_VERSION_MAJOR > 8
 

src/fsfw/osal/freertos/BinarySemaphore.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/osal/freertos/BinarySemaphore.h"
 
 #include "fsfw/osal/freertos/TaskManagement.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 BinarySemaphore::BinarySemaphore() {
   handle = xSemaphoreCreateBinary();

src/fsfw/osal/freertos/CMakeLists.txt

@@ -1,32 +1,30 @@
-target_sources(${LIB_FSFW_NAME} 
+target_sources(
-	PRIVATE 
+  ${LIB_FSFW_NAME}
-		Clock.cpp
+  PRIVATE Clock.cpp
-		FixedTimeslotTask.cpp
+          FixedTimeslotTask.cpp
-		BinarySemaphore.cpp
+          BinarySemaphore.cpp
-		BinSemaphUsingTask.cpp
+          BinSemaphUsingTask.cpp
-		CountingSemaphore.cpp
+          CountingSemaphore.cpp
-		CountingSemaphUsingTask.cpp
+          CountingSemaphUsingTask.cpp
-		MessageQueue.cpp
+          MessageQueue.cpp
-		Mutex.cpp
+          Mutex.cpp
-		MutexFactory.cpp
+          MutexFactory.cpp
-		PeriodicTask.cpp
+          PeriodicTask.cpp
-		QueueFactory.cpp
+          QueueFactory.cpp
-		SemaphoreFactory.cpp
+          SemaphoreFactory.cpp
-		TaskFactory.cpp
+          TaskFactory.cpp
-		Timekeeper.cpp
+          Timekeeper.cpp
-		TaskManagement.cpp
+          TaskManagement.cpp
-		QueueMapManager.cpp
+          QueueMapManager.cpp)
-)
 
-# FreeRTOS is required to link the FSFW now. It is recommended to compile 
+# FreeRTOS is required to link the FSFW now. It is recommended to compile
-# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the 
+# FreeRTOS as a static library and set LIB_OS_NAME to the target name of the
 # library.
 if(NOT LIB_OS_NAME)
-	message(STATUS
+  message(
-		"LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
+    STATUS
-	)
+      "LIB_OS_NAME is empty. Make sure to include the FreeRTOS header path properly."
+  )
 else()
-    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+  target_link_libraries(${LIB_FSFW_NAME} PRIVATE ${LIB_OS_NAME})
-        ${LIB_OS_NAME}
-    )
 endif()

src/fsfw/osal/freertos/CountingSemaphUsingTask.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/osal/freertos/CountingSemaphUsingTask.h"
 
 #include "fsfw/osal/freertos/TaskManagement.h"
-#include "fsfw/serviceinterface.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #if (tskKERNEL_VERSION_MAJOR == 8 && tskKERNEL_VERSION_MINOR > 2) || tskKERNEL_VERSION_MAJOR > 8