Merge pull request 'meier/halAdjustments' (#32) from meier/halAdjustments into eive/develop

Reviewed-on: eive/fsfw#32

hal/CMakeLists.txt

@@ -9,6 +9,7 @@ option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Requires gpiod libr
 # Linux. The only exception from this is the gpiod library which requires a dedicated installation,
 # but CMake is able to determine whether this library is installed with find_library.
 option(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS "Add peripheral drivers for embedded Linux" ON)
+option(FSFW_HAL_LINUX_ADD_LIBGPIOD "Target implements libgpiod" ON)
 
 option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
 option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)

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

@@ -11,7 +11,7 @@ namespace gpio {
 
 enum Levels : uint8_t { LOW = 0, HIGH = 1, NONE = 99 };
 
-enum Direction : uint8_t { IN = 0, OUT = 1 };
+enum Direction : uint8_t { DIR_IN = 0, DIR_OUT = 1 };
 
 enum GpioOperation { READ, WRITE };
 
@@ -20,7 +20,7 @@ enum class GpioTypes {
   GPIO_REGULAR_BY_CHIP,
   GPIO_REGULAR_BY_LABEL,
   GPIO_REGULAR_BY_LINE_NAME,
-  CALLBACK
+  TYPE_CALLBACK
 };
 
 static constexpr gpioId_t NO_GPIO = -1;
@@ -57,7 +57,7 @@ class GpioBase {
   // Can be used to cast GpioBase to a concrete child implementation
   gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
   std::string consumer;
-  gpio::Direction direction = gpio::Direction::IN;
+  gpio::Direction direction = gpio::Direction::DIR_IN;
   gpio::Levels initValue = gpio::Levels::NONE;
 };
 
@@ -79,8 +79,8 @@ class GpiodRegularBase : public GpioBase {
 class GpiodRegularByChip : public GpiodRegularBase {
  public:
   GpiodRegularByChip()
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(), gpio::Direction::IN,
-                         gpio::LOW, 0) {}
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, std::string(),
+                         gpio::Direction::DIR_IN, gpio::LOW, 0) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
                      gpio::Direction direction_, gpio::Levels initValue_)
@@ -89,7 +89,7 @@ class GpiodRegularByChip : public GpiodRegularBase {
         chipname(chipname_) {}
 
   GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_, gpio::Direction::DIR_IN,
                          gpio::LOW, lineNum_),
         chipname(chipname_) {}
 
@@ -105,7 +105,7 @@ class GpiodRegularByLabel : public GpiodRegularBase {
         label(label_) {}
 
   GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::IN,
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_, gpio::Direction::DIR_IN,
                          gpio::LOW, lineNum_),
         label(label_) {}
 
@@ -126,8 +126,8 @@ class GpiodRegularByLineName : public GpiodRegularBase {
         lineName(lineName_) {}
 
   GpiodRegularByLineName(std::string lineName_, std::string consumer_)
-      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_, gpio::Direction::IN,
-                         gpio::LOW),
+      : GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_,
+                         gpio::Direction::DIR_IN, gpio::LOW),
         lineName(lineName_) {}
 
   std::string lineName;
@@ -137,7 +137,7 @@ class GpioCallback : public GpioBase {
  public:
   GpioCallback(std::string consumer, gpio::Direction direction_, gpio::Levels initValue_,
                gpio::gpio_cb_t callback, void* callbackArgs)
-      : GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
+      : GpioBase(gpio::GpioTypes::TYPE_CALLBACK, consumer, direction_, initValue_),
         callback(callback),
         callbackArgs(callbackArgs) {}
 

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -10,7 +10,7 @@ GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceC
       transitionDelayMs(transitionDelayMs),
       dataset(this) {
 #if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
 }
 

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -13,7 +13,7 @@ MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCom
       dataset(this),
       transitionDelay(transitionDelay) {
 #if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
   // Set to default values right away
   registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
@@ -264,7 +264,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       int16_t mgmMeasurementRawZ =
           packet[MGMLIS3MDL::Z_HIGHBYTE_IDX] << 8 | packet[MGMLIS3MDL::Z_LOWBYTE_IDX];
 
-      /* Target value in microtesla */
+      // Target value in microtesla
       float mgmX = static_cast<float>(mgmMeasurementRawX) * sensitivityFactor *
                    MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
       float mgmY = static_cast<float>(mgmMeasurementRawY) * sensitivityFactor *
@@ -462,7 +462,9 @@ ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() {
   return RETURN_OK;
 }
 
-void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {}
+void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+  DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
+}
 
 uint32_t MgmLIS3MDLHandler::getTransitionDelayMs(Mode_t from, Mode_t to) { return transitionDelay; }
 

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -12,7 +12,7 @@ MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommu
       primaryDataset(this),
       transitionDelay(transitionDelay) {
 #if FSFW_HAL_RM3100_MGM_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(3);
+  debugDivider = new PeriodicOperationDivider(10);
 #endif
 }
 

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -9,8 +9,12 @@ target_sources(${LIB_FSFW_NAME} PRIVATE
 )
 
 if(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS)
+if(FSFW_HAL_LINUX_ADD_LIBGPIOD)
 	add_subdirectory(gpio)
+endif()
 	add_subdirectory(spi)
 	add_subdirectory(i2c)
 	add_subdirectory(uart)
 endif()
+
+add_subdirectory(uio)

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

@@ -74,7 +74,7 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
         configureGpioByLineName(gpioConfig.first, *regularGpio);
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
         auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (gpioCallback->callback == nullptr) {
           return GPIO_INVALID_INSTANCE;
@@ -161,11 +161,11 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
   consumer = regularGpio.consumer;
   /* Configure direction and add a description to the GPIO */
   switch (direction) {
-    case (gpio::OUT): {
+    case (gpio::DIR_OUT): {
       result = gpiod_line_request_output(lineHandle, consumer.c_str(), regularGpio.initValue);
       break;
     }
-    case (gpio::IN): {
+    case (gpio::DIR_IN): {
       result = gpiod_line_request_input(lineHandle, consumer.c_str());
       break;
     }
@@ -326,7 +326,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd) {
         }
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
         auto callbackGpio = dynamic_cast<GpioCallback*>(gpioConfig.second);
         if (callbackGpio == nullptr) {
           return GPIO_TYPE_FAILURE;
@@ -366,13 +366,13 @@ ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
       case (gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
       case (gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
-        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::CALLBACK) {
+        if (gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::TYPE_CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
         break;
       }
-      case (gpio::GpioTypes::CALLBACK): {
-        if (gpioType != gpio::GpioTypes::CALLBACK) {
+      case (gpio::GpioTypes::TYPE_CALLBACK): {
+        if (gpioType != gpio::GpioTypes::TYPE_CALLBACK) {
           eraseDuplicateDifferentType = true;
         }
       }

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

@@ -1,4 +1,13 @@
-#include "fsfw_hal/linux/i2c/I2cComIF.h"
+#include "I2cComIF.h"
+
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/utility.h"
+
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+#include "fsfw/globalfunctions/arrayprinter.h"
+#endif
 
 #include <errno.h>
 #include <fcntl.h>
@@ -8,11 +17,6 @@
 
 #include <cstring>
 
-#include "fsfw/FSFW.h"
-#include "fsfw/serviceinterface.h"
-#include "fsfw_hal/linux/UnixFileGuard.h"
-#include "fsfw_hal/linux/utility.h"
-
 I2cComIF::I2cComIF(object_id_t objectId) : SystemObject(objectId) {}
 
 I2cComIF::~I2cComIF() {}
@@ -112,6 +116,11 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
+
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(sendData, sendLen);
+#endif
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -176,6 +185,11 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "I2C read bytes from bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(replyBuffer, requestLen);
+#endif
+
   i2cDeviceMapIter->second.replyLen = requestLen;
   return HasReturnvaluesIF::RETURN_OK;
 }

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

@@ -7,7 +7,7 @@
 
 ReturnValue_t gpio::createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
                                         std::string consumer, gpio::Direction direction,
-                                        int initValue) {
+                                        gpio::Levels initValue) {
   if (cookie == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }

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

@@ -21,7 +21,8 @@ namespace gpio {
  * @return
  */
 ReturnValue_t createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
-                                  std::string consumer, gpio::Direction direction, int initValue);
+                                  std::string consumer, gpio::Direction direction,
+                                  gpio::Levels initValue);
 }  // namespace gpio
 
 #endif /* BSP_RPI_GPIO_GPIORPI_H_ */

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

@@ -269,6 +269,50 @@ void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCooki
       cfsetispeed(options, B460800);
       cfsetospeed(options, B460800);
       break;
+    case 500000:
+      cfsetispeed(options, B500000);
+      cfsetospeed(options, B500000);
+      break;
+    case 576000:
+      cfsetispeed(options, B576000);
+      cfsetospeed(options, B576000);
+      break;
+    case 921600:
+      cfsetispeed(options, B921600);
+      cfsetospeed(options, B921600);
+      break;
+    case 1000000:
+      cfsetispeed(options, B1000000);
+      cfsetospeed(options, B1000000);
+      break;
+    case 1152000:
+      cfsetispeed(options, B1152000);
+      cfsetospeed(options, B1152000);
+      break;
+    case 1500000:
+      cfsetispeed(options, B1500000);
+      cfsetospeed(options, B1500000);
+      break;
+    case 2000000:
+      cfsetispeed(options, B2000000);
+      cfsetospeed(options, B2000000);
+      break;
+    case 2500000:
+      cfsetispeed(options, B2500000);
+      cfsetospeed(options, B2500000);
+      break;
+    case 3000000:
+      cfsetispeed(options, B3000000);
+      cfsetospeed(options, B3000000);
+      break;
+    case 3500000:
+      cfsetispeed(options, B3500000);
+      cfsetospeed(options, B3500000);
+      break;
+    case 4000000:
+      cfsetispeed(options, B4000000);
+      cfsetospeed(options, B4000000);
+      break;
     default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
       sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;

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

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

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

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

hal/src/fsfw_hal/linux/uio/UioMapper.cpp

@@ -0,0 +1,84 @@
+#include "UioMapper.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+
+#include "fsfw/serviceinterface.h"
+
+const char UioMapper::UIO_PATH_PREFIX[] = "/sys/class/uio/";
+const char UioMapper::MAP_SUBSTR[] = "/maps/map";
+const char UioMapper::SIZE_FILE_PATH[] = "/size";
+
+UioMapper::UioMapper(std::string uioFile, int mapNum) : uioFile(uioFile), mapNum(mapNum) {}
+
+UioMapper::~UioMapper() {}
+
+ReturnValue_t UioMapper::getMappedAdress(uint32_t** address, Permissions permissions) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  int fd = open(uioFile.c_str(), O_RDWR);
+  if (fd < 1) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "PtmeAxiConfig::initialize: Invalid UIO device file" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  size_t size = 0;
+  result = getMapSize(&size);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  *address = static_cast<uint32_t*>(
+      mmap(NULL, size, static_cast<int>(permissions), MAP_SHARED, fd, mapNum * getpagesize()));
+
+  if (*address == MAP_FAILED) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UioMapper::getMappedAdress: Failed to map physical address of uio device "
+                 << uioFile.c_str() << " and map" << static_cast<int>(mapNum) << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t UioMapper::getMapSize(size_t* size) {
+  std::stringstream namestream;
+  namestream << UIO_PATH_PREFIX << uioFile.substr(5, std::string::npos) << MAP_SUBSTR << mapNum
+             << SIZE_FILE_PATH;
+  FILE* fp;
+  fp = fopen(namestream.str().c_str(), "r");
+  if (fp == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UioMapper::getMapSize: Failed to open file " << namestream.str() << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  char hexstring[SIZE_HEX_STRING] = "";
+  int items = fscanf(fp, "%s", hexstring);
+  if (items != 1) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno
+                 << " to read size "
+                    "string from file "
+                 << namestream.str() << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  uint32_t sizeTmp = 0;
+  items = sscanf(hexstring, "%x", &sizeTmp);
+  if (size != nullptr) {
+    *size = sizeTmp;
+  }
+  if (items != 1) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UioMapper::getMapSize: Failed with error code " << errno << "to convert "
+                 << "size of map" << mapNum << " to integer" << std::endl;
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  fclose(fp);
+  return HasReturnvaluesIF::RETURN_OK;
+}

hal/src/fsfw_hal/linux/uio/UioMapper.h

@@ -0,0 +1,58 @@
+#ifndef FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_
+#define FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_
+
+#include <sys/mman.h>
+
+#include <string>
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief   Class to help opening uio device files and mapping the physical addresses into the user
+ *          address space.
+ *
+ * @author  J. Meier
+ */
+class UioMapper {
+ public:
+  enum class Permissions : int {
+    READ_ONLY = PROT_READ,
+    WRITE_ONLY = PROT_WRITE,
+    READ_WRITE = PROT_READ | PROT_WRITE
+  };
+
+  /**
+   * @brief   Constructor
+   *
+   * @param uioFile   The device file of the uiO to open
+   * @param uioMap    Number of memory map. Most UIO drivers have only one map which has than 0.
+   */
+  UioMapper(std::string uioFile, int mapNum = 0);
+  virtual ~UioMapper();
+
+  /**
+   * @brief   Maps the physical address into user address space and returns the mapped address
+   *
+   * @address The mapped user space address
+   * @permissions Specifies the read/write permissions of the address region
+   */
+  ReturnValue_t getMappedAdress(uint32_t** address, Permissions permissions);
+
+ private:
+  static const char UIO_PATH_PREFIX[];
+  static const char MAP_SUBSTR[];
+  static const char SIZE_FILE_PATH[];
+  static constexpr int SIZE_HEX_STRING = 10;
+
+  std::string uioFile;
+  int mapNum = 0;
+
+  /**
+   * @brief   Reads the map size from the associated sysfs size file
+   *
+   * @param size  The read map size
+   */
+  ReturnValue_t getMapSize(size_t* size);
+};
+
+#endif /* FSFW_HAL_SRC_FSFW_HAL_LINUX_UIO_UIOMAPPER_H_ */

src/fsfw/FSFW.h.in

@@ -57,6 +57,11 @@
 #define FSFW_HAL_SPI_WIRETAPPING            0
 #endif
 
+// Can be used for low-level debugging of the I2C bus
+#ifndef FSFW_HAL_I2C_WIRETAPPING
+#define FSFW_HAL_I2C_WIRETAPPING            0
+#endif
+
 #ifndef FSFW_HAL_L3GD20_GYRO_DEBUG
 #define FSFW_HAL_L3GD20_GYRO_DEBUG          0
 #endif /* FSFW_HAL_L3GD20_GYRO_DEBUG */

src/fsfw/controller/ControllerBase.h

@@ -1,7 +1,6 @@
 #ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
 #define FSFW_CONTROLLER_CONTROLLERBASE_H_
 
-#include "fsfw/datapool/HkSwitchHelper.h"
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
 #include "fsfw/modes/HasModesIF.h"

src/fsfw/datalinklayer/DataLinkLayer.h

@@ -30,7 +30,7 @@ class DataLinkLayer : public CCSDSReturnValuesIF {
   //! [EXPORT] : [COMMENT] A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0
   static const Event BIT_LOCK_LOST = MAKE_EVENT(3, severity::INFO);
   //	static const Event RF_CHAIN_LOST = MAKE_EVENT(4, severity::INFO); //!< The CCSDS Board
-  //detected that either bit lock or RF available or both are lost. No parameters.
+  // detected that either bit lock or RF available or both are lost. No parameters.
   //! [EXPORT] : [COMMENT] The CCSDS Board could not interpret a TC
   static const Event FRAME_PROCESSING_FAILED = MAKE_EVENT(5, severity::LOW);
   /**

src/fsfw/datalinklayer/VirtualChannelReception.cpp

@@ -30,9 +30,9 @@ ReturnValue_t VirtualChannelReception::mapDemultiplexing(TcTransferFrame* frame)
   mapChannelIterator iter = mapChannels.find(mapId);
   if (iter == mapChannels.end()) {
     //		error << "VirtualChannelReception::mapDemultiplexing on VC " << std::hex << (int)
-    //channelId
+    // channelId
     //				<< ": MapChannel " << (int) mapId << std::dec << " not found." <<
-    //std::endl;
+    // std::endl;
     return VC_NOT_FOUND;
   } else {
     return (iter->second)->extractPackets(frame);

src/fsfw/datapool/CMakeLists.txt

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

src/fsfw/datapool/HkSwitchHelper.cpp

@@ -1,67 +0,0 @@
-#include "fsfw/datapool/HkSwitchHelper.h"
-
-#include "fsfw/ipc/QueueFactory.h"
-
-HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy)
-    : commandActionHelper(this), eventProxy(eventProxy) {
-  actionQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-HkSwitchHelper::~HkSwitchHelper() { QueueFactory::instance()->deleteMessageQueue(actionQueue); }
-
-ReturnValue_t HkSwitchHelper::initialize() {
-  ReturnValue_t result = commandActionHelper.initialize();
-
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    return result;
-  }
-
-  return result;
-}
-
-ReturnValue_t HkSwitchHelper::performOperation(uint8_t operationCode) {
-  CommandMessage command;
-  while (actionQueue->receiveMessage(&command) == HasReturnvaluesIF::RETURN_OK) {
-    ReturnValue_t result = commandActionHelper.handleReply(&command);
-    if (result == HasReturnvaluesIF::RETURN_OK) {
-      continue;
-    }
-    command.setToUnknownCommand();
-    actionQueue->reply(&command);
-  }
-
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-void HkSwitchHelper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
-
-void HkSwitchHelper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-                                        ReturnValue_t returnCode) {
-  eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-void HkSwitchHelper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
-
-void HkSwitchHelper::completionSuccessfulReceived(ActionId_t actionId) {}
-
-void HkSwitchHelper::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
-  eventProxy->forwardEvent(SWITCHING_TM_FAILED, returnCode, actionId);
-}
-
-ReturnValue_t HkSwitchHelper::switchHK(SerializeIF* sids, bool enable) {
-  //	ActionId_t action = HKService::DISABLE_HK;
-  //	if (enable) {
-  //		action = HKService::ENABLE_HK;
-  //	}
-  //
-  //	ReturnValue_t result = commandActionHelper.commandAction(
-  //			objects::PUS_HK_SERVICE, action, sids);
-  //
-  //	if (result != HasReturnvaluesIF::RETURN_OK) {
-  //		eventProxy->forwardEvent(SWITCHING_TM_FAILED, result);
-  //	}
-  //	return result;
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueIF* HkSwitchHelper::getCommandQueuePtr() { return actionQueue; }

src/fsfw/datapool/HkSwitchHelper.h

@@ -1,44 +0,0 @@
-#ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-#define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_
-
-#include "fsfw/action/CommandsActionsIF.h"
-#include "fsfw/events/EventReportingProxyIF.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-// TODO this class violations separation between mission and framework
-// but it is only a transitional solution until the Datapool is
-// implemented decentrally
-
-class HkSwitchHelper : public ExecutableObjectIF, public CommandsActionsIF {
- public:
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HK;
-  static const Event SWITCHING_TM_FAILED =
-      MAKE_EVENT(1, severity::LOW);  //!< Commanding the HK Service failed, p1: error code, p2
-                                     //!< action: 0 disable / 1 enable
-
-  HkSwitchHelper(EventReportingProxyIF* eventProxy);
-  virtual ~HkSwitchHelper();
-
-  ReturnValue_t initialize();
-
-  virtual ReturnValue_t performOperation(uint8_t operationCode = 0);
-
-  ReturnValue_t switchHK(SerializeIF* sids, bool enable);
-
-  virtual void setTaskIF(PeriodicTaskIF* task_){};
-
- protected:
-  virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step);
-  virtual void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode);
-  virtual void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size);
-  virtual void completionSuccessfulReceived(ActionId_t actionId);
-  virtual void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode);
-  virtual MessageQueueIF* getCommandQueuePtr();
-
- private:
-  CommandActionHelper commandActionHelper;
-  MessageQueueIF* actionQueue;
-  EventReportingProxyIF* eventProxy;
-};
-
-#endif /* FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ */

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -291,3 +291,5 @@ float LocalPoolDataSetBase::getCollectionInterval() const {
     return 0.0;
   }
 }
+
+void LocalPoolDataSetBase::printSet() { return; }

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -171,6 +171,11 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   float getCollectionInterval() const;
 
+  /**
+   * @brief   Can be overwritten by a specific implementation of a dataset to print the set.
+   */
+  virtual void printSet();
+
  protected:
   sid_t sid;
   //! This mutex is used if the data is created by one object only.

src/fsfw/datapoollocal/LocalPoolObjectBase.cpp

@@ -47,13 +47,14 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
   HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
   if (hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolVariable: The supplied pool owner did not implement the correct "
-                  "interface HasLocalDataPoolIF!"
-               << std::endl;
+    sif::error << "LocalPoolVariable: The supplied pool owner 0x" << std::hex << poolOwner
+               << std::dec << " did not implement the correct interface "
+               << "HasLocalDataPoolIF" << std::endl;
 #else
     sif::printError(
-        "LocalPoolVariable: The supplied pool owner did not implement the correct "
-        "interface HasLocalDataPoolIF!\n");
+        "LocalPoolVariable: The supplied pool owner 0x%08x did not implement the correct "
+        "interface HasLocalDataPoolIF\n",
+        poolOwner);
 #endif
     return;
   }

src/fsfw/datapoollocal/StaticLocalDataSet.h

@@ -46,7 +46,7 @@ class StaticLocalDataSet : public LocalPoolDataSetBase {
   }
 
  private:
-  std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList;
+  std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList = {};
 };
 
 #endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -665,6 +665,11 @@ void DeviceHandlerBase::doGetWrite() {
 void DeviceHandlerBase::doSendRead() {
   ReturnValue_t result;
 
+  result = doSendReadHook();
+  if (result != RETURN_OK) {
+    return;
+  }
+
   size_t replyLen = 0;
   if (cookieInfo.pendingCommand != deviceCommandMap.end()) {
     replyLen = getNextReplyLength(cookieInfo.pendingCommand->first);
@@ -920,6 +925,8 @@ void DeviceHandlerBase::commandSwitch(ReturnValue_t onOff) {
   }
 }
 
+ReturnValue_t DeviceHandlerBase::doSendReadHook() { return RETURN_OK; }
+
 ReturnValue_t DeviceHandlerBase::getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) {
   return DeviceHandlerBase::NO_SWITCH;
 }

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -1082,6 +1082,12 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   void commandSwitch(ReturnValue_t onOff);
 
+  /**
+   * @brief   This function can be used to insert device specific code during the do-send-read
+   *          step.
+   */
+  virtual ReturnValue_t doSendReadHook();
+
  private:
   /**
    * State a cookie is in.

src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -29,6 +29,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
   switch (event->getEvent()) {
     case HasModesIF::MODE_TRANSITION_FAILED:
     case HasModesIF::OBJECT_IN_INVALID_MODE:
+    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
       // We'll try a recovery as long as defined in MAX_REBOOT.
       // Might cause some AssemblyBase cycles, so keep number low.
       handleRecovery(event->getEvent());

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -109,6 +109,7 @@ class DeviceHandlerIF {
   static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
   static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
   static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
+  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);
 
   static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;
 

src/fsfw/fdir/FailureIsolationBase.h

@@ -14,13 +14,12 @@ class FailureIsolationBase : public HasReturnvaluesIF,
                              public HasParametersIF {
  public:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-  static const Event FDIR_CHANGED_STATE =
-      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
-                                      //!< (oldState) to par1 (newState).
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
-      2, severity::MEDIUM);  //!< FDIR tries to restart device. Par1: event that caused recovery.
-  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
-      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.
+  //! FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
+  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
+  //! FDIR tries to restart device. Par1: event that caused recovery.
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
+  //! FDIR turns off device. Par1: event that caused recovery.
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM);
 
   FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                        uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);

src/fsfw/globalfunctions/CRC.cpp

@@ -116,8 +116,8 @@ uint16_t CRC::crc16ccitt(uint8_t const input[], uint32_t length, uint16_t starti
   //	for (int i=0; i<16 ;i++)
   //	{
   //		 if  (xor_out[i] == true)
-  //			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before Final
-  //XOR
+  //			 crc_value = crc_value + pow(2,(15 -i));   // reverse CrC result before
+  // Final XOR
   //	}
   //
   //	crc_value = 0;// for debug mode

src/fsfw/health/HasHealthIF.h

@@ -23,19 +23,15 @@ class HasHealthIF {
   static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
   static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
-  static const Event OVERWRITING_HEALTH =
-      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
-                                     //!< satellite alive.
-  static const Event TRYING_RECOVERY =
-      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
-                                         //!< power-cycle). No parameters.
-  static const Event RECOVERY_STEP =
-      MAKE_EVENT(11, severity::MEDIUM);  //!< Recovery is ongoing. Comes twice during recovery. P1:
-                                         //!< 0 for the first, 1 for the second event. P2: 0
-  static const Event RECOVERY_DONE = MAKE_EVENT(
-      12,
-      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
-
+  //! Assembly overwrites health information of children to keep satellite alive.
+  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
+  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
+  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  //! Recovery is ongoing. Comes twice during recovery.
+  //! P1: 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
+  //! Recovery was completed. Not necessarily successful. No parameters.
+  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/modes/HasModesIF.h

@@ -19,32 +19,29 @@ class HasModesIF {
   static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  static const Event CHANGING_MODE =
-      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
-                                      //!< p2: target submode
-  static const Event MODE_INFO = MAKE_EVENT(
-      1,
-      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
+  //! An object announces changing the mode. p1: target mode. p2: target submode
+  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
+  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
+  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
   static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
   static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
   static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  static const Event OBJECT_IN_INVALID_MODE =
-      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
-                                     //!< mode it should never be in.
-  static const Event FORCING_MODE = MAKE_EVENT(
-      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
-                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
-  static const Event MODE_CMD_REJECTED =
-      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
-                                     //!< called object id, Par2: return code.
+  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
+  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
+  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
+  //! p1: target mode. p2: target submode
+  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
+  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
+  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
 
-  static const Mode_t MODE_ON =
-      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
-          //!< sent by the device handler itself, but direct commands van be commanded and will be
-          //!< interpreted
-  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
-                                     //!< this mode is a mode change to on.
-  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".
+  //! The device is powered and ready to perform operations. In this mode, no commands are
+  //! sent by the device handler itself, but direct commands van be commanded and will be
+  //! interpreted
+  static const Mode_t MODE_ON = 1;
+  //! The device is powered off. The only command accepted in this mode is a mode change to on.
+  static const Mode_t MODE_OFF = 0;
+  //! To avoid checks against magic number "0".
+  static const Submode_t SUBMODE_NONE = 0;
 
   virtual ~HasModesIF() {}
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/modes/ModeMessage.h

@@ -14,30 +14,30 @@ class ModeMessage {
   static const uint8_t MESSAGE_ID = messagetypes::MODE_COMMAND;
   static const Command_t CMD_MODE_COMMAND =
       MAKE_COMMAND_ID(0x01);  //!> Command to set the specified Mode, replies are: REPLY_MODE_REPLY,
-                              //!REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies,
-                              //!as this will break the subsystem mode machine!!
+                              //! REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any replies,
+                              //! as this will break the subsystem mode machine!!
   static const Command_t CMD_MODE_COMMAND_FORCED = MAKE_COMMAND_ID(
       0xF1);  //!> Command to set the specified Mode, regardless of external control flag, replies
-              //!are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any
-              //!replies, as this will break the subsystem mode machine!!
+              //! are: REPLY_MODE_REPLY, REPLY_WRONG_MODE_REPLY, and REPLY_REJECTED; don't add any
+              //! replies, as this will break the subsystem mode machine!!
   static const Command_t REPLY_MODE_REPLY =
       MAKE_COMMAND_ID(0x02);  //!> Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
   static const Command_t REPLY_MODE_INFO =
       MAKE_COMMAND_ID(0x03);  //!> Unrequested info about the current mode (used for composites to
-                              //!inform their container of a changed mode)
+                              //! inform their container of a changed mode)
   static const Command_t REPLY_CANT_REACH_MODE = MAKE_COMMAND_ID(
       0x04);  //!> Reply in case a mode command can't be executed. Par1: returnCode, Par2: 0
   static const Command_t REPLY_WRONG_MODE_REPLY =
       MAKE_COMMAND_ID(0x05);  //!> Reply to a CMD_MODE_COMMAND, indicating that a mode was commanded
-                              //!and a transition started but was aborted; the parameters contain
-                              //!the mode that was reached
+                              //! and a transition started but was aborted; the parameters contain
+                              //! the mode that was reached
   static const Command_t CMD_MODE_READ = MAKE_COMMAND_ID(
       0x06);  //!> Command to read the current mode and reply with a REPLY_MODE_REPLY
   static const Command_t CMD_MODE_ANNOUNCE = MAKE_COMMAND_ID(
       0x07);  //!> Command to trigger an ModeInfo Event. This command does NOT have a reply.
   static const Command_t CMD_MODE_ANNOUNCE_RECURSIVELY =
       MAKE_COMMAND_ID(0x08);  //!> Command to trigger an ModeInfo Event and to send this command to
-                              //!every child. This command does NOT have a reply.
+                              //! every child. This command does NOT have a reply.
 
   static Mode_t getMode(const CommandMessage* message);
   static Submode_t getSubmode(const CommandMessage* message);

src/fsfw/osal/linux/CMakeLists.txt

@@ -1,29 +1,29 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE
     Clock.cpp
-	BinarySemaphore.cpp
-	CountingSemaphore.cpp
-	FixedTimeslotTask.cpp
-	InternalErrorCodes.cpp
-	MessageQueue.cpp
-	Mutex.cpp
-	MutexFactory.cpp
-	PeriodicPosixTask.cpp
-	PosixThread.cpp
-	QueueFactory.cpp
-	SemaphoreFactory.cpp
-	TaskFactory.cpp
-	tcpipHelpers.cpp
-	unixUtility.cpp
+    BinarySemaphore.cpp
+    CountingSemaphore.cpp
+    FixedTimeslotTask.cpp
+    InternalErrorCodes.cpp
+    MessageQueue.cpp
+    Mutex.cpp
+    MutexFactory.cpp
+    PeriodicPosixTask.cpp
+    PosixThread.cpp
+    QueueFactory.cpp
+    SemaphoreFactory.cpp
+    TaskFactory.cpp
+    tcpipHelpers.cpp
+    unixUtility.cpp
 )
 
 find_package(Threads REQUIRED)
 
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
-	${CMAKE_THREAD_LIBS_INIT}
-	rt
+    ${CMAKE_THREAD_LIBS_INIT}
+    rt
 )
 
 target_link_libraries(${LIB_FSFW_NAME} INTERFACE
-	${CMAKE_THREAD_LIBS_INIT}
+    ${CMAKE_THREAD_LIBS_INIT}
 )
 

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -65,9 +65,10 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
   /**
    * @brief	The function containing the actual functionality of the task.
    * @details	The method sets and starts
-   * 			the task's period, then enters a loop that is repeated indefinitely. Within the loop,
-   * all performOperation methods of the added objects are called. Afterwards the task will be
-   * blocked until the next period. On missing the deadline, the deadlineMissedFunction is executed.
+   * 			the task's period, then enters a loop that is repeated indefinitely. Within
+   * the loop, all performOperation methods of the added objects are called. Afterwards the task
+   * will be blocked until the next period. On missing the deadline, the deadlineMissedFunction is
+   * executed.
    */
   virtual void taskFunctionality(void);
   /**

src/fsfw/osal/rtems/PeriodicTask.h

@@ -13,8 +13,8 @@ class ExecutableObjectIF;
  * @brief This class represents a specialized task for periodic activities of multiple objects.
  *
  * @details MultiObjectTask is an extension to ObjectTask in the way that it is able to execute
- * 			multiple objects that implement the ExecutableObjectIF interface. The objects must
- * be added prior to starting the task.
+ * 			multiple objects that implement the ExecutableObjectIF interface. The
+ * objects must be added prior to starting the task.
  * @author  baetz
  * @ingroup task_handling
  */

src/fsfw/osal/rtems/RTEMSTaskBase.h

@@ -25,8 +25,8 @@ class RTEMSTaskBase {
    * all other attributes are set with default values.
    * @param priority		Sets the priority of a task. Values range from a low 0 to a high 99.
    * @param stack_size	The stack size reserved by the operating system for the task.
-   * @param nam			The name of the Task, as a null-terminated String. Currently max 4 chars
-   * supported (excluding Null-terminator), rest will be truncated
+   * @param nam			The name of the Task, as a null-terminated String. Currently max 4
+   * chars supported (excluding Null-terminator), rest will be truncated
    */
   RTEMSTaskBase(rtems_task_priority priority, size_t stack_size, const char *name);
   /**

src/fsfw/power/Fuse.h

@@ -34,14 +34,14 @@ class Fuse : public SystemObject,
   };
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
-  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(
-      1, severity::LOW);  //!< PSS detected that current on a fuse is totally out of bounds.
-  static const Event FUSE_WENT_OFF =
-      MAKE_EVENT(2, severity::LOW);  //!< PSS detected a fuse that went off.
-  static const Event POWER_ABOVE_HIGH_LIMIT =
-      MAKE_EVENT(4, severity::LOW);  //!< PSS detected a fuse that violates its limits.
-  static const Event POWER_BELOW_LOW_LIMIT =
-      MAKE_EVENT(5, severity::LOW);  //!< PSS detected a fuse that violates its limits.
+  //! PSS detected that current on a fuse is totally out of bounds.
+  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
+  //! PSS detected a fuse that went off.
+  static const Event FUSE_WENT_OFF = MAKE_EVENT(2, severity::LOW);
+  //! PSS detected a fuse that violates its limits.
+  static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, severity::LOW);
+  //! PSS detected a fuse that violates its limits.
+  static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW);
 
   typedef std::list<PowerComponentIF *> DeviceList;
   Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,

src/fsfw/pus/Service9TimeManagement.h

@@ -6,10 +6,10 @@
 class Service9TimeManagement : public PusServiceBase {
  public:
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-  static constexpr Event CLOCK_SET =
-      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-  static constexpr Event CLOCK_SET_FAILURE =
-      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.
+  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+  static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO);
+  //!< Clock could not be set. P1: Returncode.
+  static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW);
 
   static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
 

src/fsfw/rmap/RMAP.h

@@ -51,9 +51,9 @@ class RMAP : public HasReturnvaluesIF {
   // MAKE_RETURN_CODE(0xE4); //the data that was to be sent was too long for the hw to handle (write
   // command) or the expected len was bigger than maximal expected len (read command) command was
   // not sent
-  // replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t COMMAND_NULLPOINTER
-  // = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write command, or
-  // nullpointer in read command
+  // replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t
+  // COMMAND_NULLPOINTER = MAKE_RETURN_CODE(0xE5); //datalen was != 0 but data was == NULL in write
+  // command, or nullpointer in read command
   static const ReturnValue_t COMMAND_CHANNEL_DEACTIVATED =
       MAKE_RETURN_CODE(0xE6);  // the channel has no port set
   static const ReturnValue_t COMMAND_PORT_OUT_OF_RANGE =
@@ -73,8 +73,8 @@ class RMAP : public HasReturnvaluesIF {
   static const ReturnValue_t REPLY_MISSMATCH = MAKE_RETURN_CODE(
       0xD3);  // a read command was issued, but get_write_rply called, or other way round
   static const ReturnValue_t REPLY_TIMEOUT = MAKE_RETURN_CODE(0xD4);  // timeout
-  // replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER =
-  // MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL return values for
+  // replaced by DeviceCommunicationIF::NULLPOINTER	static const ReturnValue_t REPLY_NULLPOINTER
+  // = MAKE_RETURN_CODE(0xD5);//one of the arguments in a read reply was NULL return values for
   // get_reply
   static const ReturnValue_t REPLY_INTERFACE_BUSY =
       MAKE_RETURN_CODE(0xC0);  // Interface is busy (transmission buffer still being processed)
@@ -169,8 +169,8 @@ class RMAP : public HasReturnvaluesIF {
    * @param buffer the data to write
    * @param length length of data
    * @return
-   *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write
-   * command
+   *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was ==
+   * NULL in write command
    *      - return codes of RMAPChannelIF::sendCommand()
    */
   static ReturnValue_t sendWriteCommand(RMAPCookie *cookie, const uint8_t *buffer, size_t length);
@@ -205,8 +205,8 @@ class RMAP : public HasReturnvaluesIF {
    * @param cookie to cookie to read from
    * @param expLength the expected maximum length of the reply
    * @return
-   *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was == NULL in write
-   * command, or nullpointer in read command
+   *      - @c COMMAND_NULLPOINTER				datalen was != 0 but data was ==
+   * NULL in write command, or nullpointer in read command
    *      - return codes of RMAPChannelIF::sendCommand()
    */
   static ReturnValue_t sendReadCommand(RMAPCookie *cookie, uint32_t expLength);

src/fsfw/rmap/RMAPChannelIF.h

@@ -73,16 +73,16 @@ class RMAPChannelIF {
    * @param datalen length of data
    * @return
    *      - @c RETURN_OK
-   *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending command;
-   * command was not sent
-   *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for expected len; command
-   * was not sent
-   *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long for the hw to
-   * handle (write command) or the expected len was bigger than maximal expected len (read command)
-   * command was not sent
+   *      - @c COMMAND_NO_DESCRIPTORS_AVAILABLE 	no descriptors available for sending
+   * command; command was not sent
+   *      - @c COMMAND_BUFFER_FULL				no receiver buffer available for
+   * expected len; command was not sent
+   *      - @c COMMAND_TOO_BIG					the data that was to be sent was too long
+   * for the hw to handle (write command) or the expected len was bigger than maximal expected len
+   * (read command) command was not sent
    *      - @c COMMAND_CHANNEL_DEACTIVATED		the channel has no port set
-   *      - @c NOT_SUPPORTED						if you dont feel like implementing
-   * something...
+   *      - @c NOT_SUPPORTED						if you dont feel like
+   * implementing something...
    */
   virtual ReturnValue_t sendCommand(RMAPCookie *cookie, uint8_t instruction, const uint8_t *data,
                                     size_t datalen) = 0;
@@ -97,8 +97,8 @@ class RMAPChannelIF {
    *      - @c REPLY_NO_REPLY				no reply was received
    *      - @c REPLY_NOT_SENT				command was not sent, implies no reply
    *      - @c REPLY_NOT_YET_SENT			command is still waiting to be sent
-   *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission buffer still being
-   * processed)
+   *      - @c WRITE_REPLY_INTERFACE_BUSY			Interface is busy (transmission
+   * buffer still being processed)
    *      - @c WRITE_REPLY_TRANSMISSION_ERROR		Interface encountered errors during last
    * operation, data could not be processed. (transmission error)
    *      - @c WRITE_REPLY_INVALID_DATA			Invalid data (amount / value)

src/fsfw/rmap/rmapStructs.h

@@ -32,10 +32,10 @@ static const uint8_t RMAP_COMMAND_READ = ((1 << RMAP_COMMAND_BIT) | (1 << RMAP_C
 static const uint8_t RMAP_REPLY_WRITE =
     ((1 << RMAP_COMMAND_BIT_WRITE) | (1 << RMAP_COMMAND_BIT_REPLY));
 static const uint8_t RMAP_REPLY_READ = ((1 << RMAP_COMMAND_BIT_REPLY));
-//#define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE) |
-//(1<<RMAP_COMMAND_BIT_REPLY)) #define RMAP_COMMAND_WRITE_VERIFY	((1<<RMAP_COMMAND_BIT) |
+//#define RMAP_COMMAND_WRITE			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_WRITE)
+//| (1<<RMAP_COMMAND_BIT_REPLY)) #define RMAP_COMMAND_WRITE_VERIFY	((1<<RMAP_COMMAND_BIT) |
 //(1<<RMAP_COMMAND_BIT_WRITE) | (1<<RMAP_COMMAND_BIT_REPLY) | (1<<RMAP_COMMAND_BIT_VERIFY)) #define
-//RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))
+// RMAP_COMMAND_READ			((1<<RMAP_COMMAND_BIT) | (1<<RMAP_COMMAND_BIT_REPLY))
 
 //#define RMAP_REPLY_WRITE			((1<<RMAP_COMMAND_BIT_WRITE) |
 //(1<<RMAP_COMMAND_BIT_REPLY))

src/fsfw/timemanager/Clock.h

@@ -99,6 +99,13 @@ class Clock {
    */
   static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
 
+  /**
+   * Convert to time of day struct given the POSIX timeval struct
+   * @param from
+   * @param to
+   * @return
+   */
+  static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
   /**
    * Converts a time of day struct to POSIX seconds.
    * @param time The time of day as input

src/fsfw/timemanager/ClockCommon.cpp

@@ -1,7 +1,9 @@
+#include <ctime>
+
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"
 
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval *tt) {
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
   uint16_t leapSeconds;
   ReturnValue_t result = getLeapSeconds(&leapSeconds);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -31,7 +33,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
   if (timeMutex == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
@@ -42,9 +44,22 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
+  struct tm* timeInfo;
+  timeInfo = gmtime(&from->tv_sec);
+  to->year = timeInfo->tm_year + 1900;
+  to->month = timeInfo->tm_mon + 1;
+  to->day = timeInfo->tm_mday;
+  to->hour = timeInfo->tm_hour;
+  to->minute = timeInfo->tm_min;
+  to->second = timeInfo->tm_sec;
+  to->usecond = from->tv_usec;
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t Clock::checkOrCreateClockMutex() {
   if (timeMutex == nullptr) {
-    MutexFactory *mutexFactory = MutexFactory::instance();
+    MutexFactory* mutexFactory = MutexFactory::instance();
     if (mutexFactory == nullptr) {
       return HasReturnvaluesIF::RETURN_FAILED;
     }

src/fsfw/tmstorage/TmStoreBackendIF.h

@@ -33,50 +33,47 @@ class TmStoreBackendIF : public HasParametersIF {
   static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-  static const Event STORE_SEND_WRITE_FAILED =
-      MAKE_EVENT(0, severity::LOW);  //!< Initiating sending data to store failed. Low, par1:
-                                     //!< returnCode, par2: integer (debug info)
-  static const Event STORE_WRITE_FAILED = MAKE_EVENT(
-      1, severity::LOW);  //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_SEND_READ_FAILED =
-      MAKE_EVENT(2, severity::LOW);  //!< Initiating reading data from store failed. Low, par1:
-                                     //!< returnCode, par2: 0
-  static const Event STORE_READ_FAILED = MAKE_EVENT(
-      3, severity::LOW);  //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
-  static const Event UNEXPECTED_MSG =
-      MAKE_EVENT(4, severity::LOW);  //!< An unexpected TM packet or data message occurred. Low,
-                                     //!< par1: 0, par2: integer (debug info)
-  static const Event STORING_FAILED = MAKE_EVENT(
-      5, severity::LOW);  //!< Storing data failed. May simply be a full store. Low, par1:
-                          //!< returnCode, par2: integer (sequence count of failed packet).
-  static const Event TM_DUMP_FAILED =
-      MAKE_EVENT(6, severity::LOW);  //!< Dumping retrieved data failed. Low, par1: returnCode,
-                                     //!< par2: integer (sequence count of failed packet).
-  static const Event STORE_INIT_FAILED =
-      MAKE_EVENT(7, severity::LOW);  //!< Corrupted init data or read error. Low, par1: returnCode,
-                                     //!< par2: integer (debug info)
-  static const Event STORE_INIT_EMPTY = MAKE_EVENT(
-      8, severity::INFO);  //!< Store was not initialized. Starts empty. Info, parameters both zero.
-  static const Event STORE_CONTENT_CORRUPTED =
-      MAKE_EVENT(9, severity::LOW);  //!< Data was read out, but it is inconsistent. Low par1:
-                                     //!< Memory address of corruption, par2: integer (debug info)
-  static const Event STORE_INITIALIZE =
-      MAKE_EVENT(10, severity::INFO);  //!< Info event indicating the store will be initialized,
-                                       //!< either at boot or after IOB switch. Info. pars: 0
-  static const Event INIT_DONE = MAKE_EVENT(
-      11, severity::INFO);  //!< Info event indicating the store was successfully initialized,
-                            //!< either at boot or after IOB switch. Info. pars: 0
-  static const Event DUMP_FINISHED = MAKE_EVENT(
-      12, severity::INFO);  //!< Info event indicating that dumping finished successfully. par1:
-                            //!< Number of dumped packets. par2: APID/SSC (16bits each)
-  static const Event DELETION_FINISHED = MAKE_EVENT(
-      13, severity::INFO);  //!< Info event indicating that deletion finished successfully. par1:
-                            //!< Number of deleted packets. par2: APID/SSC (16bits each)
-  static const Event DELETION_FAILED = MAKE_EVENT(
-      14,
-      severity::LOW);  //!< Info event indicating that something went wrong during deletion. pars: 0
-  static const Event AUTO_CATALOGS_SENDING_FAILED =
-      MAKE_EVENT(15, severity::INFO);  //!< Info that the a auto catalog report failed
+  //! Initiating sending data to store failed. Low, par1:
+  //! returnCode, par2: integer (debug info)
+  static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
+  //! Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW);
+  //! Initiating reading data from store failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW);
+  //! Data was requested, but access failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW);
+  //! An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
+  static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW);
+  //! Storing data failed. May simply be a full store. Low, par1: returnCode,
+  //! par2: integer (sequence count of failed packet).
+  static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW);
+  //! Dumping retrieved data failed. Low, par1: returnCode,
+  //! par2: integer (sequence count of failed packet).
+  static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW);
+  //! Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
+  //! Store was not initialized. Starts empty. Info, parameters both zero.
+  static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW);
+  //! Data was read out, but it is inconsistent. Low par1:
+  //! Memory address of corruption, par2: integer (debug info)
+  static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO);
+
+  static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW);
+  //! Info event indicating the store will be initialized, either at boot or after IOB switch.
+  //! Info. pars: 0
+  static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO);
+  //! Info event indicating the store was successfully initialized, either at boot or after
+  //! IOB switch. Info. pars: 0
+  static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO);
+  //! Info event indicating that dumping finished successfully.
+  //! par1: Number of dumped packets. par2: APID/SSC (16bits each)
+  static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO);
+  //! Info event indicating that deletion finished successfully.
+  //! par1:Number of deleted packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO);
+  //! Info event indicating that something went wrong during deletion. pars: 0
+  static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW);
+  //! Info that the a auto catalog report failed
+  static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);
 
   virtual ~TmStoreBackendIF() {}
 

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -172,15 +172,18 @@ ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage* message) {
   }
 
   if (tmFifo->full()) {
+    if (warningSwitch) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
-                    "of stored packet IDs reached!"
-                 << std::endl;
+      sif::warning << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+                      "of stored packet IDs reached!"
+                   << std::endl;
 #else
-    sif::printWarning(
-        "TmTcBridge::storeDownlinkData: TM downlink max. number "
-        "of stored packet IDs reached!\n");
+      sif::printWarning(
+          "TmTcBridge::storeDownlinkData: TM downlink max. number "
+          "of stored packet IDs reached!\n");
 #endif
+      warningSwitch = true;
+    }
     if (overwriteOld) {
       tmFifo->retrieve(&storeId);
       tmStore->deleteData(storeId);

src/fsfw/tmtcservices/TmTcBridge.h

@@ -72,6 +72,8 @@ class TmTcBridge : public AcceptsTelemetryIF,
   virtual uint16_t getIdentifier() override;
   virtual MessageQueueId_t getRequestQueue() override;
 
+  bool warningSwitch = true;
+
  protected:
   //! Cached for initialize function.
   object_id_t tmStoreId = objects::NO_OBJECT;