format adapted

Reviewed-on: fsfw/fsfw#445

CMakeLists.txt

@@ -10,6 +10,7 @@ endif()
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
+option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)
 
 # Optional sources
 option(FSFW_ADD_PUS "Compile with PUS sources" ON)
@@ -21,7 +22,7 @@ option(FSFW_ADD_COORDINATES "Compile with coordinate components" OFF)
 option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 
 # Contrib sources
-option(FSFW_ADD_SPG4_PROPAGATOR "Add SPG4 propagator code" OFF)
+option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
@@ -94,7 +95,9 @@ message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
 add_subdirectory(src)
 add_subdirectory(tests)
-add_subdirectory(hal)
+if(FSFW_ADD_HAL)
+    add_subdirectory(hal)
+endif()
 add_subdirectory(contrib)
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.

README.md

@@ -1,4 +1,4 @@
-![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+![FSFW Logo](misc/logo/FSFW_Logo_V3_bw.png)
 
 # Flight Software Framework (FSFW)
 

contrib/CMakeLists.txt

@@ -1,11 +1,9 @@
-if(FSFW_ADD_SPG4_PROPAGATOR)
-    target_sources(${LIB_FSFW_NAME} PRIVATE
-        sgp4/sgp4unit.cpp
-    )
-    target_include_directories(${LIB_FSFW_NAME} PRIVATE
-        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
-    )
-    target_include_directories(${LIB_FSFW_NAME} INTERFACE
-        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
-    )
-endif()
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw_contrib)

contrib/fsfw_contrib/CMakeLists.txt

@@ -0,0 +1,11 @@
+if(FSFW_ADD_SGP4_PROPAGATOR)
+    target_sources(${LIB_FSFW_NAME} PRIVATE
+        sgp4/sgp4unit.cpp
+    )
+    target_include_directories(${LIB_FSFW_NAME} PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
+    )
+    target_include_directories(${LIB_FSFW_NAME} INTERFACE
+        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
+    )
+endif()

hal/src/CMakeLists.txt

@@ -6,4 +6,4 @@ target_include_directories(${LIB_FSFW_NAME} INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-add_subdirectory(fsfw)
+add_subdirectory(fsfw_hal)

hal/src/fsfw/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(hal)

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 GpioCookie::GpioCookie() {

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/hal/devicehandlers/GyroL3GD20Handler.h"
+#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
 
 #include "fsfw/datapool/PoolReadGuard.h"
 

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h

@@ -1,14 +1,14 @@
 #ifndef MISSION_DEVICES_GYROL3GD20HANDLER_H_
 #define MISSION_DEVICES_GYROL3GD20HANDLER_H_
 
-#include "OBSWConfig.h"
+#include "fsfw/FSFW.h"
 #include "devicedefinitions/GyroL3GD20Definitions.h"
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 
 #ifndef FSFW_HAL_L3GD20_GYRO_DEBUG
-#define FSFW_HAL_L3GD20_GYRO_DEBUG   1
+#define FSFW_HAL_L3GD20_GYRO_DEBUG   0
 #endif /* FSFW_HAL_L3GD20_GYRO_DEBUG */
 
 /**

hal/src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -1,4 +1,9 @@
-#include "fsfw/hal/linux/UnixFileGuard.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+
+#include <cerrno>
+#include <cstring>
 
 UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
         std::string diagnosticPrefix):
@@ -10,12 +15,11 @@ UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
     if (*fileDescriptor < 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << diagnosticPrefix <<"Opening device failed with error code " << errno <<
-                "." << std::endl;
-        sif::warning << "Error description: " << strerror(errno) << std::endl;
+        sif::warning << diagnosticPrefix << ": Opening device failed with error code " <<
+                errno << ": " << strerror(errno) << std::endl;
 #else
-        sif::printError("%sOpening device failed with error code %d.\n", diagnosticPrefix);
-        sif::printWarning("Error description: %s\n", strerror(errno));
+        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/gpio/LinuxLibgpioIF.cpp

@@ -1,6 +1,6 @@
-#include "fsfw/hal/linux/gpio/LinuxLibgpioIF.h"
-#include "fsfw/hal/common/gpio/gpioDefinitions.h"
-#include "fsfw/hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
 
 #include <fsfw/serviceinterface/ServiceInterface.h>
 

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

@@ -1,6 +1,6 @@
-#include "fsfw/hal/linux/i2c/I2cComIF.h"
-#include "fsfw/hal/linux/utility.h"
-#include "fsfw/hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/i2c/I2cComIF.h"
+#include "fsfw_hal/linux/utility.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/linux/i2c/I2cCookie.h"
+#include "fsfw_hal/linux/i2c/I2cCookie.h"
 
 I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
 		std::string deviceFile_) :

hal/src/fsfw_hal/linux/rpi/GpioRPi.cpp

@@ -1,7 +1,7 @@
 #include "fsfw/FSFW.h"
 
-#include "fsfw/hal/linux/rpi/GpioRPi.h"
-#include "fsfw/hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
 
 #include <fsfw/serviceinterface/ServiceInterface.h>
 

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

@@ -1,8 +1,8 @@
 #include "fsfw/FSFW.h"
-#include "fsfw/hal/linux/spi/SpiComIF.h"
-#include "fsfw/hal/linux/spi/SpiCookie.h"
-#include "fsfw/hal/linux/utility.h"
-#include "fsfw/hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/spi/SpiComIF.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+#include "fsfw_hal/linux/utility.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
 
 #include <fsfw/ipc/MutexFactory.h>
 #include <fsfw/globalfunctions/arrayprinter.h>
@@ -82,7 +82,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
         gpioComIF->pullHigh(gpioId);
     }
 
-    size_t spiSpeed = 0;
+    uint32_t spiSpeed = 0;
     spi::SpiModes spiMode = spi::SpiModes::MODE_0;
 
     SpiCookie::UncommonParameters params;
@@ -184,7 +184,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie *spiCookie, const
     /* Prepare transfer */
     int fileDescriptor = 0;
     std::string device = spiCookie->getSpiDevice();
-    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage: ");
+    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
     if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
         return OPENING_FILE_FAILED;
     }
@@ -273,7 +273,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
     std::string device = spiCookie->getSpiDevice();
     int fileDescriptor = 0;
     UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR,
-            "SpiComIF::requestReceiveMessage: ");
+            "SpiComIF::requestReceiveMessage");
     if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
         return OPENING_FILE_FAILED;
     }

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

@@ -3,7 +3,7 @@
 
 #include "spiDefinitions.h"
 #include "returnvalues/classIds.h"
-#include "fsfw/hal/common/gpio/GpioIF.h"
+#include "fsfw_hal/common/gpio/GpioIF.h"
 
 #include "fsfw/devicehandlers/DeviceCommunicationIF.h"
 #include "fsfw/objectmanager/SystemObject.h"

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/linux/spi/SpiCookie.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
 
 SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
         const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed):

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
 #include "OBSWConfig.h"
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -443,6 +443,60 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF *cookie,
     return RETURN_OK;
 }
 
+ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartRxBuffer: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCIFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
+ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartTxBuffer: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCOFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
+ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartTxAndRxBuf: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCIOFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
 void UartComIF::setUartMode(struct termios *options, UartCookie &uartCookie) {
     UartModes uartMode = uartCookie.getUartMode();
     if(uartMode == UartModes::NON_CANONICAL) {

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

@@ -41,6 +41,21 @@ public:
     ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
             size_t *size) override;
 
+    /**
+     * @brief   This function discards all data received but not read in the UART buffer.
+     */
+    ReturnValue_t flushUartRxBuffer(CookieIF *cookie);
+
+    /**
+     * @brief   This function discards all data in the transmit buffer of the UART driver.
+     */
+    ReturnValue_t flushUartTxBuffer(CookieIF *cookie);
+
+    /**
+     * @brief   This function discards both data in the transmit and receive buffer of the UART.
+     */
+    ReturnValue_t flushUartTxAndRxBuf(CookieIF *cookie);
+
 private:
 
     using UartDeviceFile_t = std::string;

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/linux/uart/UartCookie.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
 
 #include <fsfw/serviceinterface/ServiceInterface.h>
 

hal/src/fsfw_hal/linux/utility.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/FSFW.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/hal/linux/utility.h"
+#include "fsfw_hal/linux/utility.h"
 
 #include <cerrno>
 #include <cstring>

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

@@ -1,10 +1,10 @@
-#include "fsfw/hal/stm32h7/devicetest/GyroL3GD20H.h"
+#include "fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h"
 
-#include "fsfw/hal/stm32h7/spi/mspInit.h"
-#include "fsfw/hal/stm32h7/spi/spiDefinitions.h"
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
-#include "fsfw/hal/stm32h7/spi/spiInterrupts.h"
-#include "fsfw/hal/stm32h7/spi/stm32h743ziSpi.h"
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
 
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

hal/src/fsfw_hal/stm32h7/dma.cpp

@@ -1,4 +1,4 @@
-#include <fsfw/hal/stm32h7/dma.h>
+#include <fsfw_hal/stm32h7/dma.h>
 
 #include <cstdint>
 #include <cstddef>

hal/src/fsfw_hal/stm32h7/gpio/gpio.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/hal/stm32h7/gpio/gpio.h"
+#include "fsfw_hal/stm32h7/gpio/gpio.h"
 
 #include "stm32h7xx_hal_rcc.h"
 

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

@@ -1,11 +1,11 @@
-#include "fsfw/hal/stm32h7/spi/SpiComIF.h"
-#include "fsfw/hal/stm32h7/spi/SpiCookie.h"
+#include "fsfw_hal/stm32h7/spi/SpiComIF.h"
+#include "fsfw_hal/stm32h7/spi/SpiCookie.h"
 
 #include "fsfw/tasks/SemaphoreFactory.h"
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
-#include "fsfw/hal/stm32h7/spi/spiInterrupts.h"
-#include "fsfw/hal/stm32h7/spi/mspInit.h"
-#include "fsfw/hal/stm32h7/gpio/gpio.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/gpio/gpio.h"
 
 // FreeRTOS required special Semaphore handling from an ISR. Therefore, we use the concrete
 // instance here, because RTEMS and FreeRTOS are the only relevant OSALs currently

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

@@ -5,7 +5,7 @@
 #include "fsfw/devicehandlers/DeviceCommunicationIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 
-#include "fsfw/hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
 #include "stm32h7xx_hal_spi.h"
 #include "stm32h743xx.h"
 

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

@@ -1,4 +1,4 @@
-#include "fsfw/hal/stm32h7/spi/SpiCookie.h"
+#include "fsfw_hal/stm32h7/spi/SpiCookie.h"
 
 
 SpiCookie::SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferModes transferMode,

hal/src/fsfw_hal/stm32h7/spi/mspInit.cpp

@@ -1,7 +1,7 @@
-#include "fsfw/hal/stm32h7/dma.h"
-#include "fsfw/hal/stm32h7/spi/mspInit.h"
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
-#include "fsfw/hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/dma.h"
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
 
 #include "stm32h743xx.h"
 #include "stm32h7xx_hal_spi.h"

hal/src/fsfw_hal/stm32h7/spi/spiCore.cpp

@@ -1,5 +1,5 @@
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
-#include "fsfw/hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
 
 #include <cstdio>
 

hal/src/fsfw_hal/stm32h7/spi/spiCore.h

@@ -1,8 +1,8 @@
 #ifndef FSFW_HAL_STM32H7_SPI_SPICORE_H_
 #define FSFW_HAL_STM32H7_SPI_SPICORE_H_
 
-#include "fsfw/hal/stm32h7/dma.h"
-#include "fsfw/hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/dma.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
 
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_dma.h"

hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
 
 void spi::assignSpiMode(SpiModes spiMode, SPI_HandleTypeDef& spiHandle) {
     switch(spiMode) {

hal/src/fsfw_hal/stm32h7/spi/spiInterrupts.cpp

@@ -1,5 +1,5 @@
-#include "fsfw/hal/stm32h7/spi/spiInterrupts.h"
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
 
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_dma.h"

hal/src/fsfw_hal/stm32h7/spi/stm32h743ziSpi.cpp

@@ -1,6 +1,6 @@
-#include "fsfw/hal/stm32h7/spi/stm32h743ziSpi.h"
-#include "fsfw/hal/stm32h7/spi/spiCore.h"
-#include "fsfw/hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
 
 #include "stm32h7xx_hal.h"
 #include "stm32h7xx_hal_rcc.h"

misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp

@@ -4,7 +4,7 @@
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
+#include <fsfw/tmtcpacket/pus/tm/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <fsfw/internalError/InternalErrorReporter.h>

src/fsfw/FSFW.h.in

@@ -9,5 +9,10 @@
 #cmakedefine FSFW_ADD_COORDINATES
 #cmakedefine FSFW_ADD_PUS
 #cmakedefine FSFW_ADD_MONITORING
+#cmakedefine FSFW_ADD_SGP4_PROPAGATOR
+
+#ifndef FSFW_HAL_L3GD20_GYRO_DEBUG
+#define FSFW_HAL_L3GD20_GYRO_DEBUG   0
+#endif /* FSFW_HAL_L3GD20_GYRO_DEBUG */
 
 #endif /* FSFW_FSFW_H_ */

src/fsfw/coordinates/Sgp4Propagator.h

@@ -7,7 +7,7 @@
 #ifndef PLATFORM_WIN
 #include <sys/time.h>
 #endif
-#include "fsfw/contrib/sgp4/sgp4unit.h"
+#include "fsfw_contrib/sgp4/sgp4unit.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class Sgp4Propagator {

src/fsfw/coordinates/coordinatesConf.h

@@ -8,4 +8,9 @@
     not enabled with FSFW_ADD_COORDINATES
 #endif
 
+#ifndef FSFW_ADD_SGP4_PROPAGATOR
+#warning Coordinates files were included but SGP4 contributed code compilation was \
+    not enabled with FSFW_ADD_SGP4_PROPAGATOR
+#endif
+
 #endif /* FSFW_SRC_FSFW_COORDINATES_COORDINATESCONF_H_ */

src/fsfw/events/EventManager.cpp

@@ -12,119 +12,119 @@ MessageQueueId_t EventManagerIF::eventmanagerQueue = MessageQueueIF::NO_QUEUE;
 // So a good guess is 75 to a max of 100 pools required for each, which fits well.
 const LocalPool::LocalPoolConfig EventManager::poolConfig = {
         {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
-        		sizeof(EventMatchTree::Node)},
+                sizeof(EventMatchTree::Node)},
         {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS,
-        		sizeof(EventIdRangeMatcher)},
+                sizeof(EventIdRangeMatcher)},
         {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS,
-        		sizeof(ReporterRangeMatcher)}
+                sizeof(ReporterRangeMatcher)}
 };
 
 EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId),
-		factoryBackend(0, poolConfig, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
+        SystemObject(setObjectId),
+        factoryBackend(0, poolConfig, false, true) {
+    mutex = MutexFactory::instance()->createMutex();
+    eventReportQueue = QueueFactory::instance()->createMessageQueue(
+            MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
 }
 
 EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
+    QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
+    MutexFactory::instance()->deleteMutex(mutex);
 }
 
 MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
+    return eventReportQueue->getId();
 }
 
 ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    while (result == HasReturnvaluesIF::RETURN_OK) {
+        EventMessage message;
+        result = eventReportQueue->receiveMessage(&message);
+        if (result == HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
-			printEvent(&message);
+            printEvent(&message);
 #endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+            notifyListeners(&message);
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-					message->getSender());
-		}
-	}
-	unlockMutex();
+    lockMutex();
+    for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+        if (iter->second.match(message)) {
+            MessageQueueSenderIF::sendMessage(iter->first, message,
+                    message->getSender());
+        }
+    }
+    unlockMutex();
 }
 
 ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
 bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    auto result = listenerList.insert(
+            std::pair<MessageQueueId_t, EventMatchTree>(listener,
+                    EventMatchTree(&factoryBackend, forwardAllButSelected)));
+    if (!result.second) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
+        EventId_t event) {
+    return subscribeToEventRange(listener, event);
 }
 
 ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
+        object_id_t object) {
+    return subscribeToEventRange(listener, 0, 0, true, object);
 }
 
 ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
+        EventId_t idFrom, EventId_t idTo, bool idInverted,
+        object_id_t reporterFrom, object_id_t reporterTo,
+        bool reporterInverted) {
+    auto iter = listenerList.find(listener);
+    if (iter == listenerList.end()) {
+        return LISTENER_NOT_FOUND;
+    }
+    lockMutex();
+    ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
+            reporterFrom, reporterTo, reporterInverted);
+    unlockMutex();
+    return result;
 }
 
 ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
+        EventId_t idFrom, EventId_t idTo, bool idInverted,
+        object_id_t reporterFrom, object_id_t reporterTo,
+        bool reporterInverted) {
+    auto iter = listenerList.find(listener);
+    if (iter == listenerList.end()) {
+        return LISTENER_NOT_FOUND;
+    }
+    lockMutex();
+    ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
+            reporterFrom, reporterTo, reporterInverted);
+    unlockMutex();
+    return result;
 }
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(timeoutType, timeoutMs);
+    mutex->lockMutex(timeoutType, timeoutMs);
 }
 
 void EventManager::unlockMutex() {
-	mutex->unlockMutex();
+    mutex->unlockMutex();
 }
 
 void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
-		uint32_t timeoutMs) {
-	this->timeoutType = timeoutType;
-	this->timeoutMs = timeoutMs;
+        uint32_t timeoutMs) {
+    this->timeoutType = timeoutType;
+    this->timeoutMs = timeoutMs;
 }
 
 #if FSFW_OBJ_EVENT_TRANSLATION == 1
@@ -157,7 +157,7 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage *messag
                     message->getReporter() << std::setfill(' ') << std::dec;
         }
         sif::info << " reported event with ID " << message->getEventId() << std::endl;
-        sif::debug << translateEvents(message->getEvent()) << " | " <<std::hex << "P1 Hex: 0x" <<
+        sif::info << translateEvents(message->getEvent()) << " | " <<std::hex << "P1 Hex: 0x" <<
                 message->getParameter1() << " | P1 Dec: " << std::dec << message->getParameter1() <<
                 std::hex << " | P2 Hex: 0x" << message->getParameter2() << " | P2 Dec: " <<
                 std::dec << message->getParameter2() << std::endl;
@@ -170,9 +170,10 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage *messag
             sif::printInfo("Event Manager: Reporter ID 0x%08x reported event with ID %d\n",
                     message->getReporter(), message->getEventId());
         }
-        sif::printInfo("P1 Hex: 0x%x | P1 Dec: %d | P2 Hex: 0x%x | P2 Dec: %d\n",
-                message->getParameter1(), message->getParameter1(),
-                message->getParameter2(), message->getParameter2());
+
+        sif::printInfo("%s | P1 Hex: 0x%x | P1 Dec: %d | P2 Hex: 0x%x | P2 Dec: %d\n",
+                translateEvents(message->getEvent()), message->getParameter1(),
+                message->getParameter1(), message->getParameter2(), message->getParameter2());
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 0 */
     }
     else {

src/fsfw/osal/freertos/MessageQueue.h

@@ -11,7 +11,6 @@
 #include "FreeRTOS.h"
 #include "queue.h"
 
-
 /**
  * @brief		This class manages sending and receiving of
  * 				message queue messages.

src/fsfw/osal/linux/unixUtility.cpp

@@ -14,7 +14,7 @@ void utility::printUnixErrorGeneric(const char* const className,
 #if FSFW_VERBOSE_LEVEL >= 1
     if(outputType == sif::OutputTypes::OUT_ERROR) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << className << "::" << function << ":"  << failString << " error: "
+    sif::error << className << "::" << function << ": "  << failString << " error: "
             << strerror(errno)  << std::endl;
 #else
     sif::printError("%s::%s: %s error: %s\n", className, function, failString, strerror(errno));
@@ -22,7 +22,7 @@ void utility::printUnixErrorGeneric(const char* const className,
     }
     else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << className << "::" << function << ":"  << failString << " error: "
+    sif::warning << className << "::" << function << ": "  << failString << " error: "
             << strerror(errno)  << std::endl;
 #else
     sif::printWarning("%s::%s: %s error: %s\n", className, function, failString, strerror(errno));

src/fsfw/serviceinterface/ServiceInterface.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 #define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
 
-#include <FSFWConfig.h>
+#include "fsfw/FSFW.h"
 #include "serviceInterfaceDefintions.h"
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1

src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp

@@ -146,8 +146,8 @@ std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 #endif
 
 	int32_t charCount = sprintf(parsePosition,
-			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
-					this->logMessage.c_str(), loggerTime.hour,
+			"%s%s | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), sif::ANSI_COLOR_RESET, loggerTime.hour,
 					loggerTime.minute,
 					loggerTime.second,
 					loggerTime.usecond /1000);
@@ -171,9 +171,11 @@ bool ServiceInterfaceBuffer::crAdditionEnabled() const {
     return addCrToPreamble;
 }
 
+#if FSFW_COLORED_OUTPUT == 1
 void ServiceInterfaceBuffer::setAsciiColorPrefix(std::string colorPrefix) {
-    this->colorPrefix = colorPrefix;
+	this->colorPrefix = colorPrefix;
 }
+#endif
 
 #ifdef UT699
 #include "../osal/rtems/Interrupt.h"

src/fsfw/serviceinterface/ServiceInterfacePrinter.cpp

@@ -56,25 +56,29 @@ void fsfwPrint(sif::PrintLevel printType, const char* fmt, va_list arg) {
 #endif
 
    if (printType == sif::PrintLevel::INFO_LEVEL) {
-       len += sprintf(bufferPosition + len, "INFO: ");
+       len += sprintf(bufferPosition + len, "INFO");
    }
    if(printType == sif::PrintLevel::DEBUG_LEVEL) {
-	   len += sprintf(bufferPosition + len, "DEBUG: ");
+	   len += sprintf(bufferPosition + len, "DEBUG");
    }
    if(printType == sif::PrintLevel::WARNING_LEVEL) {
-	   len += sprintf(bufferPosition + len, "WARNING: ");
+	   len += sprintf(bufferPosition + len, "WARNING");
    }
 
    if(printType == sif::PrintLevel::ERROR_LEVEL) {
-	   len += sprintf(bufferPosition + len, "ERROR: ");
+	   len += sprintf(bufferPosition + len, "ERROR");
    }
 
+#if FSFW_COLORED_OUTPUT == 1
+   len += sprintf(bufferPosition + len, sif::ANSI_COLOR_RESET);
+#endif
+
     Clock::TimeOfDay_t now;
     Clock::getDateAndTime(&now);
     /*
      * Log current time to terminal if desired.
      */
-    len += sprintf(bufferPosition + len, "| %lu:%02lu:%02lu.%03lu | ",
+    len += sprintf(bufferPosition + len, " | %lu:%02lu:%02lu.%03lu | ",
     		(unsigned long) now.hour,
 			(unsigned long) now.minute,
 			(unsigned long) now.second,

src/fsfw/serviceinterface/ServiceInterfaceStream.cpp

@@ -19,9 +19,11 @@ bool ServiceInterfaceStream::crAdditionEnabled() const {
     return streambuf.crAdditionEnabled();
 }
 
+#if FSFW_COLORED_OUTPUT == 1
 void ServiceInterfaceStream::setAsciiColorPrefix(std::string asciiColorCode) {
     streambuf.setAsciiColorPrefix(asciiColorCode);
 }
+#endif
 
 #endif
 

src/fsfw/serviceinterface/ServiceInterfaceStream.h

@@ -46,7 +46,9 @@ public:
 	 */
 	bool crAdditionEnabled() const;
 
+#if FSFW_COLORED_OUTPUT == 1
 	void setAsciiColorPrefix(std::string asciiColorCode);
+#endif
 
 protected:
 	ServiceInterfaceBuffer streambuf;

tests/src/CMakeLists.txt

@@ -6,4 +6,4 @@ target_include_directories(${LIB_FSFW_NAME} INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-add_subdirectory(fsfw)
+add_subdirectory(fsfw_tests)

tests/src/fsfw/CMakeLists.txt

@@ -1 +0,0 @@
-add_subdirectory(tests)

tests/src/fsfw_tests/internal/InternalUnitTester.cpp

@@ -1,11 +1,11 @@
-#include "fsfw/tests/internal/InternalUnitTester.h"
-#include "fsfw/tests/internal/UnittDefinitions.h"
+#include "fsfw_tests/internal/InternalUnitTester.h"
+#include "fsfw_tests/internal/UnittDefinitions.h"
 
-#include "fsfw/tests/internal/osal/IntTestMq.h"
-#include "fsfw/tests/internal/osal/IntTestSemaphore.h"
-#include "fsfw/tests/internal/osal/IntTestMutex.h"
-#include "fsfw/tests/internal/serialize/IntTestSerialization.h"
-#include "fsfw/tests/internal/globalfunctions/TestArrayPrinter.h"
+#include "fsfw_tests/internal/osal/IntTestMq.h"
+#include "fsfw_tests/internal/osal/IntTestSemaphore.h"
+#include "fsfw_tests/internal/osal/IntTestMutex.h"
+#include "fsfw_tests/internal/serialize/IntTestSerialization.h"
+#include "fsfw_tests/internal/globalfunctions/TestArrayPrinter.h"
 
 #include <cstdlib>
 

tests/src/fsfw_tests/internal/UnittDefinitions.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/tests/internal/UnittDefinitions.h"
+#include "fsfw_tests/internal/UnittDefinitions.h"
 
  ReturnValue_t unitt::put_error(std::string errorId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

tests/src/fsfw_tests/internal/globalfunctions/TestArrayPrinter.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/tests/internal/globalfunctions/TestArrayPrinter.h"
+#include "fsfw_tests/internal/globalfunctions/TestArrayPrinter.h"
 
 void arrayprinter::testArrayPrinter() {
     {