Merge pull request 'Increased TM stack robustness' (#501) from eive/fsfw:mueller/tm-stack-robustness-cherry-picked into master

Reviewed-on: fsfw/fsfw#501
Reviewed-by: Ulrich Mohr <mohr@irs.uni-stuttgart.de>

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

@@ -9,13 +9,12 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum Levels: uint8_t {
+enum Levels {
     LOW = 0,
-    HIGH = 1,
-    NONE = 99
+    HIGH = 1
 };
 
-enum Direction: uint8_t {
+enum Direction {
     IN = 0,
     OUT = 1
 };
@@ -25,18 +24,16 @@ enum GpioOperation {
     WRITE
 };
 
-enum class GpioTypes {
+enum GpioTypes {
     NONE,
     GPIO_REGULAR_BY_CHIP,
     GPIO_REGULAR_BY_LABEL,
-    GPIO_REGULAR_BY_LINE_NAME,
     CALLBACK
 };
 
 static constexpr gpioId_t NO_GPIO = -1;
 
-using gpio_cb_t = void (*) (gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
-        void* args);
+using gpio_cb_t = void (*) (gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args);
 
 }
 
@@ -60,7 +57,7 @@ public:
     GpioBase() = default;
 
     GpioBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
-            gpio::Levels initValue):
+            int initValue):
             gpioType(gpioType), consumer(consumer),direction(direction), initValue(initValue) {}
 
     virtual~ GpioBase() {};
@@ -69,21 +66,15 @@ public:
     gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
     std::string consumer;
     gpio::Direction direction = gpio::Direction::IN;
-    gpio::Levels initValue = gpio::Levels::NONE;
+    int initValue = 0;
 };
 
 class GpiodRegularBase: public GpioBase {
 public:
     GpiodRegularBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
-            gpio::Levels initValue, int lineNum):
-            GpioBase(gpioType, consumer, direction, initValue), lineNum(lineNum) {
+            int initValue, int lineNum): GpioBase(gpioType, consumer, direction, initValue),
+            lineNum(lineNum) {
     }
-
-    // line number will be configured at a later point for the open by line name configuration
-    GpiodRegularBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
-            gpio::Levels initValue): GpioBase(gpioType, consumer, direction, initValue) {
-    }
-
     int lineNum = 0;
     struct gpiod_line* lineHandle = nullptr;
 };
@@ -96,7 +87,7 @@ public:
     }
 
     GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
-            gpio::Direction direction_, gpio::Levels initValue_) :
+            gpio::Direction direction_, int initValue_) :
             GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP,
                     consumer_, direction_, initValue_, lineNum_),
             chipname(chipname_){
@@ -114,7 +105,7 @@ public:
 class GpiodRegularByLabel: public GpiodRegularBase {
 public:
     GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_,
-            gpio::Direction direction_, gpio::Levels initValue_) :
+            gpio::Direction direction_, int initValue_) :
             GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_,
                     direction_, initValue_, lineNum_),
             label(label_) {
@@ -129,30 +120,9 @@ public:
     std::string label;
 };
 
-/**
- * @brief   Passing this GPIO configuration to the GPIO IF object will try to open the GPIO by its
- *          line name. This line name can be set in the device tree and must be unique. Otherwise
- *          the driver will open the first line with the given name.
- */
-class GpiodRegularByLineName: public GpiodRegularBase {
-public:
-    GpiodRegularByLineName(std::string lineName_, std::string consumer_, gpio::Direction direction_,
-            gpio::Levels initValue_) :
-            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_, direction_,
-                    initValue_), lineName(lineName_) {
-    }
-
-    GpiodRegularByLineName(std::string lineName_, std::string consumer_) :
-            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_,
-                    gpio::Direction::IN, gpio::LOW), lineName(lineName_) {
-    }
-
-    std::string lineName;
-};
-
 class GpioCallback: public GpioBase {
 public:
-    GpioCallback(std::string consumer, gpio::Direction direction_, gpio::Levels initValue_,
+    GpioCallback(std::string consumer, gpio::Direction direction_, int initValue_,
             gpio::gpio_cb_t callback, void* callbackArgs):
             GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
             callback(callback), callbackArgs(callbackArgs) {}

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -73,7 +73,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(
     switch (internalState) {
     case(InternalState::STATE_NONE):
     case(InternalState::STATE_NORMAL): {
-        return DeviceHandlerBase::NOTHING_TO_SEND;
+        return HasReturnvaluesIF::RETURN_OK;
     }
     case(InternalState::STATE_FIRST_CONTACT): {
         *id = MGMLIS3MDL::IDENTIFY_DEVICE;

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -2,7 +2,6 @@
 #define MISSION_DEVICES_MGMRM3100HANDLER_H_
 
 #include "fsfw/FSFW.h"
-#include "devices/powerSwitcherList.h"
 #include "devicedefinitions/MgmRM3100HandlerDefs.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 

hal/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h

@@ -49,7 +49,7 @@ static constexpr uint8_t TMRC_DEFAULT_VALUE = TMRC_DEFAULT_37HZ_VALUE;
 
 static constexpr uint8_t MEASUREMENT_REG_START = 0x24;
 static constexpr uint8_t BIST_REGISTER = 0x33;
-static constexpr uint8_t DATA_READY_VAL = 0b1000'0000;
+static constexpr uint8_t DATA_READY_VAL = 0b10000000;
 static constexpr uint8_t STATUS_REGISTER = 0x34;
 static constexpr uint8_t REVID_REGISTER = 0x36;
 

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

@@ -1,9 +1,8 @@
-#include "LinuxLibgpioIF.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"
+#include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <utility>
 #include <unistd.h>
@@ -67,14 +66,6 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
             configureGpioByLabel(gpioConfig.first, *regularGpio);
             break;
         }
-        case(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME):{
-            auto regularGpio = dynamic_cast<GpiodRegularByLineName*>(gpioConfig.second);
-            if(regularGpio == nullptr) {
-                return GPIO_INVALID_INSTANCE;
-            }
-            configureGpioByLineName(gpioConfig.first, *regularGpio);
-            break;
-        }
         case(gpio::GpioTypes::CALLBACK): {
             auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
             if(gpioCallback->callback == nullptr) {
@@ -93,13 +84,13 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
     std::string& label = gpioByLabel.label;
     struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
     if (chip == nullptr) {
-        sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
+        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open gpio from gpio "
                 << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
         return RETURN_FAILED;
 
     }
     std::string failOutput = "label: " + label;
-    return configureRegularGpio(gpioId, chip, gpioByLabel, failOutput);
+    return configureRegularGpio(gpioId, gpioByLabel.gpioType, chip, gpioByLabel, failOutput);
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId,
@@ -107,41 +98,16 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId,
     std::string& chipname = gpioByChip.chipname;
     struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
     if (chip == nullptr) {
-        sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip "
+        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open chip "
                 << chipname << ". Gpio ID: " << gpioId << std::endl;
         return RETURN_FAILED;
     }
     std::string failOutput = "chipname: " + chipname;
-    return configureRegularGpio(gpioId, chip, gpioByChip, failOutput);
+    return configureRegularGpio(gpioId, gpioByChip.gpioType, chip, gpioByChip, failOutput);
 }
 
-ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
-        GpiodRegularByLineName &gpioByLineName) {
-    std::string& lineName = gpioByLineName.lineName;
-    char chipname[MAX_CHIPNAME_LENGTH];
-    unsigned int lineOffset;
-
-    int result = gpiod_ctxless_find_line(lineName.c_str(), chipname, MAX_CHIPNAME_LENGTH,
-            &lineOffset);
-    if (result != LINE_FOUND) {
-        parseFindeLineResult(result, lineName);
-        return RETURN_FAILED;
-    }
-
-    gpioByLineName.lineNum = static_cast<int>(lineOffset);
-
-    struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
-    if (chip == nullptr) {
-        sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip "
-                << chipname << ". <Gpio ID: " << gpioId << std::endl;
-        return RETURN_FAILED;
-    }
-    std::string failOutput = "line name: " + lineName;
-    return configureRegularGpio(gpioId, chip, gpioByLineName, failOutput);
-}
-
-ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod_chip* chip,
-        GpiodRegularBase& regularGpio, std::string failOutput) {
+ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+        struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput) {
     unsigned int lineNum;
     gpio::Direction direction;
     std::string consumer;
@@ -166,10 +132,22 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
     case(gpio::OUT): {
         result = gpiod_line_request_output(lineHandle, consumer.c_str(),
                 regularGpio.initValue);
+        if (result < 0) {
+            sif::error << "LinuxLibgpioIF::configureRegularGpio: Failed to request line " << lineNum <<
+                    " from GPIO instance with ID: " << gpioId << std::endl;
+            gpiod_line_release(lineHandle);
+            return RETURN_FAILED;
+        }
         break;
     }
     case(gpio::IN): {
         result = gpiod_line_request_input(lineHandle, consumer.c_str());
+        if (result < 0) {
+            sif::error << "LinuxLibgpioIF::configureGpios: Failed to request line "
+                    << lineNum << " from GPIO instance with ID: " << gpioId << std::endl;
+            gpiod_line_release(lineHandle);
+            return RETURN_FAILED;
+        }
         break;
     }
     default: {
@@ -178,18 +156,6 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
         return GPIO_INVALID_INSTANCE;
     }
 
-    if (result < 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LinuxLibgpioIF::configureRegularGpio: Failed to request line " <<
-                lineNum << " from GPIO instance with ID: " << gpioId << std::endl;
-#else
-        sif::printError("LinuxLibgpioIF::configureRegularGpio: "
-                "Failed to request line %d from GPIO instance with ID: %d\n", lineNum, gpioId);
-#endif
-        gpiod_line_release(lineHandle);
-        return RETURN_FAILED;
-    }
-
     }
     /**
      * Write line handle to GPIO configuration instance so it can later be used to set or
@@ -207,9 +173,8 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
     }
 
     auto gpioType = gpioMapIter->second->gpioType;
-    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -222,7 +187,7 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
             return GPIO_INVALID_INSTANCE;
         }
         gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
-                gpio::Levels::HIGH, gpioCallback->callbackArgs);
+                1, gpioCallback->callbackArgs);
         return RETURN_OK;
     }
     return GPIO_TYPE_FAILURE;
@@ -231,18 +196,13 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
 ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
     gpioMapIter = gpioMap.find(gpioId);
     if (gpioMapIter == gpioMap.end()) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::pullLow: Unknown GPIO ID " << gpioId << std::endl;
-#else
-        sif::printWarning("LinuxLibgpioIF::pullLow: Unknown GPIO ID %d\n", gpioId);
-#endif
         return UNKNOWN_GPIO_ID;
     }
 
     auto& gpioType = gpioMapIter->second->gpioType;
-    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -255,7 +215,7 @@ ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
             return GPIO_INVALID_INSTANCE;
         }
         gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
-                gpio::Levels::LOW, gpioCallback->callbackArgs);
+                0, gpioCallback->callbackArgs);
         return RETURN_OK;
     }
     return GPIO_TYPE_FAILURE;
@@ -265,13 +225,8 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId,
         GpiodRegularBase& regularGpio, gpio::Levels logicLevel) {
     int result = gpiod_line_set_value(regularGpio.lineHandle, logicLevel);
     if (result < 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID " << gpioId <<
                 " to logic level " << logicLevel << std::endl;
-#else
-        sif::printWarning("LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID %d to "
-                "logic level %d\n", gpioId, logicLevel);
-#endif
         return DRIVE_GPIO_FAILURE;
     }
 
@@ -281,18 +236,12 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId,
 ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
     gpioMapIter = gpioMap.find(gpioId);
     if (gpioMapIter == gpioMap.end()){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::readGpio: Unknown GPIOD ID " << gpioId << std::endl;
-#else
-        sif::printWarning("LinuxLibgpioIF::readGpio: Unknown GPIOD ID %d\n", gpioId);
-#endif
         return UNKNOWN_GPIO_ID;
     }
-
     auto gpioType = gpioMapIter->second->gpioType;
-    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
-            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -300,14 +249,10 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
         *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
     }
     else {
-        auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
-        if(gpioCallback->callback == nullptr) {
-            return GPIO_INVALID_INSTANCE;
-        }
-        gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::READ,
-                gpio::Levels::NONE, gpioCallback->callbackArgs);
-        return RETURN_OK;
+
     }
+
+
     return RETURN_OK;
 }
 
@@ -317,14 +262,13 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
     for(auto& gpioConfig: mapToAdd) {
         switch(gpioConfig.second->gpioType) {
         case(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
-        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
-        case(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
             auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioConfig.second);
             if(regularGpio == nullptr)  {
                 return GPIO_TYPE_FAILURE;
             }
-            // Check for conflicts and remove duplicates if necessary
-            result = checkForConflictsById(gpioConfig.first, gpioConfig.second->gpioType, mapToAdd);
+            /* Check for conflicts and remove duplicates if necessary */
+            result = checkForConflictsRegularGpio(gpioConfig.first, *regularGpio, mapToAdd);
             if(result != HasReturnvaluesIF::RETURN_OK) {
                 status = result;
             }
@@ -335,22 +279,15 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
             if(callbackGpio == nullptr)  {
                 return GPIO_TYPE_FAILURE;
             }
-            // Check for conflicts and remove duplicates if necessary
-            result = checkForConflictsById(gpioConfig.first,
-                    gpioConfig.second->gpioType, mapToAdd);
+            /* Check for conflicts and remove duplicates if necessary */
+            result = checkForConflictsCallbackGpio(gpioConfig.first, callbackGpio, mapToAdd);
             if(result != HasReturnvaluesIF::RETURN_OK) {
                 status = result;
             }
             break;
         }
         default: {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "Invalid GPIO type detected for GPIO ID " << gpioConfig.first
-                    << std::endl;
-#else
-            sif::printWarning("Invalid GPIO type detected for GPIO ID %d\n", gpioConfig.first);
-#endif
-            status = GPIO_TYPE_FAILURE;
+
         }
         }
     }
@@ -358,86 +295,50 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
 }
 
 
-ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
-        gpio::GpioTypes expectedType, GpioMap& mapToAdd) {
-    // Cross check with private map
+ReturnValue_t LinuxLibgpioIF::checkForConflictsRegularGpio(gpioId_t gpioIdToCheck,
+        GpiodRegularBase& gpioToCheck, GpioMap& mapToAdd) {
+    /* Cross check with private map */
     gpioMapIter = gpioMap.find(gpioIdToCheck);
     if(gpioMapIter != gpioMap.end()) {
         auto& gpioType = gpioMapIter->second->gpioType;
-        bool eraseDuplicateDifferentType = false;
-        switch(expectedType) {
-        case(gpio::GpioTypes::NONE): {
-            break;
-        }
-        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) {
-                eraseDuplicateDifferentType = true;
-            }
-            break;
-        }
-        case(gpio::GpioTypes::CALLBACK): {
-            if(gpioType != gpio::GpioTypes::CALLBACK) {
-                eraseDuplicateDifferentType = true;
-            }
-        }
-        }
-        if(eraseDuplicateDifferentType) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for "
-                    "different GPIO type " << gpioIdToCheck <<
-                    ". Removing duplicate from map to add" << std::endl;
-#else
-            sif::printWarning("LinuxLibgpioIF::checkForConflicts: ID already exists for "
-                    "different GPIO type %d. Removing duplicate from map to add\n", gpioIdToCheck);
-#endif
+        if(gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_CHIP and
+                gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
             mapToAdd.erase(gpioIdToCheck);
-            return GPIO_DUPLICATE_DETECTED;
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+        auto ownRegularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        if(ownRegularGpio == nullptr) {
+            return GPIO_TYPE_FAILURE;
         }
 
-        // Remove element from map to add because a entry for this GPIO already exists
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO "
-                "definition with ID " << gpioIdToCheck << " detected. " <<
-                "Duplicate will be removed from map to add" << std::endl;
-#else
-        sif::printWarning("LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition "
-                "with ID %d detected. Duplicate will be removed from map to add\n", gpioIdToCheck);
-#endif
+        /* Remove element from map to add because a entry for this GPIO
+        already exists */
+        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                << " detected. Duplicate will be removed from map to add." << std::endl;
         mapToAdd.erase(gpioIdToCheck);
-        return GPIO_DUPLICATE_DETECTED;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void LinuxLibgpioIF::parseFindeLineResult(int result, std::string& lineName) {
-    switch (result) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    case LINE_NOT_EXISTS:
-    case LINE_ERROR: {
-        sif::warning << "LinuxLibgpioIF::parseFindeLineResult: Line with name " << lineName <<
-                " does not exist" << std::endl;
-        break;
-    }
-    default: {
-        sif::warning << "LinuxLibgpioIF::parseFindeLineResult: Unknown return code for line "
-                "with name " << lineName << std::endl;
-        break;
-    }
-#else
-    case LINE_NOT_EXISTS:
-    case LINE_ERROR: {
-        sif::printWarning("LinuxLibgpioIF::parseFindeLineResult: Line with name %s "
-                "does not exist\n", lineName);
-        break;
-    }
-    default: {
-        sif::printWarning("LinuxLibgpioIF::parseFindeLineResult: Unknown return code for line "
-                "with name %s\n", lineName);
-        break;
-    }
-#endif
-    }
+ReturnValue_t LinuxLibgpioIF::checkForConflictsCallbackGpio(gpioId_t gpioIdToCheck,
+        GpioCallback *callbackGpio, GpioMap& mapToAdd) {
+    /* Cross check with private map */
+    gpioMapIter = gpioMap.find(gpioIdToCheck);
+    if(gpioMapIter != gpioMap.end()) {
+        if(gpioMapIter->second->gpioType != gpio::GpioTypes::CALLBACK) {
+            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
+            mapToAdd.erase(gpioIdToCheck);
+            return HasReturnvaluesIF::RETURN_OK;
+        }
 
+        /* Remove element from map to add because a entry for this GPIO
+        already exists */
+        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                << " detected. Duplicate will be removed from map to add." << std::endl;
+        mapToAdd.erase(gpioIdToCheck);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }

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

@@ -1,19 +1,19 @@
 #ifndef LINUX_GPIO_LINUXLIBGPIOIF_H_
 #define LINUX_GPIO_LINUXLIBGPIOIF_H_
 
-#include "fsfw/returnvalues/FwClassIds.h"
-#include "fsfw_hal/common/gpio/GpioIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
+#include "../../common/gpio/GpioIF.h"
+#include <returnvalues/classIds.h>
+#include <fsfw/objectmanager/SystemObject.h>
 
 class GpioCookie;
 class GpiodRegularIF;
 
 /**
- * @brief	This class implements the GpioIF for a linux based system.
- * @details
- * This implementation is based on the libgpiod lib which requires Linux 4.8 or higher.
- * @note
- * The Petalinux SDK from Xilinx supports libgpiod since Petalinux 2019.1.
+ * @brief	This class implements the GpioIF for a linux based system. The
+ * 			implementation is based on the libgpiod lib which requires linux 4.8
+ * 			or higher.
+ * @note	The Petalinux SDK from Xilinx supports libgpiod since Petalinux
+ * 			2019.1.
  */
 class LinuxLibgpioIF : public GpioIF, public SystemObject {
 public:
@@ -28,8 +28,6 @@ public:
             HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 3);
     static constexpr ReturnValue_t GPIO_INVALID_INSTANCE =
             HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
-    static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED =
-            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
 
 	LinuxLibgpioIF(object_id_t objectId);
 	virtual ~LinuxLibgpioIF();
@@ -40,13 +38,7 @@ public:
 	ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
 
 private:
-
-	static const size_t MAX_CHIPNAME_LENGTH = 11;
-	static const int LINE_NOT_EXISTS = 0;
-	static const int LINE_ERROR = -1;
-	static const int LINE_FOUND = 1;
-
-	// Holds the information and configuration of all used GPIOs
+	/* Holds the information and configuration of all used GPIOs */
 	GpioUnorderedMap gpioMap;
 	GpioUnorderedMapIter gpioMapIter;
 
@@ -61,10 +53,8 @@ private:
 
 	ReturnValue_t configureGpioByLabel(gpioId_t gpioId, GpiodRegularByLabel& gpioByLabel);
 	ReturnValue_t configureGpioByChip(gpioId_t gpioId, GpiodRegularByChip& gpioByChip);
-    ReturnValue_t configureGpioByLineName(gpioId_t gpioId,
-            GpiodRegularByLineName &gpioByLineName);
-    ReturnValue_t configureRegularGpio(gpioId_t gpioId, struct gpiod_chip* chip,
-            GpiodRegularBase& regularGpio, std::string failOutput);
+    ReturnValue_t configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+            struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput);
 
 	/**
 	 * @brief	This function checks if GPIOs are already registered and whether
@@ -77,15 +67,16 @@ private:
 	 */
 	ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
 
-	ReturnValue_t checkForConflictsById(gpioId_t gpiodId, gpio::GpioTypes type,
+	ReturnValue_t checkForConflictsRegularGpio(gpioId_t gpiodId, GpiodRegularBase& regularGpio,
 	        GpioMap& mapToAdd);
+    ReturnValue_t checkForConflictsCallbackGpio(gpioId_t gpiodId, GpioCallback* regularGpio,
+            GpioMap& mapToAdd);
 
 	/**
 	 * @brief   Performs the initial configuration of all GPIOs specified in the GpioMap mapToAdd.
 	 */
 	ReturnValue_t configureGpios(GpioMap& mapToAdd);
 
-	void parseFindeLineResult(int result, std::string& lineName);
 };
 
 #endif /* LINUX_GPIO_LINUXLIBGPIOIF_H_ */

src/fsfw/FSFW.h.in

@@ -16,13 +16,9 @@
 #cmakedefine FSFW_ADD_MONITORING
 #cmakedefine FSFW_ADD_SGP4_PROPAGATOR
 
-#ifndef FSFW_TCP_RECV_WIRETAPPING_ENABLED
-#define FSFW_TCP_RECV_WIRETAPPING_ENABLED   0
-#endif
-
 // Can be used for low-level debugging of the SPI bus
 #ifndef FSFW_HAL_SPI_WIRETAPPING
-#define FSFW_HAL_SPI_WIRETAPPING            0
+#define FSFW_HAL_SPI_WIRETAPPING      0
 #endif
 
 #ifndef FSFW_HAL_L3GD20_GYRO_DEBUG

src/fsfw/FSFWVersion.h

@@ -3,8 +3,8 @@
 
 const char* const FSFW_VERSION_NAME = "ASTP";
 
-#define FSFW_VERSION        1
-#define FSFW_SUBVERSION     2
+#define FSFW_VERSION        2
+#define FSFW_SUBVERSION     0
 #define FSFW_REVISION       0
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/devicehandlers/AssemblyBase.h

@@ -7,7 +7,7 @@
 
 /**
  * @brief   Base class to implement reconfiguration and failure handling for
- *          redundant devices by monitoring their modes and health states.
+ *          redundant devices by monitoring their modes health states.
  * @details
  * Documentation: Dissertation Baetz p.156, 157.
  *

src/fsfw/devicehandlers/DeviceCommunicationIF.h

@@ -85,10 +85,9 @@ public:
 	 * Called by DHB in the GET_WRITE doGetWrite().
 	 * Get send confirmation that the data in sendMessage() was sent successfully.
 	 * @param cookie
-	 * @return
-	 *  - @c RETURN_OK if data was sent successfully but a reply is expected
-	 *  - NO_REPLY_EXPECTED if data was sent successfully and no reply is expected
-	 *  - Everything else to indicate failure
+	 * @return - @c RETURN_OK if data was sent successfull
+	 * 		   - Everything else triggers falure event with
+	 * 		     returnvalue as parameter 1
 	 */
 	virtual ReturnValue_t getSendSuccess(CookieIF *cookie) = 0;
 

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -334,7 +334,8 @@ protected:
      *  - @c RETURN_OK to send command after #rawPacket and #rawPacketLen
      *       have been set.
      *  - @c HasActionsIF::EXECUTION_COMPLETE to generate a finish reply immediately. This can
-     *       be used if no reply is expected
+     *       be used if no reply is expected. Otherwise, the developer can call #actionHelper.finish
+     *       to finish the command handling.
      *  - Anything else triggers an event with the return code as a parameter as well as a
      *    step reply failed with the return code
      */

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -120,8 +120,7 @@ public:
 	static const ReturnValue_t WRONG_MODE_FOR_COMMAND = MAKE_RETURN_CODE(0xA5);
 	static const ReturnValue_t TIMEOUT = MAKE_RETURN_CODE(0xA6);
 	static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0xA7);
-	//!< Used to indicate that this is a command-only command.
-	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8);
+	static const ReturnValue_t NO_REPLY_EXPECTED = MAKE_RETURN_CODE(0xA8); //!< Used to indicate that this is a command-only command.
 	static const ReturnValue_t NON_OP_TEMPERATURE = MAKE_RETURN_CODE(0xA9);
 	static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xAA);
 

src/fsfw/globalfunctions/DleEncoder.cpp

@@ -165,11 +165,9 @@ ReturnValue_t DleEncoder::decodeStreamEscaped(const uint8_t *sourceStream, size_
     if (sourceStream[encodedIndex++] != STX_CHAR) {
         return DECODING_ERROR;
     }
-    while ((encodedIndex < sourceStreamLen)
-            and (decodedIndex < maxDestStreamlen)
-            and (sourceStream[encodedIndex] != ETX_CHAR)
-            and (sourceStream[encodedIndex] != STX_CHAR)) {
-        if (sourceStream[encodedIndex] == DLE_CHAR) {
+    while ((encodedIndex < sourceStreamLen) and (decodedIndex < maxDestStreamlen)) {
+        switch(sourceStream[encodedIndex]) {
+        case(DLE_CHAR): {
             if(encodedIndex + 1 >= sourceStreamLen) {
                 //reached the end of the sourceStream
                 *readLen = sourceStreamLen;
@@ -197,29 +195,33 @@ ReturnValue_t DleEncoder::decodeStreamEscaped(const uint8_t *sourceStream, size_
                 }
             }
             ++encodedIndex;
+            break;
         }
-        else {
+        case(STX_CHAR): {
+            *readLen = encodedIndex;
+            return DECODING_ERROR;
+        }
+        case(ETX_CHAR): {
+            *readLen = ++encodedIndex;
+            *decodedLen = decodedIndex;
+            return RETURN_OK;
+        }
+        default: {
             destStream[decodedIndex] = sourceStream[encodedIndex];
+            break;
+        }
         }
-
         ++encodedIndex;
         ++decodedIndex;
     }
-    if (sourceStream[encodedIndex] != ETX_CHAR) {
-        if(decodedIndex == maxDestStreamlen) {
-            //so far we did not find anything wrong here, so let user try again
-            *readLen = 0;
-            return STREAM_TOO_SHORT;
-        }
-        else {
-            *readLen = ++encodedIndex;
-            return DECODING_ERROR;
-        }
-    }
-    else {
-        *readLen = ++encodedIndex;
-        *decodedLen = decodedIndex;
-        return RETURN_OK;
+
+    if(decodedIndex == maxDestStreamlen) {
+        //so far we did not find anything wrong here, so let user try again
+        *readLen = 0;
+        return STREAM_TOO_SHORT;
+    } else {
+        *readLen = encodedIndex;
+        return DECODING_ERROR;
     }
 }
 

src/fsfw/globalfunctions/PeriodicOperationDivider.cpp

@@ -2,42 +2,43 @@
 
 
 PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
-        bool resetAutomatically): resetAutomatically(resetAutomatically),
-        counter(divider), divider(divider) {
+		bool resetAutomatically): resetAutomatically(resetAutomatically),
+		counter(divider), divider(divider) {
 }
 
 bool PeriodicOperationDivider::checkAndIncrement() {
-    counter++;
-    bool opNecessary = check();
-    if(opNecessary) {
-        if(resetAutomatically) {
-            resetCounter();
-        }
-    }
-    return opNecessary;
+	bool opNecessary = check();
+	if(opNecessary) {
+		if(resetAutomatically) {
+			counter = 0;
+		}
+		return opNecessary;
+	}
+	counter ++;
+	return opNecessary;
 }
 
 bool PeriodicOperationDivider::check() {
-    if(counter >= divider) {
-        return true;
-    }
-    return false;
+	if(counter >= divider) {
+		return true;
+	}
+	return false;
 }
 
 
 
 void PeriodicOperationDivider::resetCounter() {
-    counter = 0;
+	counter = 0;
 }
 
 void PeriodicOperationDivider::setDivider(uint32_t newDivider) {
-    divider = newDivider;
+	divider = newDivider;
 }
 
 uint32_t PeriodicOperationDivider::getCounter() const {
-    return counter;
+	return counter;
 }
 
 uint32_t PeriodicOperationDivider::getDivider() const {
-    return divider;
+	return divider;
 }

src/fsfw/globalfunctions/PeriodicOperationDivider.h

@@ -13,51 +13,51 @@
  */
 class PeriodicOperationDivider {
 public:
-    /**
-     * Initialize with the desired divider and specify whether the internal
-     * counter will be reset automatically.
-     * @param divider
-     * @param resetAutomatically
-     */
-    PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
+	/**
+	 * Initialize with the desired divider and specify whether the internal
+	 * counter will be reset automatically.
+	 * @param divider
+	 * @param resetAutomatically
+	 */
+	PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
 
 
-    /**
-     * Check whether operation is necessary.
-     * If an operation is necessary and the class has been
-     * configured to be reset automatically, the counter will be reset.
-     *
-     * @return
-     * -@c true if the counter is larger or equal to the divider
-     * -@c false otherwise
-     */
-    bool checkAndIncrement();
+	/**
+	 * Check whether operation is necessary.
+	 * If an operation is necessary and the class has been
+	 * configured to be reset automatically, the counter will be reset.
+	 *
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool checkAndIncrement();
 
-    /**
-     * Checks whether an operation is necessary.
-     * This function will not increment the counter!
-     * @return
-     * -@c true if the counter is larger or equal to the divider
-     * -@c false otherwise
-     */
-    bool check();
+	/**
+	 * Checks whether an operation is necessary.
+	 * This function will not increment the counter!
+	 * @return
+	 * -@c true if the counter is larger or equal to the divider
+	 * -@c false otherwise
+	 */
+	bool check();
 
-    /**
-     * Can be used to reset the counter to 0 manually.
-     */
-    void resetCounter();
-    uint32_t getCounter() const;
+	/**
+	 * Can be used to reset the counter to 0 manually.
+	 */
+	void resetCounter();
+	uint32_t getCounter() const;
 
-    /**
-     * Can be used to set a new divider value.
-     * @param newDivider
-     */
-    void setDivider(uint32_t newDivider);
-    uint32_t getDivider() const;
+	/**
+	 * Can be used to set a new divider value.
+	 * @param newDivider
+	 */
+	void setDivider(uint32_t newDivider);
+	uint32_t getDivider() const;
 private:
-    bool resetAutomatically = true;
-    uint32_t counter = 0;
-    uint32_t divider = 0;
+	bool resetAutomatically = true;
+	uint32_t counter = 0;
+	uint32_t divider = 0;
 };
 
 

src/fsfw/memory/HasFileSystemIF.h

@@ -81,7 +81,7 @@ public:
 	 * @param args Any other arguments which an implementation might require
 	 * @return
 	 */
-	virtual ReturnValue_t removeFile(const char* repositoryPath,
+	virtual ReturnValue_t deleteFile(const char* repositoryPath,
 	        const char* filename, void* args = nullptr) = 0;
 
 	/**

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -1,10 +1,8 @@
+#include "fsfw/osal/common/TcpTmTcServer.h"
+#include "fsfw/osal/common/TcpTmTcBridge.h"
+#include "fsfw/osal/common/tcpipHelpers.h"
+
 #include "fsfw/platform.h"
-#include "fsfw/FSFW.h"
-
-#include "TcpTmTcServer.h"
-#include "TcpTmTcBridge.h"
-#include "tcpipHelpers.h"
-
 #include "fsfw/container/SharedRingBuffer.h"
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/ipc/MutexGuard.h"

src/fsfw/osal/linux/CMakeLists.txt

@@ -13,10 +13,8 @@ target_sources(${LIB_FSFW_NAME}
 		QueueFactory.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
-		Timer.cpp
 		tcpipHelpers.cpp
 		unixUtility.cpp
-		CommandExecutor.cpp
 )
 
 find_package(Threads REQUIRED)

src/fsfw/osal/linux/CommandExecutor.cpp

@@ -1,185 +0,0 @@
-#include "CommandExecutor.h"
-
-#include "fsfw/serviceinterface.h"
-#include "fsfw/container/SimpleRingBuffer.h"
-#include "fsfw/container/DynamicFIFO.h"
-
-#include <unistd.h>
-
-#include <cstring>
-
-CommandExecutor::CommandExecutor(const size_t maxSize):
-readVec(maxSize) {
-    waiter.events = POLLIN;
-}
-
-ReturnValue_t CommandExecutor::load(std::string command, bool blocking, bool printOutput) {
-    if(state == States::PENDING) {
-        return COMMAND_PENDING;
-    }
-
-    currentCmd = command;
-    this->blocking = blocking;
-    this->printOutput = printOutput;
-    if(state == States::IDLE) {
-        state = States::COMMAND_LOADED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CommandExecutor::execute() {
-    if(state == States::IDLE) {
-        return NO_COMMAND_LOADED_OR_PENDING;
-    }
-    else if(state == States::PENDING) {
-        return COMMAND_PENDING;
-    }
-    currentCmdFile = popen(currentCmd.c_str(), "r");
-    if(currentCmdFile == nullptr) {
-        lastError = errno;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    if(blocking) {
-        return executeBlocking();
-    }
-    else {
-        currentFd = fileno(currentCmdFile);
-        waiter.fd = currentFd;
-    }
-    state = States::PENDING;
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CommandExecutor::close() {
-    if(state == States::PENDING) {
-        // Attempt to close process, irrespective of if it is running or not
-        if(currentCmdFile != nullptr) {
-            pclose(currentCmdFile);
-        }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void CommandExecutor::printLastError(std::string funcName) const {
-    if(lastError != 0) {
-        sif::error << funcName << " pclose failed with code " <<
-                lastError << ": " << strerror(lastError) << std::endl;
-    }
-}
-
-void CommandExecutor::setRingBuffer(SimpleRingBuffer *ringBuffer,
-        DynamicFIFO<uint16_t>* sizesFifo) {
-    this->ringBuffer = ringBuffer;
-    this->sizesFifo = sizesFifo;
-}
-
-ReturnValue_t CommandExecutor::check(bool& bytesRead) {
-    if(blocking) {
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    switch(state) {
-    case(States::IDLE):
-    case(States::COMMAND_LOADED): {
-        return NO_COMMAND_LOADED_OR_PENDING;
-    }
-    case(States::PENDING): {
-        break;
-    }
-    }
-
-    int result = poll(&waiter, 1, 0);
-    switch(result) {
-    case(0): {
-        return HasReturnvaluesIF::RETURN_OK;
-        break;
-    }
-    case(1): {
-        if (waiter.revents & POLLIN) {
-            ssize_t readBytes = read(currentFd, readVec.data(), readVec.size());
-            if(readBytes == 0) {
-                // Should not happen
-                sif::warning << "CommandExecutor::check: "
-                        "No bytes read after poll event.." << std::endl;
-                break;
-            }
-            else if(readBytes > 0) {
-                bytesRead = true;
-                if(printOutput) {
-                    // It is assumed the command output is line terminated
-                    sif::info << currentCmd << " | " << readVec.data();
-                }
-                if(ringBuffer != nullptr) {
-                    ringBuffer->writeData(reinterpret_cast<const uint8_t*>(
-                            readVec.data()), readBytes);
-                }
-                if(sizesFifo != nullptr) {
-                    if(not sizesFifo->full()) {
-                        sizesFifo->insert(readBytes);
-                    }
-                }
-                return BYTES_READ;
-            }
-            else {
-                // Should also not happen
-                sif::warning << "CommandExecutor::check: Error " << errno << ": " <<
-                        strerror(errno) << std::endl;
-            }
-        }
-        else if(waiter.revents & POLLERR) {
-            sif::warning << "CommandExecuter::check: Poll error" << std::endl;
-            return COMMAND_ERROR;
-        }
-        else if(waiter.revents & POLLHUP) {
-            int result = pclose(currentCmdFile);
-            if(result != 0) {
-                lastError = result;
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            state = States::IDLE;
-            currentCmdFile = nullptr;
-            currentFd = 0;
-            return EXECUTION_FINISHED;
-        }
-        break;
-    }
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-void CommandExecutor::reset() {
-    CommandExecutor::close();
-    currentCmdFile = nullptr;
-    currentFd = 0;
-    state = States::IDLE;
-}
-
-int CommandExecutor::getLastError() const {
-    return this->lastError;
-}
-
-CommandExecutor::States CommandExecutor::getCurrentState() const {
-    return state;
-}
-
-ReturnValue_t CommandExecutor::executeBlocking() {
-    while(fgets(readVec.data(), readVec.size(), currentCmdFile) != nullptr) {
-        std::string output(readVec.data());
-        if(printOutput) {
-            sif::info << currentCmd << " | " << output;
-        }
-        if(ringBuffer != nullptr) {
-            ringBuffer->writeData(reinterpret_cast<const uint8_t*>(output.data()), output.size());
-        }
-        if(sizesFifo != nullptr) {
-            if(not sizesFifo->full()) {
-                sizesFifo->insert(output.size());
-            }
-        }
-    }
-    int result = pclose(currentCmdFile);
-    if(result != 0) {
-        lastError = result;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-}

src/fsfw/osal/linux/CommandExecutor.h

@@ -1,134 +0,0 @@
-#ifndef FSFW_SRC_FSFW_OSAL_LINUX_COMMANDEXECUTOR_H_
-#define FSFW_SRC_FSFW_OSAL_LINUX_COMMANDEXECUTOR_H_
-
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/returnvalues/FwClassIds.h"
-
-#include <poll.h>
-
-#include <string>
-#include <vector>
-
-class SimpleRingBuffer;
-template <typename T> class DynamicFIFO;
-
-/**
- * @brief   Helper class to execute shell commands in blocking and non-blocking mode
- * @details
- * This class is able to execute processes by using the Linux popen call. It also has the
- * capability of writing the read output of a process into a provided ring buffer.
- *
- * The executor works by first loading the command which should be executed and specifying
- * whether it should be executed blocking or non-blocking. After that, execution can be started
- * with the execute command. In blocking mode, the execute command will block until the command
- * has finished
- */
-class CommandExecutor {
-public:
-    enum class States {
-        IDLE,
-        COMMAND_LOADED,
-        PENDING
-    };
-
-    static constexpr uint8_t CLASS_ID = CLASS_ID::LINUX_OSAL;
-
-    //! [EXPORT] : [COMMENT] Execution of the current command has finished
-    static constexpr ReturnValue_t EXECUTION_FINISHED =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
-
-    //! [EXPORT] : [COMMENT] Command is pending. This will also be returned if the user tries
-    //! to load another command but a command is still pending
-    static constexpr ReturnValue_t COMMAND_PENDING =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
-    //! [EXPORT] : [COMMENT] Some bytes have been read from the executing process
-    static constexpr ReturnValue_t BYTES_READ =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
-    //! [EXPORT] : [COMMENT] Command execution failed
-    static constexpr ReturnValue_t COMMAND_ERROR =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
-    //! [EXPORT] : [COMMENT]
-    static constexpr ReturnValue_t NO_COMMAND_LOADED_OR_PENDING =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 4);
-    static constexpr ReturnValue_t PCLOSE_CALL_ERROR =
-            HasReturnvaluesIF::makeReturnCode(CLASS_ID, 6);
-
-    /**
-     * Constructor. Is initialized with maximum size of internal buffer to read data from the
-     * executed process.
-     * @param maxSize
-     */
-    CommandExecutor(const size_t maxSize);
-
-    /**
-     * Load a new command which should be executed
-     * @param command
-     * @param blocking
-     * @param printOutput
-     * @return
-     */
-    ReturnValue_t load(std::string command, bool blocking, bool printOutput = true);
-    /**
-     * Execute the loaded command.
-     * @return
-     *  - In blocking mode, it will return RETURN_FAILED if
-     *    the result of the system call was not 0. The error value can be accessed using
-     *    getLastError
-     *  - In non-blocking mode, this call will start
-     *    the execution and then return RETURN_OK
-     */
-    ReturnValue_t execute();
-    /**
-     * Only used in non-blocking mode. Checks the currently running command.
-     * @param bytesRead Will be set to the number of bytes read, if bytes have been read
-     * @return
-     *  - BYTES_READ if bytes have been read from the executing process. It is recommended to call
-     *    check again after this
-     *  - RETURN_OK execution is pending, but no bytes have been read from the executing process
-     *  - RETURN_FAILED if execution has failed, error value can be accessed using getLastError
-     *  - EXECUTION_FINISHED if the process was executed successfully
-     *  - COMMAND_ERROR internal poll error
-     */
-    ReturnValue_t check(bool& bytesRead);
-    /**
-     * Abort the current command. Should normally not be necessary, check can be used to find
-     * out whether command execution was successful
-     * @return RETURN_OK
-     */
-    ReturnValue_t close();
-
-    States getCurrentState() const;
-    int getLastError() const;
-    void printLastError(std::string funcName) const;
-
-    /**
-     * Assign a ring buffer and a FIFO which will be filled by the executor with the output
-     * read from the started process
-     * @param ringBuffer
-     * @param sizesFifo
-     */
-    void setRingBuffer(SimpleRingBuffer* ringBuffer, DynamicFIFO<uint16_t>* sizesFifo);
-
-    /**
-     * Reset the executor. This calls close internally and then reset the state machine so new
-     * commands can be loaded and executed
-     */
-    void reset();
-private:
-    std::string currentCmd;
-    bool blocking = true;
-    FILE* currentCmdFile = nullptr;
-    int currentFd = 0;
-    bool printOutput = true;
-    std::vector<char> readVec;
-    struct pollfd waiter {};
-    SimpleRingBuffer* ringBuffer = nullptr;
-    DynamicFIFO<uint16_t>* sizesFifo = nullptr;
-
-    States state = States::IDLE;
-    int lastError = 0;
-
-    ReturnValue_t executeBlocking();
-};
-
-#endif /* FSFW_SRC_FSFW_OSAL_LINUX_COMMANDEXECUTOR_H_ */

src/fsfw/osal/linux/MessageQueue.cpp

@@ -285,10 +285,10 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 
             utility::printUnixErrorGeneric(CLASS_NAME, "sendMessageFromMessageQueue", "EBADF");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::warning << "mq_send to " << sendTo << " sent from "
-                    << sentFrom << " failed" << std::endl;
+            sif::warning << "mq_send to: " << sendTo << " sent from "
+                    << sentFrom << "failed" << std::endl;
 #else
-            sif::printWarning("mq_send to %d sent from %d failed\n", sendTo, sentFrom);
+            sif::printWarning("mq_send to: %d sent from %d failed\n", sendTo, sentFrom);
 #endif
             return DESTINATION_INVALID;
         }

src/fsfw/osal/linux/Timer.cpp

@@ -1,57 +0,0 @@
-#include "fsfw/osal/linux/Timer.h"
-#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
-#include <errno.h>
-
-
-Timer::Timer() {
-	sigevent sigEvent;
-	sigEvent.sigev_notify = SIGEV_NONE;
-	sigEvent.sigev_signo = 0;
-	sigEvent.sigev_value.sival_ptr = &timerId;
-	int status = timer_create(CLOCK_MONOTONIC, &sigEvent, &timerId);
-	if(status!=0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Timer creation failed with: " << status <<
-				" errno: " << errno << std::endl;
-#endif
-	}
-}
-
-Timer::~Timer() {
-	timer_delete(timerId);
-}
-
-int Timer::setTimer(uint32_t intervalMs) {
-	itimerspec timer;
-	timer.it_value.tv_sec = intervalMs / 1000;
-	timer.it_value.tv_nsec = (intervalMs * 1000000) % (1000000000);
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	set = true;
-	return timer_settime(timerId, 0, &timer, NULL);
-}
-
-
-int Timer::getTimer(uint32_t* remainingTimeMs){
-	itimerspec timer;
-	timer.it_value.tv_sec = 0;
-	timer.it_value.tv_nsec = 0;
-	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_nsec = 0;
-	int status = timer_gettime(timerId, &timer);
-
-	*remainingTimeMs = timer.it_value.tv_sec * 1000 + timer.it_value.tv_nsec / 1000000;
-
-	return status;
-}
-
-bool Timer::isSet() const {
-    return this->set;
-}
-
-void Timer::resetTimer() {
-    if(not this->set) {
-        set = false;
-    }
-    setTimer(0);
-}

src/fsfw/osal/linux/Timer.h

@@ -1,49 +0,0 @@
-#ifndef FRAMEWORK_OSAL_LINUX_TIMER_H_
-#define FRAMEWORK_OSAL_LINUX_TIMER_H_
-
-#include <signal.h>
-#include <time.h>
-#include <stdint.h>
-
-/**
- * This class is a helper for the creation of a Clock Monotonic timer which does not trigger a signal
- */
-class Timer {
-public:
-	/**
-	 * Creates the Timer sets the timerId Member
-	 */
-	Timer();
-	/**
-	 * Deletes the timer
-	 *
-	 * Careful! According to POSIX documentation:
-	 * The treatment of any pending signal generated by the deleted timer is unspecified.
-	 */
-	virtual ~Timer();
-
-	/**
-	 * Set the timer given in timerId to the given interval
-	 *
-	 * @param intervalMs Interval in ms to be set
-	 * @return 0 on Success 1 else
-	 */
-	int setTimer(uint32_t intervalMs);
-
-	/**
-	 * Get the remaining time of the timer
-	 *
-	 * @param remainingTimeMs Pointer to integer value which is used to return the remaining time
-	 * @return 0 on Success 1 else (see timer_getime documentation of posix function)
-	 */
-	int getTimer(uint32_t* remainingTimeMs);
-
-	bool isSet() const;
-	void resetTimer();
-
-private:
-	bool set = true;
-	timer_t timerId;
-};
-
-#endif /* FRAMEWORK_OSAL_LINUX_TIMER_H_ */

src/fsfw/pus/Service5EventReporting.cpp

@@ -41,7 +41,8 @@ ReturnValue_t Service5EventReporting::performService() {
 	    }
 	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::warning <<  "Service5EventReporting::generateEventReport: Too many events" << std::endl;
+	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	        " Too many events" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -63,11 +64,8 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "Service5EventReporting::generateEventReport: "
-		        "Could not send TM packet" << std::endl;
-#else
-		sif::printWarning("Service5EventReporting::generateEventReport: "
-                "Could not send TM packet\n");
+		sif::debug << "Service5EventReporting::generateEventReport:"
+		        " Could not send TM packet" << std::endl;
 #endif
 	}
 	return result;

src/fsfw/pus/Service8FunctionManagement.cpp

@@ -33,8 +33,8 @@ ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
 	if(tcDataLen < sizeof(object_id_t)) {
 		return CommandingServiceBase::INVALID_TC;
 	}
-	// Can't fail, size was checked before
-	SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(objectId, &tcData,
+			&tcDataLen, SerializeIF::Endianness::BIG);
 
 	return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }

src/fsfw/returnvalues/HasReturnvaluesIF.h

@@ -22,9 +22,9 @@ public:
 	 * @param number
 	 * @return
 	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t classId,
+	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
 			uint8_t number) {
-	    return (static_cast<ReturnValue_t>(classId) << 8) + number;
+	    return (static_cast<ReturnValue_t>(interfaceId) << 8) + number;
 	}
 };
 

src/fsfw/subsystem/SubsystemBase.h

@@ -62,8 +62,7 @@ protected:
 	struct ChildInfo {
 		MessageQueueId_t commandQueue;
 		Mode_t mode;
-		Submode_t submode;
-		bool healthChanged;
+		Submode_t submode;bool healthChanged;
 	};
 
 	Mode_t mode;

src/fsfw/timemanager/Countdown.cpp

@@ -6,16 +6,14 @@ Countdown::Countdown(uint32_t initialTimeout): timeout(initialTimeout) {
 Countdown::~Countdown() {
 }
 
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
-	timeout = miliseconds;
-	return return_value;
+ReturnValue_t Countdown::setTimeout(uint32_t milliseconds) {
+	ReturnValue_t returnValue = Clock::getUptime( &startTime );
+	timeout = milliseconds;
+	return returnValue;
 }
 
 bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
+	if ( uint32_t( this->getCurrentTime() - startTime) >= timeout) {
 		return true;
 	} else {
 		return false;
@@ -31,7 +29,23 @@ ReturnValue_t Countdown::resetTimer() {
 }
 
 void Countdown::timeOut() {
-	uint32_t current_time;
-		Clock::getUptime( &current_time );
-	startTime= current_time - timeout;
+	startTime = this->getCurrentTime() - timeout;
+}
+
+uint32_t Countdown::getRemainingMillis() const {
+	// We fetch the time before the if-statement
+	// to be sure that the return is in
+	// range 0 <= number <= timeout
+	uint32_t currentTime = this->getCurrentTime();
+	if (this->hasTimedOut()){
+		return 0;
+	}else{
+		return (startTime + timeout) - currentTime;
+	}
+}
+
+uint32_t Countdown::getCurrentTime() const {
+	uint32_t currentTime;
+	Clock::getUptime( &currentTime );
+	return currentTime;
 }

src/fsfw/timemanager/Countdown.h

@@ -4,28 +4,77 @@
 #include "Clock.h"
 
 /**
- * @brief	This file defines the Countdown class.
- * @author	baetz
+ *
+ * Countdown keeps track of a timespan.
+ *
+ * Countdown::resetTimer restarts the timer.
+ * Countdown::setTimeout sets a new countdown duration and resets.
+ *
+ * Can be checked with Countdown::hasTimedOut or
+ * Countdown::isBusy.
+ *
+ * Countdown::timeOut will force the timer to time out.
+ *
  */
 class Countdown {
 public:
-	uint32_t timeout;
+	/**
+	 * Constructor which sets the countdown duration in milliseconds
+	 *
+	 * It does not start the countdown!
+	 * Call resetTimer or setTimeout before usage!
+	 * Otherwise a call to hasTimedOut might return True.
+	 *
+	 * @param initialTimeout Countdown duration in milliseconds
+	 */
 	Countdown(uint32_t initialTimeout = 0);
 	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
-
+	/**
+	 * Call to set a new countdown duration.
+	 *
+	 * Resets the countdown!
+	 *
+	 * @param milliseconds new countdown duration in milliseconds
+	 * @return Returnvalue from Clock::getUptime
+	 */
+	ReturnValue_t setTimeout(uint32_t milliseconds);
+	/**
+	 * Returns true if the countdown duration has passed.
+	 *
+	 * @return True if the countdown has passed
+	 * 		   False if it is still running
+	 */
 	bool hasTimedOut() const;
-
+	/**
+	 * Complementary to hasTimedOut.
+	 *
+	 * @return True if the countdown is till running
+	 * 		   False if it is still running
+	 */
 	bool isBusy() const;
-
-	//!< Use last set timeout value and restart timer.
+	/**
+	 *  Uses last set timeout value and restarts timer.
+	 */
 	ReturnValue_t resetTimer();
-
-	//!< Make hasTimedOut() return true
+	/**
+	 * Returns the remaining milliseconds (0 if timeout)
+	 */
+	uint32_t getRemainingMillis() const;
+	/**
+	 * Makes hasTimedOut() return true
+	 */
 	void timeOut();
-
+	/**
+	 * Internal countdown duration in milliseconds
+	 */
+	uint32_t timeout;
 private:
+	/**
+	 * Last time the timer was started (uptime)
+	 */
 	uint32_t startTime = 0;
+
+	uint32_t getCurrentTime() const;
 };
 
 #endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

src/fsfw/tmtcpacket/SpacePacket.h

@@ -19,7 +19,8 @@ public:
 	/**
 	 * The constructor initializes the packet and sets all header information
 	 * according to the passed parameters.
-	 * @param packetDataLength Sets the packet data length field and therefore specifies the size of the packet.
+	 * @param packetDataLength Sets the packet data length field and therefore specifies
+	 * the size of the packet.
 	 * @param isTelecommand Sets the packet type field to either TC (true) or TM (false).
 	 * @param apid Sets the packet's APID field. The default value describes an idle packet.
 	 * @param sequenceCount ets the packet's Source Sequence Count field.

src/fsfw/tmtcpacket/SpacePacketBase.cpp

@@ -4,7 +4,7 @@
 #include <cstring>
 
 SpacePacketBase::SpacePacketBase(const uint8_t* setAddress) {
-	this->data = reinterpret_cast<SpacePacketPointer*>(const_cast<uint8_t*>(setAddress));
+    this->data = reinterpret_cast<SpacePacketPointer*>(const_cast<uint8_t*>(setAddress));
 }
 
 SpacePacketBase::~SpacePacketBase() {
@@ -12,11 +12,11 @@ SpacePacketBase::~SpacePacketBase() {
 
 //CCSDS Methods:
 uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
-	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+    return (this->data->header.packet_id_h & 0b11100000) >> 5;
 }
 
 ReturnValue_t SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
-		bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
+        bool hasSecondaryHeader, uint16_t apid, uint16_t sequenceCount) {
     if(data == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -28,41 +28,42 @@ ReturnValue_t SpacePacketBase::initSpacePacketHeader(bool isTelecommand,
 #endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
-	//reset header to zero:
-	memset(data, 0, sizeof(this->data->header) );
-	//Set TC/TM bit.
-	data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
-	//Set secondaryHeader bit
-	data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
-	this->setAPID( apid );
-	//Always initialize as standalone packets.
-	data->header.sequence_control_h = 0b11000000;
-	setPacketSequenceCount(sequenceCount);
-	return HasReturnvaluesIF::RETURN_OK;
+    //reset header to zero:
+    memset(data, 0, sizeof(this->data->header) );
+    //Set TC/TM bit.
+    data->header.packet_id_h = ((isTelecommand? 1 : 0)) << 4;
+    //Set secondaryHeader bit
+    data->header.packet_id_h |= ((hasSecondaryHeader? 1 : 0)) << 3;
+    this->setAPID( apid );
+    //Always initialize as standalone packets.
+    data->header.sequence_control_h = 0b11000000;
+    setPacketSequenceCount(sequenceCount);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 bool SpacePacketBase::isTelecommand( void ) {
-	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+    return (this->data->header.packet_id_h & 0b00010000) >> 4;
 }
 
 bool SpacePacketBase::hasSecondaryHeader( void ) {
-	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+    return (this->data->header.packet_id_h & 0b00001000) >> 3;
 }
 
 uint16_t SpacePacketBase::getPacketId() {
-	return ( (this->data->header.packet_id_h) << 8 ) +
-			this->data->header.packet_id_l;
+    return ( (this->data->header.packet_id_h) << 8 ) +
+            this->data->header.packet_id_l;
 }
 
 uint16_t SpacePacketBase::getAPID( void ) const {
-	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
-			this->data->header.packet_id_l;
+    return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+            this->data->header.packet_id_l;
 }
 
 void SpacePacketBase::setAPID( uint16_t new_apid ) {
-	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
-	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
-	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+    // Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+    this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) |
+            ( ( new_apid & 0x0700 ) >> 8 );
+    this->data->header.packet_id_l = ( new_apid & 0x00FF );
 }
 
 void SpacePacketBase::setSequenceFlags( uint8_t sequenceflags ) {
@@ -71,51 +72,52 @@ void SpacePacketBase::setSequenceFlags( uint8_t sequenceflags ) {
 }
 
 uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
-	return ( (this->data->header.sequence_control_h) << 8 )
-		+ this->data->header.sequence_control_l;
+    return ( (this->data->header.sequence_control_h) << 8 )
+            + this->data->header.sequence_control_l;
 }
 
 uint8_t SpacePacketBase::getSequenceFlags( void ) {
-	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+    return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
 }
 
 uint16_t SpacePacketBase::getPacketSequenceCount( void ) const {
-	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
-		+ this->data->header.sequence_control_l;
+    return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+            + this->data->header.sequence_control_l;
 }
 
 void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
-	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
-	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+    this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) |
+            ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+    this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
 }
 
 uint16_t SpacePacketBase::getPacketDataLength() const {
-	return ( (this->data->header.packet_length_h) << 8 )
-		+ this->data->header.packet_length_l;
+    return ( (this->data->header.packet_length_h) << 8 )
+            + this->data->header.packet_length_l;
 }
 
 void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
-	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
-	this->data->header.packet_length_l = ( new_length & 0x00FF );
+    this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+    this->data->header.packet_length_l = ( new_length & 0x00FF );
 }
 
 size_t SpacePacketBase::getFullSize() {
-	//+1 is done because size in packet data length field is: size of data field -1
-	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+    // +1 is done because size in packet data length field is: size of data field -1
+    return this->getPacketDataLength() + sizeof(this->data->header) + 1;
 }
 
 uint8_t* SpacePacketBase::getWholeData() {
-	return (uint8_t*)this->data;
+    return (uint8_t*)this->data;
 }
 
 void SpacePacketBase::setData( const uint8_t* p_Data ) {
-	this->data = (SpacePacketPointer*)p_Data;
+    this->data = (SpacePacketPointer*)p_Data;
 }
 
 uint32_t SpacePacketBase::getApidAndSequenceCount() const {
-	return (getAPID() << 16) + getPacketSequenceCount();
+    return (getAPID() << 16) + getPacketSequenceCount();
 }
 
 uint8_t* SpacePacketBase::getPacketData() {
-	return &(data->packet_data);
+    return &(data->packet_data);
 }

src/fsfw/tmtcpacket/SpacePacketBase.h

@@ -22,8 +22,8 @@
  * @ingroup tmtcpackets
  */
 struct SpacePacketPointer {
-	CCSDSPrimaryHeader header;
-	uint8_t packet_data;
+    CCSDSPrimaryHeader header;
+    uint8_t packet_data;
 };
 
 /**
@@ -39,150 +39,151 @@ struct SpacePacketPointer {
  */
 class SpacePacketBase {
 protected:
-	/**
-	 * A pointer to a structure which defines the data structure of
-	 * the packet header.
-	 * To be hardware-safe, all elements are of byte size.
-	 */
-	SpacePacketPointer* data;
+    /**
+     * A pointer to a structure which defines the data structure of
+     * the packet header.
+     * To be hardware-safe, all elements are of byte size.
+     */
+    SpacePacketPointer* data;
 public:
-	static const uint16_t LIMIT_APID = 2048; //2^1
-	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
-	static const uint16_t APID_IDLE_PACKET = 0x7FF;
-	static const uint8_t TELECOMMAND_PACKET = 1;
-	static const uint8_t TELEMETRY_PACKET = 0;
-	/**
-	 * This definition defines the CRC size in byte.
-	 */
-	static const uint8_t CRC_SIZE = 2;
-	/**
-	 * This is the minimum size of a SpacePacket.
-	 */
-	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
-	/**
-	 * This is the default constructor.
-	 * It sets its internal data pointer to the address passed.
-	 * @param set_address	The position where the packet data lies.
-	 */
-	SpacePacketBase( const uint8_t* set_address );
-	/**
-	 * No data is allocated, so the destructor is empty.
-	 */
-	virtual ~SpacePacketBase();
+    static const uint16_t LIMIT_APID = 2048; //2^1
+    static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+    static const uint16_t APID_IDLE_PACKET = 0x7FF;
+    static const uint8_t TELECOMMAND_PACKET = 1;
+    static const uint8_t TELEMETRY_PACKET = 0;
+    /**
+     * This definition defines the CRC size in byte.
+     */
+    static const uint8_t CRC_SIZE = 2;
+    /**
+     * This is the minimum size of a SpacePacket.
+     */
+    static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+    /**
+     * This is the default constructor.
+     * It sets its internal data pointer to the address passed.
+     * @param set_address	The position where the packet data lies.
+     */
+    SpacePacketBase( const uint8_t* set_address );
+    /**
+     * No data is allocated, so the destructor is empty.
+     */
+    virtual ~SpacePacketBase();
 
-	//CCSDS Methods:
-	/**
-	 * Getter for the packet version number field.
-	 * @return Returns the highest three bit of the packet in one byte.
-	 */
-	uint8_t getPacketVersionNumber( void );
-	/**
-	 * This method checks the type field in the header.
-	 * This bit specifies, if the command is interpreted as Telecommand of
-	 * as Telemetry. For a Telecommand, the bit is set.
-	 * @return Returns true if the bit is set and false if not.
-	 */
-	bool isTelecommand( void );
+    //CCSDS Methods
 
-	ReturnValue_t initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader,
-	        uint16_t apid, uint16_t sequenceCount = 0);
-	/**
-	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
-	 *  which is checked with this method.
-	 * @return	Returns true if the bit is set and false if not.
-	 */
-	bool hasSecondaryHeader( void );
-	/**
-	 * Returns the complete first two bytes of the packet, which together form
-	 * the CCSDS packet id.
-	 * @return	The CCSDS packet id.
-	 */
-	uint16_t getPacketId( void );
-	/**
-	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @return The CCSDS APID.
-	 */
-	uint16_t getAPID( void ) const;
-	/**
-	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
-	 * id.
-	 * @param 	The APID to set. The highest five bits of the parameter are
-	 * 			ignored.
-	 */
-	void setAPID( uint16_t setAPID );
+    /**
+     * Getter for the packet version number field.
+     * @return Returns the highest three bit of the packet in one byte.
+     */
+    uint8_t getPacketVersionNumber( void );
+    /**
+     * This method checks the type field in the header.
+     * This bit specifies, if the command is interpreted as Telecommand of
+     * as Telemetry. For a Telecommand, the bit is set.
+     * @return Returns true if the bit is set and false if not.
+     */
+    bool isTelecommand( void );
 
-	/**
+    ReturnValue_t initSpacePacketHeader(bool isTelecommand, bool hasSecondaryHeader,
+            uint16_t apid, uint16_t sequenceCount = 0);
+    /**
+     * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+     *  which is checked with this method.
+     * @return	Returns true if the bit is set and false if not.
+     */
+    bool hasSecondaryHeader( void );
+    /**
+     * Returns the complete first two bytes of the packet, which together form
+     * the CCSDS packet id.
+     * @return	The CCSDS packet id.
+     */
+    uint16_t getPacketId( void );
+    /**
+     * Returns the APID of a packet, which are the lowest 11 bit of the packet
+     * id.
+     * @return The CCSDS APID.
+     */
+    uint16_t getAPID( void ) const;
+    /**
+     * Sets the APID of a packet, which are the lowest 11 bit of the packet
+     * id.
+     * @param 	The APID to set. The highest five bits of the parameter are
+     * 			ignored.
+     */
+    void setAPID( uint16_t setAPID );
+
+    /**
      * Sets the sequence flags of a packet, which are bit 17 and 18 in the space packet header.
      * @param   The sequence flags to set
      */
     void setSequenceFlags( uint8_t sequenceflags );
 
-	/**
-	 * Returns the CCSDS packet sequence control field, which are the third and
-	 * the fourth byte of the CCSDS primary header.
-	 * @return The CCSDS packet sequence control field.
-	 */
-	uint16_t getPacketSequenceControl( void );
-	/**
-	 * Returns the SequenceFlags, which are the highest two bit of the packet
-	 * sequence control field.
-	 * @return	The CCSDS sequence flags.
-	 */
-	uint8_t getSequenceFlags( void );
-	/**
-	 * Returns the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * @return The CCSDS sequence count.
-	 */
-	uint16_t getPacketSequenceCount( void ) const;
-	/**
-	 * Sets the packet sequence count, which are the lowest 14 bit of the
-	 * packet sequence control field.
-	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
-	 * @param setCount	The value to set the count to.
-	 */
-	void setPacketSequenceCount( uint16_t setCount );
-	/**
-	 * Returns the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header. The packet data length is the size of every kind
-	 * of data \b after the CCSDS Primary Header \b -1.
-	 * @return
-	 * The CCSDS packet data length. uint16_t is sufficient,
-	 * because this is limit in CCSDS standard
-	 */
-	uint16_t getPacketDataLength(void) const;
-	/**
-	 * Sets the packet data length, which is the fifth and sixth byte of the
-	 * CCSDS Primary Header.
-	 * @param setLength The value of the length to set. It must fit the true
-	 * 					CCSDS packet data length . The packet data length is
-	 * 					the size of every kind of data \b after the CCSDS
-	 * 					Primary Header \b -1.
-	 */
-	void setPacketDataLength( uint16_t setLength );
+    /**
+     * Returns the CCSDS packet sequence control field, which are the third and
+     * the fourth byte of the CCSDS primary header.
+     * @return The CCSDS packet sequence control field.
+     */
+    uint16_t getPacketSequenceControl( void );
+    /**
+     * Returns the SequenceFlags, which are the highest two bit of the packet
+     * sequence control field.
+     * @return	The CCSDS sequence flags.
+     */
+    uint8_t getSequenceFlags( void );
+    /**
+     * Returns the packet sequence count, which are the lowest 14 bit of the
+     * packet sequence control field.
+     * @return The CCSDS sequence count.
+     */
+    uint16_t getPacketSequenceCount( void ) const;
+    /**
+     * Sets the packet sequence count, which are the lowest 14 bit of the
+     * packet sequence control field.
+     * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+     * @param setCount	The value to set the count to.
+     */
+    void setPacketSequenceCount( uint16_t setCount );
+    /**
+     * Returns the packet data length, which is the fifth and sixth byte of the
+     * CCSDS Primary Header. The packet data length is the size of every kind
+     * of data \b after the CCSDS Primary Header \b -1.
+     * @return
+     * The CCSDS packet data length. uint16_t is sufficient,
+     * because this is limit in CCSDS standard
+     */
+    uint16_t getPacketDataLength(void) const;
+    /**
+     * Sets the packet data length, which is the fifth and sixth byte of the
+     * CCSDS Primary Header.
+     * @param setLength The value of the length to set. It must fit the true
+     * 					CCSDS packet data length . The packet data length is
+     * 					the size of every kind of data \b after the CCSDS
+     * 					Primary Header \b -1.
+     */
+    void setPacketDataLength( uint16_t setLength );
 
-	//Helper methods:
-	/**
-	 * This method returns a raw uint8_t pointer to the packet.
-	 * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-	 */
-	virtual uint8_t* getWholeData( void );
+    // Helper methods
+    /**
+     * This method returns a raw uint8_t pointer to the packet.
+     * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
+     */
+    virtual uint8_t* getWholeData( void );
 
-	uint8_t* getPacketData();
-	/**
-	 * With this method, the packet data pointer can be redirected to another
-	 * location.
-	 * @param p_Data A pointer to another raw Space Packet.
-	 */
-	virtual void setData( const uint8_t* p_Data );
-	/**
-	 * This method returns the full raw packet size.
-	 * @return	The full size of the packet in bytes.
-	 */
-	size_t getFullSize();
+    uint8_t* getPacketData();
+    /**
+     * With this method, the packet data pointer can be redirected to another
+     * location.
+     * @param p_Data A pointer to another raw Space Packet.
+     */
+    virtual void setData( const uint8_t* p_Data );
+    /**
+     * This method returns the full raw packet size.
+     * @return	The full size of the packet in bytes.
+     */
+    size_t getFullSize();
 
-	uint32_t getApidAndSequenceCount() const;
+    uint32_t getApidAndSequenceCount() const;
 
 };
 

src/fsfw/tmtcpacket/pus/definitions.h

@@ -0,0 +1,16 @@
+#ifndef FSFW_SRC_FSFW_TMTCPACKET_PUS_TM_DEFINITIONS_H_
+#define FSFW_SRC_FSFW_TMTCPACKET_PUS_TM_DEFINITIONS_H_
+
+#include <cstdint>
+
+namespace pus {
+
+//! Version numbers according to ECSS-E-ST-70-41C p.439
+enum PusVersion: uint8_t {
+    PUS_A_VERSION = 1,
+    PUS_C_VERSION = 2
+};
+
+}
+
+#endif /* FSFW_SRC_FSFW_TMTCPACKET_PUS_TM_DEFINITIONS_H_ */

src/fsfw/tmtcpacket/pus/tc/TcPacketPus.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/tmtcpacket/pus/tc/TcPacketPus.h"
+#include "TcPacketPus.h"
 #include "fsfw/globalfunctions/CRC.h"
 
 #include <cstring>
@@ -8,14 +8,13 @@ TcPacketPus::TcPacketPus(const uint8_t *setData): TcPacketBase(setData) {
 }
 
 void TcPacketPus::initializeTcPacket(uint16_t apid, uint16_t sequenceCount,
-        uint8_t ack, uint8_t service, uint8_t subservice, uint16_t sourceId) {
+        uint8_t ack, uint8_t service, uint8_t subservice, pus::PusVersion pusVersion,
+        uint16_t sourceId) {
     initSpacePacketHeader(true, true, apid, sequenceCount);
     std::memset(&tcData->dataField, 0, sizeof(tcData->dataField));
     setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-    // Data Field Header:
-    // Set CCSDS_secondary_header_flag to 0 and version number to 001
-    tcData->dataField.versionTypeAck = 0b00010000;
-    tcData->dataField.versionTypeAck |= (ack & 0x0F);
+    // Data Field Header. For PUS A, the first bit (CCSDS Secondary Header Flag) is zero
+    tcData->dataField.versionTypeAck = pusVersion << 4 | (ack & 0x0F);
     tcData->dataField.serviceType = service;
     tcData->dataField.serviceSubtype = subservice;
 #if FSFW_USE_PUS_C_TELECOMMANDS == 1

src/fsfw/tmtcpacket/pus/tc/TcPacketPus.h

@@ -2,6 +2,7 @@
 #define FSFW_TMTCPACKET_PUS_TCPACKETPUSA_H_
 
 #include "fsfw/FSFW.h"
+#include "../definitions.h"
 #include "fsfw/tmtcpacket/ccsds_header.h"
 #include "TcPacketBase.h"
 
@@ -75,7 +76,8 @@ protected:
      * @param subservice PUS Subservice
      */
     void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
-            uint8_t service, uint8_t subservice, uint16_t sourceId = 0);
+            uint8_t service, uint8_t subservice, pus::PusVersion pusVersion,
+            uint16_t sourceId = 0);
 
     /**
      * A pointer to a structure which defines the data structure of

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.cpp

@@ -23,7 +23,12 @@ TcPacketStoredPus::TcPacketStoredPus(uint16_t apid,  uint8_t service,
         return;
     }
     this->setData(pData);
-    initializeTcPacket(apid, sequenceCount, ack, service, subservice);
+#if FSFW_USE_PUS_C_TELECOMMANDS == 1
+    pus::PusVersion pusVersion = pus::PusVersion::PUS_C_VERSION;
+#else
+    pus::PusVersion pusVersion = pus::PusVersion::PUS_A_VERSION;
+#endif
+    initializeTcPacket(apid, sequenceCount, ack, service, subservice, pusVersion);
     std::memcpy(&tcData->appData, data, size);
     this->setPacketDataLength(
             size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);

src/fsfw/tmtcpacket/pus/tm/TmPacketBase.h

@@ -31,8 +31,6 @@ public:
     //! Maximum size of a TM Packet in this mission.
     //! TODO: Make this dependant on a config variable.
     static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
-    //! First four bits of first byte of secondary header
-    static const uint8_t VERSION_NUMBER_BYTE = 0b00010000;
 
     /**
      * This is the default constructor.

src/fsfw/tmtcpacket/pus/tm/TmPacketPusA.cpp

@@ -1,5 +1,6 @@
-#include "fsfw/tmtcpacket/pus/tm/TmPacketPusA.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketBase.h"
+#include "../definitions.h"
+#include "TmPacketPusA.h"
+#include "TmPacketBase.h"
 
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
@@ -62,12 +63,7 @@ void TmPacketPusA::initializeTmPacket(uint16_t apid, uint8_t service,
     //First, set to zero.
     memset(&tmData->data_field, 0, sizeof(tmData->data_field));
 
-    // NOTE: In PUS-C, the PUS Version is 2 and specified for the first 4 bits.
-    // The other 4 bits of the first byte are the spacecraft time reference
-    // status. To change to PUS-C, set 0b00100000.
-    // Set CCSDS_secondary header flag to 0, version number to 001 and ack
-    // to 0000
-    tmData->data_field.version_type_ack = 0b00010000;
+    tmData->data_field.version_type_ack = pus::PusVersion::PUS_A_VERSION << 4;
     tmData->data_field.service_type = service;
     tmData->data_field.service_subtype = subservice;
     tmData->data_field.subcounter = packetSubcounter;

src/fsfw/tmtcpacket/pus/tm/TmPacketPusC.cpp

@@ -1,5 +1,6 @@
-#include "fsfw/tmtcpacket/pus/tm/TmPacketPusC.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketBase.h"
+#include "../definitions.h"
+#include "TmPacketPusC.h"
+#include "TmPacketBase.h"
 
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
@@ -67,7 +68,8 @@ ReturnValue_t TmPacketPusC::initializeTmPacket(uint16_t apid, uint8_t service,
 
     /* Only account for last 4 bytes for time reference field */
     timeRefField &= 0b1111;
-    tmData->dataField.versionTimeReferenceField = VERSION_NUMBER_BYTE | timeRefField;
+    tmData->dataField.versionTimeReferenceField =
+            (pus::PusVersion::PUS_C_VERSION << 4) | timeRefField;
     tmData->dataField.serviceType = service;
     tmData->dataField.serviceSubtype = subservice;
     tmData->dataField.subcounterMsb = packetSubcounter << 8 & 0xff;

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredBase.cpp

@@ -91,4 +91,34 @@ void TmPacketStoredBase::checkAndReportLostTm() {
     }
 }
 
-
+void TmPacketStoredBase::handleStoreFailure(const char *const packetType, ReturnValue_t result,
+        size_t sizeToReserve) {
+    checkAndReportLostTm();
+#if FSFW_VERBOSE_LEVEL >= 1
+    switch(result) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    case(StorageManagerIF::DATA_STORAGE_FULL): {
+        sif::warning << "TmPacketStoredPus" << packetType << ": " <<
+                "Store full for packet with size" << sizeToReserve << std::endl;
+        break;
+    }
+    case(StorageManagerIF::DATA_TOO_LARGE): {
+        sif::warning << "TmPacketStoredPus" << packetType << ": Data with size " <<
+                sizeToReserve << " too large" <<  std::endl;
+        break;
+    }
+#else
+    case(StorageManagerIF::DATA_STORAGE_FULL): {
+        sif::printWarning("TmPacketStoredPus%s: Store full for packet with "
+                "size %d\n", packetType, sizeToReserve);
+        break;
+    }
+    case(StorageManagerIF::DATA_TOO_LARGE): {
+        sif::printWarning("TmPacketStoredPus%s: Data with size "
+                "%d too large\n", packetType, sizeToReserve);
+        break;
+    }
+#endif
+#endif
+    }
+}

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredBase.h

@@ -82,6 +82,9 @@ protected:
     bool checkAndSetStore();
 
     void checkAndReportLostTm();
+
+    void handleStoreFailure(const char* const packetType, ReturnValue_t result,
+            size_t sizeToReserve);
 };
 
 

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredPusA.cpp

@@ -5,69 +5,70 @@
 
 #include <cstring>
 
-TmPacketStoredPusA::TmPacketStoredPusA(store_address_t setAddress) :
-		TmPacketStoredBase(setAddress), TmPacketPusA(nullptr){
+TmPacketStoredPusA::TmPacketStoredPusA(store_address_t setAddress):
+        TmPacketStoredBase(setAddress), TmPacketPusA(nullptr){
 }
 
 TmPacketStoredPusA::TmPacketStoredPusA(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
-		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
+        uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
+        uint32_t size, const uint8_t *headerData, uint32_t headerSize):
 		TmPacketPusA(nullptr) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (not TmPacketStoredBase::checkAndSetStore()) {
-		return;
-	}
-	uint8_t *pData = nullptr;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(getPacketMinimumSize() + size + headerSize), &pData);
+    storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    if (not TmPacketStoredBase::checkAndSetStore()) {
+        return;
+    }
+    uint8_t *pData = nullptr;
+    size_t sizeToReserve = getPacketMinimumSize() + size + headerSize;
+    ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+            sizeToReserve, &pData);
 
-	if (returnValue != store->RETURN_OK) {
-	    TmPacketStoredBase::checkAndReportLostTm();
-		return;
-	}
-	setData(pData);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	memcpy(getSourceData(), headerData, headerSize);
-	memcpy(getSourceData() + headerSize, data, size);
-	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
+    if (returnValue != store->RETURN_OK) {
+        handleStoreFailure("A", returnValue, sizeToReserve);
+        return;
+    }
+    setData(pData);
+    initializeTmPacket(apid, service, subservice, packetSubcounter);
+    memcpy(getSourceData(), headerData, headerSize);
+    memcpy(getSourceData() + headerSize, data, size);
+    setPacketDataLength(size + headerSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
 }
 
 TmPacketStoredPusA::TmPacketStoredPusA(uint16_t apid, uint8_t service,
-		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
-		SerializeIF *header) :
-		TmPacketPusA(nullptr) {
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (not TmPacketStoredBase::checkAndSetStore()) {
-		return;
-	}
-	size_t sourceDataSize = 0;
-	if (content != NULL) {
-		sourceDataSize += content->getSerializedSize();
-	}
-	if (header != NULL) {
-		sourceDataSize += header->getSerializedSize();
-	}
-	uint8_t *p_data = NULL;
-	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-			(getPacketMinimumSize() + sourceDataSize), &p_data);
-	if (returnValue != store->RETURN_OK) {
-	    TmPacketStoredBase::checkAndReportLostTm();
-	}
-	setData(p_data);
-	initializeTmPacket(apid, service, subservice, packetSubcounter);
-	uint8_t *putDataHere = getSourceData();
-	size_t size = 0;
-	if (header != NULL) {
-		header->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	if (content != NULL) {
-		content->serialize(&putDataHere, &size, sourceDataSize,
-				SerializeIF::Endianness::BIG);
-	}
-	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
+        uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
+        SerializeIF *header) :
+		        TmPacketPusA(nullptr) {
+    storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    if (not TmPacketStoredBase::checkAndSetStore()) {
+        return;
+    }
+    size_t sourceDataSize = 0;
+    if (content != nullptr) {
+        sourceDataSize += content->getSerializedSize();
+    }
+    if (header != nullptr) {
+        sourceDataSize += header->getSerializedSize();
+    }
+    uint8_t *pData = nullptr;
+    size_t sizeToReserve = getPacketMinimumSize() + sourceDataSize;
+    ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
+            sizeToReserve, &pData);
+    if (returnValue != store->RETURN_OK) {
+        handleStoreFailure("A", returnValue, sizeToReserve);
+        return;
+    }
+    setData(pData);
+    initializeTmPacket(apid, service, subservice, packetSubcounter);
+    uint8_t *putDataHere = getSourceData();
+    size_t size = 0;
+    if (header != nullptr) {
+        header->serialize(&putDataHere, &size, sourceDataSize,
+                SerializeIF::Endianness::BIG);
+    }
+    if (content != nullptr) {
+        content->serialize(&putDataHere, &size, sourceDataSize,
+                SerializeIF::Endianness::BIG);
+    }
+    setPacketDataLength(sourceDataSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
 }
 
 uint8_t* TmPacketStoredPusA::getAllTmData() {

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredPusA.h

@@ -15,46 +15,46 @@
  *	packets in a store with the help of a storeAddress.
  *	@ingroup tmtcpackets
  */
-class TmPacketStoredPusA :
+class TmPacketStoredPusA:
         public TmPacketStoredBase,
         public TmPacketPusA {
 public:
-	/**
-	 * This is a default constructor which does not set the data pointer.
-	 * However, it does try to set the packet store.
-	 */
-	TmPacketStoredPusA( store_address_t setAddress );
-	/**
-	 * With this constructor, new space is allocated in the packet store and
-	 * a new PUS Telemetry Packet is created there.
-	 * Packet Application Data passed in data is copied into the packet.
-	 * The Application data is passed in two parts, first a header, then a
-	 * data field. This allows building a Telemetry Packet from two separate
-	 * data sources.
-	 * @param apid			Sets the packet's APID field.
-	 * @param service		Sets the packet's Service ID field.
-	 * 		This specifies the source service.
-	 * @param subservice	Sets the packet's Service Subtype field.
-	 * 		This specifies the source sub-service.
-	 * @param packet_counter	Sets the Packet counter field of this packet
-	 * @param data			The payload data to be copied to the
-	 * 						Application Data Field
-	 * @param size			The amount of data to be copied.
-	 * @param headerData 	The header Data of the Application field,
-	 * 						 will be copied in front of data
-	 * @param headerSize	The size of the headerDataF
-	 */
-	TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
-			uint32_t size = 0, const uint8_t* headerData = nullptr,
-			uint32_t headerSize = 0);
-	/**
-	 * Another ctor to directly pass structured content and header data to the
-	 * packet to avoid additional buffers.
-	 */
-	TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
-			uint8_t packet_counter, SerializeIF* content,
-			SerializeIF* header = nullptr);
+    /**
+     * This is a default constructor which does not set the data pointer.
+     * However, it does try to set the packet store.
+     */
+    TmPacketStoredPusA( store_address_t setAddress );
+    /**
+     * With this constructor, new space is allocated in the packet store and
+     * a new PUS Telemetry Packet is created there.
+     * Packet Application Data passed in data is copied into the packet.
+     * The Application data is passed in two parts, first a header, then a
+     * data field. This allows building a Telemetry Packet from two separate
+     * data sources.
+     * @param apid			Sets the packet's APID field.
+     * @param service		Sets the packet's Service ID field.
+     * 		This specifies the source service.
+     * @param subservice	Sets the packet's Service Subtype field.
+     * 		This specifies the source sub-service.
+     * @param packet_counter	Sets the Packet counter field of this packet
+     * @param data			The payload data to be copied to the
+     * 						Application Data Field
+     * @param size			The amount of data to be copied.
+     * @param headerData 	The header Data of the Application field,
+     * 						 will be copied in front of data
+     * @param headerSize	The size of the headerDataF
+     */
+    TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
+            uint8_t packet_counter = 0, const uint8_t* data = nullptr,
+            uint32_t size = 0, const uint8_t* headerData = nullptr,
+            uint32_t headerSize = 0);
+    /**
+     * Another ctor to directly pass structured content and header data to the
+     * packet to avoid additional buffers.
+     */
+    TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
+            uint8_t packet_counter, SerializeIF* content,
+            SerializeIF* header = nullptr);
 
     uint8_t* getAllTmData() override;
     void setDataPointer(const uint8_t* newPointer) override;

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredPusC.cpp

@@ -19,19 +19,19 @@ TmPacketStoredPusC::TmPacketStoredPusC(uint16_t apid, uint8_t service,
         return;
     }
     uint8_t *pData = nullptr;
+    size_t sizeToReserve = getPacketMinimumSize() + size + headerSize;
     ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
-            (getPacketMinimumSize() + size + headerSize), &pData);
+            sizeToReserve, &pData);
 
     if (returnValue != store->RETURN_OK) {
-        TmPacketStoredBase::checkAndReportLostTm();
+        handleStoreFailure("C", returnValue, sizeToReserve);
         return;
     }
     setData(pData);
     initializeTmPacket(apid, service, subservice, packetSubcounter, destinationId, timeRefField);
     memcpy(getSourceData(), headerData, headerSize);
     memcpy(getSourceData() + headerSize, data, size);
-    setPacketDataLength(
-            size + headerSize + sizeof(PUSTmDataFieldHeaderPusC) + CRC_SIZE - 1);
+    setPacketDataLength(size + headerSize + sizeof(PUSTmDataFieldHeaderPusC) + CRC_SIZE - 1);
 }
 
 TmPacketStoredPusC::TmPacketStoredPusC(uint16_t apid, uint8_t service,
@@ -53,34 +53,7 @@ TmPacketStoredPusC::TmPacketStoredPusC(uint16_t apid, uint8_t service,
     size_t sizeToReserve = getPacketMinimumSize() + sourceDataSize;
     ReturnValue_t returnValue = store->getFreeElement(&storeAddress, sizeToReserve, &pData);
     if (returnValue != store->RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
-        switch(returnValue) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        case(StorageManagerIF::DATA_STORAGE_FULL): {
-            sif::warning << "TmPacketStoredPusC::TmPacketStoredPusC: Store full for packet with "
-                    "size " << sizeToReserve << std::endl;
-            break;
-        }
-        case(StorageManagerIF::DATA_TOO_LARGE): {
-            sif::warning << "TmPacketStoredPusC::TmPacketStoredPusC: Data with size " <<
-                    sizeToReserve << " too large" <<  std::endl;
-            break;
-        }
-#else
-        case(StorageManagerIF::DATA_STORAGE_FULL): {
-            sif::printWarning("TmPacketStoredPusC::TmPacketStoredPusC: Store full for packet with "
-                    "size %d\n", sizeToReserve);
-            break;
-        }
-        case(StorageManagerIF::DATA_TOO_LARGE): {
-            sif::printWarning("TmPacketStoredPusC::TmPacketStoredPusC: Data with size "
-                    "%d too large\n", sizeToReserve);
-            break;
-        }
-#endif
-#endif
-        }
-        TmPacketStoredBase::checkAndReportLostTm();
+        handleStoreFailure("C", returnValue, sizeToReserve);
         return;
     }
     setData(pData);

tests/src/fsfw_tests/unit/CMakeLists.txt

@@ -18,4 +18,5 @@ add_subdirectory(serialize)
 add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 add_subdirectory(globalfunctions)
+add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)

tests/src/fsfw_tests/unit/globalfunctions/testDleEncoder.cpp

@@ -103,7 +103,7 @@ TEST_CASE("DleEncoder" , "[DleEncoder]") {
             for(size_t faultyDestSize = 0; faultyDestSize < expectedVec.size(); faultyDestSize ++) {
                 result = dleEncoder.encode(vecToEncode.data(), vecToEncode.size(),
                         buffer.data(), faultyDestSize, &encodedLen);
-                REQUIRE(result == DleEncoder::STREAM_TOO_SHORT);
+                REQUIRE(result == static_cast<int>(DleEncoder::STREAM_TOO_SHORT));
             }
         };
 
@@ -218,5 +218,10 @@ TEST_CASE("DleEncoder" , "[DleEncoder]") {
         REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
 
         dleEncoder.setEscapeMode(true);
+        testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_ESCAPED;
+        testArray1EncodedFaulty[5] = 0;
+        result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                &readLen, buffer.data(), buffer.size(), &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
     }
 }

tests/src/fsfw_tests/unit/timemanager/CMakeLists.txt

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

tests/src/fsfw_tests/unit/timemanager/TestCountdown.cpp

@@ -0,0 +1,27 @@
+#include "fsfw_tests/unit/CatchDefinitions.h"
+#include <fsfw/timemanager/Countdown.h>
+#include <catch2/catch_test_macros.hpp>
+
+
+TEST_CASE( "Countdown Tests", "[TestCountdown]") {
+	INFO("Countdown Tests");
+	Countdown count(20);
+	REQUIRE(count.timeout == 20);
+	REQUIRE(count.setTimeout(100) == static_cast<uint16_t>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(count.timeout == 100);
+	REQUIRE(count.setTimeout(150) == static_cast<uint16_t>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(count.isBusy());
+	REQUIRE(not count.hasTimedOut());
+	uint32_t number = count.getRemainingMillis();
+	REQUIRE(number > 0);
+	bool blocked = false;
+	while(not count.hasTimedOut()){
+		blocked = true;
+	};
+	REQUIRE(blocked);
+	number = count.getRemainingMillis();
+	REQUIRE(number==0);
+	count.resetTimer();
+	REQUIRE(not count.hasTimedOut());
+	REQUIRE(count.isBusy());
+}