Merge remote-tracking branch 'upstream/mueller/data-wrapper' into develop

Reviewed-on: fsfw/fsfw#665

CHANGELOG.md

@@ -12,6 +12,14 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
+- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
+  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
+  types of telemetry.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
+- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
+  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
+  pointer.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
 - Add new `UnsignedByteField` class
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660
 

misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp

@@ -35,7 +35,7 @@ void Factory::produceFsfwObjects(void) {
 }
 
 void Factory::setStaticFrameworkObjectIds() {
-	PusServiceBase::packetSource = objects::NO_OBJECT;
+	PusServiceBase::PUS_DISTRIBUTOR = objects::NO_OBJECT;
 	PusServiceBase::PACKET_DESTINATION = objects::NO_OBJECT;
 
 	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;

src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h

@@ -28,17 +28,11 @@ struct ParamsBase {
 };
 
 struct RegularHkPeriodicParams : public ParamsBase {
-  RegularHkPeriodicParams(sid_t sid, float collectionInterval)
-      : ParamsBase(sid, false, collectionInterval, false) {}
-
   RegularHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
       : ParamsBase(sid, enableReporting, collectionInterval, false) {}
 };
 
 struct DiagnosticsHkPeriodicParams : public ParamsBase {
-  DiagnosticsHkPeriodicParams(sid_t sid, float collectionInterval)
-      : ParamsBase(sid, false, collectionInterval, true) {}
-
   DiagnosticsHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
       : ParamsBase(sid, enableReporting, collectionInterval, true) {}
 };

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1269,30 +1269,40 @@ ReturnValue_t DeviceHandlerBase::letChildHandleMessage(CommandMessage* message)
   return returnvalue::FAILED;
 }
 
-void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t replyId,
+void DeviceHandlerBase::handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
                                        bool forceDirectTm) {
-  if (dataSet == nullptr) {
+  if (dataWrapper.isNull()) {
     return;
   }
 
-  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+  auto iter = deviceReplyMap.find(replyId);
   if (iter == deviceReplyMap.end()) {
     triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
     return;
   }
 
-  /* Regular replies to a command */
+  auto reportData = [&](MessageQueueId_t queueId) {
+    if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
+      return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.serializable);
+    } else if (dataWrapper.type == util::DataTypes::RAW) {
+      return actionHelper.reportData(queueId, replyId, dataWrapper.dataUnion.raw.data,
+                                     dataWrapper.dataUnion.raw.len);
+    }
+    return returnvalue::FAILED;
+  };
+
+  // Regular replies to a command
   if (iter->second.command != deviceCommandMap.end()) {
     MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
 
+    // This may fail, but we'll ignore the fault.
     if (queueId != NO_COMMANDER) {
-      /* This may fail, but we'll ignore the fault. */
-      actionHelper.reportData(queueId, replyId, dataSet);
+      reportData(queueId);
     }
 
-    /* This check should make sure we get any TM but don't get anything doubled. */
+    // This check should make sure we get any TM but don't get anything doubled.
     if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
-      DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
+      DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper);
       actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
     }
 
@@ -1301,22 +1311,16 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t r
       // hiding of sender needed so the service will handle it as
       // unexpected Data, no matter what state (progress or completed)
       // it is in
-      actionHelper.reportData(defaultRawReceiver, replyId, dataSet, true);
+      reportData(defaultRawReceiver);
     }
   }
-  /* Unrequested or aperiodic replies */
+  // Unrequested or aperiodic replies
   else {
-    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataSet);
+    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, dataWrapper);
     if (wiretappingMode == TM) {
       actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
     }
     if (forceDirectTm and defaultRawReceiver != MessageQueueIF::NO_QUEUE) {
-      //		    sid_t setSid = sid_t(this->getObjectId(), replyId);
-      //		    LocalPoolDataSetBase* dataset = getDataSetHandle(setSid);
-      //		    if(dataset != nullptr) {
-      //	            poolManager.generateHousekeepingPacket(setSid, dataset, true);
-      //		    }
-
       // hiding of sender needed so the service will handle it as
       // unexpected Data, no matter what state (progress or completed)
       // it is in

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -23,6 +23,7 @@
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/util/dataWrapper.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -1069,9 +1070,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   bool isAwaitingReply();
 
-  void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, bool forceDirectTm = false);
-  //	void handleDeviceTM(uint8_t* data, size_t dataSize, DeviceCommandId_t replyId,
-  //	        bool forceDirectTm);
+  void handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
+                      bool forceDirectTm = false);
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                          uint32_t *msToReachTheMode);

src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp

@@ -3,10 +3,10 @@
 #include "fsfw/serialize/SerializeAdapter.h"
 
 DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId,
-                                                   SerializeIF* data)
-    : objectId(objectId), actionId(actionId), data(data) {}
+                                                   util::DataWrapper data)
+    : objectId(objectId), actionId(actionId), dataWrapper(data) {}
 
-DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {}
+DeviceTmReportingWrapper::~DeviceTmReportingWrapper() = default;
 
 ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                                   Endianness streamEndianness) const {
@@ -19,22 +19,27 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer, size_t* size
   if (result != returnvalue::OK) {
     return result;
   }
-  return data->serialize(buffer, size, maxSize, streamEndianness);
+  if (dataWrapper.isNull()) {
+    return returnvalue::FAILED;
+  }
+  if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
+    return dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize, streamEndianness);
+  } else if (dataWrapper.type == util::DataTypes::RAW) {
+    if (*size + dataWrapper.dataUnion.raw.len > maxSize) {
+      return SerializeIF::BUFFER_TOO_SHORT;
+    }
+    std::memcpy(*buffer, dataWrapper.dataUnion.raw.data, dataWrapper.dataUnion.raw.len);
+    *buffer += dataWrapper.dataUnion.raw.len;
+    *size += dataWrapper.dataUnion.raw.len;
+  }
+  return returnvalue::OK;
 }
 
 size_t DeviceTmReportingWrapper::getSerializedSize() const {
-  return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
+  return sizeof(objectId) + sizeof(ActionId_t) + dataWrapper.getLength();
 }
 
 ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer, size_t* size,
                                                     Endianness streamEndianness) {
-  ReturnValue_t result = SerializeAdapter::deSerialize(&objectId, buffer, size, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = SerializeAdapter::deSerialize(&actionId, buffer, size, streamEndianness);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return data->deSerialize(buffer, size, streamEndianness);
+  return returnvalue::FAILED;
 }

src/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -1,27 +1,29 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
-#include "../action/HasActionsIF.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../serialize/SerializeIF.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/serialize/SerializeIF.h"
+#include "fsfw/util/dataWrapper.h"
 
 class DeviceTmReportingWrapper : public SerializeIF {
  public:
-  DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, SerializeIF* data);
-  virtual ~DeviceTmReportingWrapper();
+  DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, util::DataWrapper data);
+  ~DeviceTmReportingWrapper() override;
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override;
 
-  virtual size_t getSerializedSize() const override;
-
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) override;
+  [[nodiscard]] size_t getSerializedSize() const override;
 
  private:
   object_id_t objectId;
   ActionId_t actionId;
-  SerializeIF* data;
+  util::DataWrapper dataWrapper;
+
+  // Deserialization forbidden
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override;
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_ */

src/fsfw/health/HasHealthIF.h

@@ -16,12 +16,9 @@ class HasHealthIF {
   };
 
   static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY =
-      returnvalue::makeCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE =
-      returnvalue::makeCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED =
-      returnvalue::makeCode(INTERFACE_ID, 3);
+  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY = returnvalue::makeCode(INTERFACE_ID, 1);
+  static constexpr ReturnValue_t INVALID_HEALTH_STATE = returnvalue::makeCode(INTERFACE_ID, 2);
+  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED = returnvalue::makeCode(INTERFACE_ID, 3);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
   //! P1: New Health, P2: Old Health

src/fsfw/ipc/MessageQueueMessage.cpp

@@ -12,7 +12,7 @@ MessageQueueMessage::MessageQueueMessage() : messageSize(getMinimumMessageSize()
 MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
     : messageSize(MessageQueueMessage::HEADER_SIZE + size) {
   if (size <= MessageQueueMessage::MAX_DATA_SIZE) {
-    std::memcpy(internalBuffer + MessageQueueMessage::HEADER_SIZE, data, size);
+    std::memcpy(MessageQueueMessage::getData(), data, size);
     this->messageSize = MessageQueueMessage::HEADER_SIZE + size;
   } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

src/fsfw/parameters/HasParametersIF.h

@@ -66,7 +66,8 @@ class HasParametersIF {
    * @param newValues
    * @param startAtIndex Linear index, runs left to right, top to bottom for
    * matrix indexes.
-   * @return returnvalue::OK if parameter is valid and a set function of the parameter wrapper was called.
+   * @return returnvalue::OK if parameter is valid and a set function of the parameter wrapper was
+   * called.
    */
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                                      ParameterWrapper *parameterWrapper,

src/fsfw/pus/Service11TelecommandScheduling.h

@@ -38,8 +38,9 @@ class Service11TelecommandScheduling final : public PusServiceBase {
   static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_11;
 
   static constexpr ReturnValue_t INVALID_TYPE_TIME_WINDOW = returnvalue::makeCode(CLASS_ID, 1);
-  static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE = returnvalue::makeCode(CLASS_ID, 2);
-  static constexpr ReturnValue_t INVALID_RELATIVE_TIME = returnvalue::makeCode(CLASS_ID, 3);
+  static constexpr ReturnValue_t INVALID_TIME_WINDOW = returnvalue::makeCode(CLASS_ID, 2);
+  static constexpr ReturnValue_t TIMESHIFTING_NOT_POSSIBLE = returnvalue::makeCode(CLASS_ID, 3);
+  static constexpr ReturnValue_t INVALID_RELATIVE_TIME = returnvalue::makeCode(CLASS_ID, 4);
 
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_11;
 

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -564,6 +564,9 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFr
       if (result != returnvalue::OK) {
         return result;
       }
+      if(fromTimestamp > toTimestamp) {
+        return INVALID_TIME_WINDOW;
+      }
       itBegin = telecommandMap.begin();
       itEnd = telecommandMap.begin();
 
@@ -579,16 +582,6 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFr
     default:
       return returnvalue::FAILED;
   }
-
-  // additional security check, this should never be true
-  if (itBegin->first > itEnd->first) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-#else
-    sif::printError("11::GetMapFilterFromData: itBegin > itEnd\n");
-#endif
-    return returnvalue::FAILED;
-  }
-
   // the map range should now be set according to the sent filter.
   return returnvalue::OK;
 }

src/fsfw/timemanager/CCSDSTime.h

@@ -39,13 +39,13 @@ class CCSDSTime {
    * Struct for CDS day-segmented format.
    */
   struct CDS_short {
-    uint8_t pField;
-    uint8_t dayMSB;
-    uint8_t dayLSB;
-    uint8_t msDay_hh;
-    uint8_t msDay_h;
-    uint8_t msDay_l;
-    uint8_t msDay_ll;
+    uint8_t pField = P_FIELD_CDS_SHORT;
+    uint8_t dayMSB = 0;
+    uint8_t dayLSB = 0;
+    uint8_t msDay_hh = 0;
+    uint8_t msDay_h = 0;
+    uint8_t msDay_l = 0;
+    uint8_t msDay_ll = 0;
   };
   /**
    * Struct for the CCS fromat in day of month variation with max resolution

src/fsfw/tmtcpacket/pus/defs.h

@@ -13,44 +13,6 @@ using PusChecksumT = uint16_t;
 //! Version numbers according to ECSS-E-ST-70-41C p.439
 enum PusVersion : uint8_t { PUS_A = 1, PUS_C = 2 };
 
-struct RawData {
-  const uint8_t* data;
-  size_t len;
-};
-
-enum DataTypes { RAW, SERIALIZABLE };
-
-union DataUnion {
-  RawData raw;
-  SerializeIF* serializable;
-};
-
-struct DataWrapper {
-  DataTypes type;
-  DataUnion dataUnion;
-  using BufPairT = std::pair<const uint8_t*, size_t>;
-
-  [[nodiscard]] size_t getLength() const {
-    if (type == DataTypes::RAW) {
-      return dataUnion.raw.len;
-    } else if (type == DataTypes::SERIALIZABLE and dataUnion.serializable != nullptr) {
-      return dataUnion.serializable->getSerializedSize();
-    }
-    return 0;
-  }
-
-  void setRawData(BufPairT bufPair) {
-    type = DataTypes::RAW;
-    dataUnion.raw.data = bufPair.first;
-    dataUnion.raw.len = bufPair.second;
-  }
-
-  void setSerializable(SerializeIF& serializable) {
-    type = DataTypes::SERIALIZABLE;
-    dataUnion.serializable = &serializable;
-  }
-};
-
 /**
  * This struct defines the data structure of a Space Packet when accessed
  * via a pointer.

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

@@ -37,14 +37,14 @@ ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t max
   if (result != returnvalue::OK) {
     return result;
   }
-  if (pusParams.dataWrapper.type == ecss::DataTypes::RAW) {
+  if (pusParams.dataWrapper.type == util::DataTypes::RAW) {
     const uint8_t *data = pusParams.dataWrapper.dataUnion.raw.data;
     if (data != nullptr and userDataLen > 0) {
       std::memcpy(*buffer, data, userDataLen);
       *buffer += userDataLen;
       *size += userDataLen;
     }
-  } else if (pusParams.dataWrapper.type == ecss::DataTypes::SERIALIZABLE and
+  } else if (pusParams.dataWrapper.type == util::DataTypes::SERIALIZABLE and
              pusParams.dataWrapper.dataUnion.serializable != nullptr) {
     result = pusParams.dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize,
                                                                      streamEndianness);

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

@@ -7,6 +7,7 @@
 #include "fsfw/tmtcpacket/pus/CustomUserDataIF.h"
 #include "fsfw/tmtcpacket/pus/defs.h"
 #include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
+#include "fsfw/util/dataWrapper.h"
 
 struct PusTcParams {
   PusTcParams(uint8_t service_, uint8_t subservice_) : service(service_), subservice(subservice_) {}
@@ -15,7 +16,7 @@ struct PusTcParams {
   uint8_t subservice;
   uint8_t ackFlags = ecss::ACK_ALL;
   uint16_t sourceId = 0;
-  ecss::DataWrapper dataWrapper{};
+  util::DataWrapper dataWrapper{};
   uint8_t pusVersion = ecss::PusVersion::PUS_C;
 };
 

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

@@ -77,12 +77,12 @@ ReturnValue_t PusTmCreator::serialize(uint8_t** buffer, size_t* size, size_t max
     }
   }
 
-  if (pusParams.dataWrapper.type == ecss::DataTypes::RAW and
+  if (pusParams.dataWrapper.type == util::DataTypes::RAW and
       pusParams.dataWrapper.dataUnion.raw.data != nullptr) {
     std::memcpy(*buffer, pusParams.dataWrapper.dataUnion.raw.data, userDataLen);
     *buffer += userDataLen;
     *size += userDataLen;
-  } else if (pusParams.dataWrapper.type == ecss::DataTypes::SERIALIZABLE and
+  } else if (pusParams.dataWrapper.type == util::DataTypes::SERIALIZABLE and
              pusParams.dataWrapper.dataUnion.serializable != nullptr) {
     result = pusParams.dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize,
                                                                      streamEndianness);

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

@@ -4,6 +4,7 @@
 #include "PusTmIF.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketCreator.h"
 #include "fsfw/tmtcpacket/pus/CustomUserDataIF.h"
+#include "fsfw/util/dataWrapper.h"
 
 struct PusTmSecHeader {
   PusTmSecHeader() = default;
@@ -22,19 +23,19 @@ struct PusTmSecHeader {
 struct PusTmParams {
   PusTmParams() = default;
   explicit PusTmParams(PusTmSecHeader secHeader) : secHeader(secHeader){};
-  PusTmParams(PusTmSecHeader secHeader, ecss::DataWrapper dataWrapper)
+  PusTmParams(PusTmSecHeader secHeader, util::DataWrapper dataWrapper)
       : secHeader(secHeader), dataWrapper(dataWrapper) {}
 
   PusTmParams(uint8_t service, uint8_t subservice, TimeStamperIF* timeStamper)
       : secHeader(service, subservice, timeStamper) {}
 
   PusTmParams(uint8_t service, uint8_t subservice, TimeStamperIF* timeStamper,
-              ecss::DataWrapper dataWrapper_)
+              util::DataWrapper dataWrapper_)
       : PusTmParams(service, subservice, timeStamper) {
     dataWrapper = dataWrapper_;
   }
   PusTmSecHeader secHeader;
-  ecss::DataWrapper dataWrapper{};
+  util::DataWrapper dataWrapper{};
 };
 
 class TimeStamperIF;

src/fsfw/tmtcservices/SourceSequenceCounter.h

@@ -9,16 +9,10 @@ class SourceSequenceCounter {
 
  public:
   SourceSequenceCounter(uint16_t initialSequenceCount = 0) : sequenceCount(initialSequenceCount) {}
-  void increment() {
-    sequenceCount = (sequenceCount + 1) % (ccsds::LIMIT_SEQUENCE_COUNT);
-  }
-  void decrement() {
-    sequenceCount = (sequenceCount - 1) % (ccsds::LIMIT_SEQUENCE_COUNT);
-  }
+  void increment() { sequenceCount = (sequenceCount + 1) % (ccsds::LIMIT_SEQUENCE_COUNT); }
+  void decrement() { sequenceCount = (sequenceCount - 1) % (ccsds::LIMIT_SEQUENCE_COUNT); }
   uint16_t get() { return this->sequenceCount; }
-  void reset(uint16_t toValue = 0) {
-    sequenceCount = toValue % (ccsds::LIMIT_SEQUENCE_COUNT);
-  }
+  void reset(uint16_t toValue = 0) { sequenceCount = toValue % (ccsds::LIMIT_SEQUENCE_COUNT); }
   SourceSequenceCounter& operator++(int) {
     this->increment();
     return *this;

src/fsfw/tmtcservices/VerificationCodes.h

@@ -5,7 +5,7 @@
 
 namespace tcverif {
 
-enum VerifFlags : uint8_t {
+enum VerificationFlags : uint8_t {
   NONE = 0b0000,
   ACCEPTANCE = 0b0001,
   START = 0b0010,

src/fsfw/tmtcservices/tmHelpers.h

@@ -11,13 +11,13 @@ class DataWithObjectIdPrefix : public SerializeIF {
  public:
   DataWithObjectIdPrefix(object_id_t objectId, const uint8_t* srcData, size_t srcDataLen)
       : objectId(objectId) {
-    dataWrapper.type = ecss::DataTypes::RAW;
+    dataWrapper.type = util::DataTypes::RAW;
     dataWrapper.dataUnion.raw.data = srcData;
     dataWrapper.dataUnion.raw.len = srcDataLen;
   }
 
   DataWithObjectIdPrefix(object_id_t objectId, SerializeIF& serializable) : objectId(objectId) {
-    dataWrapper.type = ecss::DataTypes::SERIALIZABLE;
+    dataWrapper.type = util::DataTypes::SERIALIZABLE;
     dataWrapper.dataUnion.serializable = &serializable;
   }
 
@@ -26,11 +26,11 @@ class DataWithObjectIdPrefix : public SerializeIF {
     if (*size + getSerializedSize() > maxSize) {
       return SerializeIF::BUFFER_TOO_SHORT;
     }
-    if (dataWrapper.type != ecss::DataTypes::RAW) {
+    if (dataWrapper.type != util::DataTypes::RAW) {
       if ((dataWrapper.dataUnion.raw.data == nullptr) and (dataWrapper.dataUnion.raw.len > 0)) {
         return returnvalue::FAILED;
       }
-    } else if (dataWrapper.type == ecss::DataTypes::SERIALIZABLE) {
+    } else if (dataWrapper.type == util::DataTypes::SERIALIZABLE) {
       if (dataWrapper.dataUnion.serializable == nullptr) {
         return returnvalue::FAILED;
       }
@@ -40,7 +40,7 @@ class DataWithObjectIdPrefix : public SerializeIF {
     if (result != returnvalue::OK) {
       return result;
     }
-    if (dataWrapper.type != ecss::DataTypes::RAW) {
+    if (dataWrapper.type != util::DataTypes::RAW) {
       std::memcpy(*buffer, dataWrapper.dataUnion.raw.data, dataWrapper.dataUnion.raw.len);
       *buffer += dataWrapper.dataUnion.raw.len;
       *size += dataWrapper.dataUnion.raw.len;
@@ -63,7 +63,7 @@ class DataWithObjectIdPrefix : public SerializeIF {
 
  private:
   object_id_t objectId;
-  ecss::DataWrapper dataWrapper{};
+  util::DataWrapper dataWrapper{};
 };
 
 }  // namespace telemetry

src/fsfw/util/dataWrapper.h

@@ -0,0 +1,77 @@
+#ifndef FSFW_UTIL_DATAWRAPPER_H
+#define FSFW_UTIL_DATAWRAPPER_H
+
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+#include "fsfw/serialize.h"
+
+namespace util {
+
+using BufPair = std::pair<const uint8_t*, size_t>;
+
+struct RawData {
+  RawData() = default;
+  const uint8_t* data = nullptr;
+  size_t len = 0;
+};
+
+enum DataTypes { NONE, RAW, SERIALIZABLE };
+
+union DataUnion {
+  RawData raw{};
+  SerializeIF* serializable;
+};
+
+struct DataWrapper {
+
+  DataWrapper() = default;
+
+  DataWrapper(const uint8_t* data, size_t size): type(DataTypes::RAW) {
+    setRawData({data, size});
+  }
+
+  explicit DataWrapper(BufPair raw): type(DataTypes::RAW) {
+    setRawData(raw);
+  }
+
+  explicit DataWrapper(SerializeIF& serializable): type(DataTypes::SERIALIZABLE) {
+    setSerializable(serializable);
+  }
+
+  DataTypes type = DataTypes::NONE;
+  DataUnion dataUnion;
+
+  [[nodiscard]] size_t getLength() const {
+    if (type == DataTypes::RAW) {
+      return dataUnion.raw.len;
+    } else if (type == DataTypes::SERIALIZABLE and dataUnion.serializable != nullptr) {
+      return dataUnion.serializable->getSerializedSize();
+    }
+    return 0;
+  }
+
+  [[nodiscard]] bool isNull() const {
+    if ((type == DataTypes::NONE) or (type == DataTypes::RAW and dataUnion.raw.data == nullptr) or
+        (type == DataTypes::SERIALIZABLE and dataUnion.serializable == nullptr)) {
+      return true;
+    }
+    return false;
+  }
+
+  void setRawData(BufPair bufPair) {
+    type = DataTypes::RAW;
+    dataUnion.raw.data = bufPair.first;
+    dataUnion.raw.len = bufPair.second;
+  }
+
+  void setSerializable(SerializeIF& serializable) {
+    type = DataTypes::SERIALIZABLE;
+    dataUnion.serializable = &serializable;
+  }
+};
+
+}  // namespace util
+
+#endif  // FSFW_UTIL_DATAWRAPPER_H

unittests/tmtcservices/testStoreAndSendHelper.cpp

@@ -44,7 +44,7 @@ TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
     REQUIRE(creator.getSubService() == 2);
     REQUIRE(creator.getService() == 17);
     auto& params = creator.getParams();
-    REQUIRE(params.dataWrapper.type == ecss::DataTypes::RAW);
+    REQUIRE(params.dataWrapper.type == util::DataTypes::RAW);
     REQUIRE(params.dataWrapper.dataUnion.raw.data == nullptr);
     REQUIRE(params.dataWrapper.dataUnion.raw.len == 0);
     REQUIRE(tmHelper.sendCounter == 0);
@@ -65,7 +65,7 @@ TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
     REQUIRE(tmHelper.prepareTmPacket(2, data.data(), data.size()) == returnvalue::OK);
     auto& creator = storeHelper.getCreatorRef();
     auto& params = creator.getParams();
-    REQUIRE(params.dataWrapper.type == ecss::DataTypes::RAW);
+    REQUIRE(params.dataWrapper.type == util::DataTypes::RAW);
     REQUIRE(params.dataWrapper.dataUnion.raw.data == data.data());
     REQUIRE(params.dataWrapper.dataUnion.raw.len == data.size());
   }
@@ -75,7 +75,7 @@ TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
     REQUIRE(tmHelper.prepareTmPacket(2, simpleSer) == returnvalue::OK);
     auto& creator = storeHelper.getCreatorRef();
     auto& params = creator.getParams();
-    REQUIRE(params.dataWrapper.type == ecss::DataTypes::SERIALIZABLE);
+    REQUIRE(params.dataWrapper.type == util::DataTypes::SERIALIZABLE);
     REQUIRE(params.dataWrapper.dataUnion.serializable == &simpleSer);
   }
 
@@ -86,7 +86,7 @@ TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
     REQUIRE(tmHelper.prepareTmPacket(2, dataWithObjId) == returnvalue::OK);
     auto& creator = storeHelper.getCreatorRef();
     auto& params = creator.getParams();
-    REQUIRE(params.dataWrapper.type == ecss::DataTypes::SERIALIZABLE);
+    REQUIRE(params.dataWrapper.type == util::DataTypes::SERIALIZABLE);
     REQUIRE(params.dataWrapper.dataUnion.serializable == &dataWithObjId);
   }
 

unittests/util/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(${FSFW_TEST_TGT} PRIVATE
   testUnsignedByteField.cpp
+  testDataWrapper.cpp
 )

unittests/util/testDataWrapper.cpp

@@ -0,0 +1,59 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/util/dataWrapper.h"
+#include "mocks/SimpleSerializable.h"
+
+TEST_CASE("Data Wrapper", "[util]") {
+  util::DataWrapper wrapper;
+  SECTION("State") {
+    REQUIRE(wrapper.isNull());
+    REQUIRE(wrapper.type == util::DataTypes::NONE);
+  }
+
+  SECTION("Set Raw Data") {
+    util::DataWrapper* instance = &wrapper;
+    bool deleteInst = false;
+    REQUIRE(wrapper.isNull());
+    std::array<uint8_t, 4> data = {1, 2, 3, 4};
+    SECTION("Setter") {
+      wrapper.setRawData({data.data(), data.size()});
+    }
+    SECTION("Direct Construction Pair") {
+      instance = new util::DataWrapper(util::BufPair(data.data(), data.size()));
+      deleteInst = true;
+    }
+    SECTION("Direct Construction Single Args") {
+      instance = new util::DataWrapper(data.data(), data.size());
+      deleteInst = true;
+    }
+    REQUIRE(not instance->isNull());
+    REQUIRE(instance->type == util::DataTypes::RAW);
+    REQUIRE(instance->dataUnion.raw.data == data.data());
+    REQUIRE(instance->dataUnion.raw.len == data.size());
+    if(deleteInst) {
+      delete instance;
+    }
+  }
+
+  SECTION("Simple Serializable") {
+    util::DataWrapper* instance = &wrapper;
+    bool deleteInst = false;
+    REQUIRE(instance->isNull());
+    SimpleSerializable serializable;
+    SECTION("Setter") {
+      wrapper.setSerializable(serializable);
+    }
+    SECTION("Direct Construction") {
+      instance = new util::DataWrapper(serializable);
+      deleteInst = true;
+    }
+
+    REQUIRE(not instance->isNull());
+    REQUIRE(instance->type == util::DataTypes::SERIALIZABLE);
+    REQUIRE(instance->dataUnion.serializable == &serializable);
+    if(deleteInst) {
+      delete instance;
+    }
+  }
+}

unittests/util/testUnsignedByteField.cpp

@@ -4,7 +4,7 @@
 
 #include "fsfw/util/UnsignedByteField.h"
 
-TEST_CASE("Unsigned Byte Field", "[unsigned-byte-field]") {
+TEST_CASE("Unsigned Byte Field", "[util]") {
   auto testByteField = UnsignedByteField<uint32_t>(10);
   auto u32ByteField = U32ByteField(10);
   auto u16ByteField = U16ByteField(5);