added sequence count provider abstraction

src/fsfw/CMakeLists.txt

@@ -32,6 +32,7 @@ add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)
 add_subdirectory(tmtcservices)
 add_subdirectory(filesystem)
+add_subdirectory(util)
 
 # Optional
 

src/fsfw/cfdp/VarLenFields.cpp

@@ -3,8 +3,8 @@
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serviceinterface.h"
 
-cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, size_t value) : VarLenField() {
-  ReturnValue_t result = this->setValue(width, value);
+cfdp::VarLenField::VarLenField(cfdp::WidthInBytes width, uint64_t value) : VarLenField() {
+  ReturnValue_t result = this->setValueAndWidth(width, value);
   if (result != returnvalue::OK) {
 #if FSFW_DISABLE_PRINTOUT == 0
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -20,8 +20,8 @@ cfdp::VarLenField::VarLenField() : width(cfdp::WidthInBytes::ONE_BYTE) { value.o
 
 cfdp::WidthInBytes cfdp::VarLenField::getWidth() const { return width; }
 
-ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_t value_) {
-  switch (widthInBytes) {
+ReturnValue_t cfdp::VarLenField::setValueAndWidth(cfdp::WidthInBytes width_, uint64_t value_) {
+  switch (width_) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       if (value_ > UINT8_MAX) {
         return returnvalue::FAILED;
@@ -43,15 +43,18 @@ ReturnValue_t cfdp::VarLenField::setValue(cfdp::WidthInBytes widthInBytes, size_
       this->value.fourBytes = value_;
       break;
     }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      this->value.eightBytes = value_;
+    }
     default: {
       break;
     }
   }
-  this->width = widthInBytes;
+  this->width = width_;
   return returnvalue::OK;
 }
 
-size_t cfdp::VarLenField::getValue() const {
+uint64_t cfdp::VarLenField::getValue() const {
   switch (width) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       return value.oneByte;
@@ -62,6 +65,9 @@ size_t cfdp::VarLenField::getValue() const {
     case (cfdp::WidthInBytes::FOUR_BYTES): {
       return value.fourBytes;
     }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return value.eightBytes;
+    }
   }
   return 0;
 }
@@ -84,6 +90,10 @@ ReturnValue_t cfdp::VarLenField::serialize(uint8_t **buffer, size_t *size, size_
     case (cfdp::WidthInBytes::FOUR_BYTES): {
       return SerializeAdapter::serialize(&value.fourBytes, buffer, size, maxSize, streamEndianness);
     }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return SerializeAdapter::serialize(&value.eightBytes, buffer, size, maxSize,
+                                         streamEndianness);
+    }
     default: {
       return returnvalue::FAILED;
     }
@@ -98,6 +108,10 @@ ReturnValue_t cfdp::VarLenField::deSerialize(cfdp::WidthInBytes width_, const ui
   return deSerialize(buffer, size, streamEndianness);
 }
 
+ReturnValue_t cfdp::VarLenField::setValue(uint64_t value_) {
+  return setValueAndWidth(getWidth(), value_);
+}
+
 ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *size,
                                              Endianness streamEndianness) {
   switch (width) {
@@ -112,6 +126,9 @@ ReturnValue_t cfdp::VarLenField::deSerialize(const uint8_t **buffer, size_t *siz
     case (cfdp::WidthInBytes::FOUR_BYTES): {
       return SerializeAdapter::deSerialize(&value.fourBytes, buffer, size, streamEndianness);
     }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      return SerializeAdapter::deSerialize(&value.eightBytes, buffer, size, streamEndianness);
+    }
     default: {
       return returnvalue::FAILED;
     }

src/fsfw/cfdp/VarLenFields.h

@@ -31,7 +31,8 @@ class VarLenField : public SerializeIF {
   bool operator!=(const VarLenField &other) const;
   bool operator<(const VarLenField &other) const;
 
-  ReturnValue_t setValue(cfdp::WidthInBytes, size_t value);
+  ReturnValue_t setValueAndWidth(cfdp::WidthInBytes width, uint64_t value);
+  ReturnValue_t setValue(uint64_t value);
 
   ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                           Endianness streamEndianness) const override;
@@ -64,7 +65,7 @@ template <typename T>
 cfdp::VarLenField::VarLenField(UnsignedByteField<T> byteField)
     : width(static_cast<cfdp::WidthInBytes>(sizeof(T))) {
   static_assert((sizeof(T) % 2) == 0);
-  setValue(width, byteField.getValue());
+  setValueAndWidth(width, byteField.getValue());
 }
 
 struct EntityId : public VarLenField {

src/fsfw/cfdp/definitions.h

@@ -68,6 +68,7 @@ enum WidthInBytes : uint8_t {
   ONE_BYTE = 1,
   TWO_BYTES = 2,
   FOUR_BYTES = 4,
+  EIGHT_BYTES = 8
 };
 
 enum FileDirective : uint8_t {

src/fsfw/cfdp/handler/SourceHandler.cpp

@@ -9,12 +9,31 @@
 #include "fsfw/cfdp/pdu/MetadataPduCreator.h"
 #include "fsfw/filesystem/HasFileSystemIF.h"
 #include "fsfw/objectmanager.h"
+#include "fsfw/serviceinterface.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 
 using namespace returnvalue;
 
 cfdp::SourceHandler::SourceHandler(SourceHandlerParams params, FsfwParams fsfwParams)
-    : sourceParams(std::move(params)), fsfwParams(fsfwParams) {}
+    : sourceParams(std::move(params)), fsfwParams(fsfwParams) {
+  // The entity ID portion of the transaction ID will always remain fixed.
+  transactionParams.id.entityId = sourceParams.cfg.localId;
+  if (sourceParams.seqCountProvider.bitWidth() == 8) {
+    transactionParams.seqCountWidth = cfdp::WidthInBytes::ONE_BYTE;
+  } else if (sourceParams.seqCountProvider.bitWidth() == 16) {
+    transactionParams.seqCountWidth = cfdp::WidthInBytes::TWO_BYTES;
+  } else if (sourceParams.seqCountProvider.bitWidth() == 32) {
+    transactionParams.seqCountWidth = cfdp::WidthInBytes::FOUR_BYTES;
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "cfdp::SourceHandler: Seq count provider bit width "
+               << sourceParams.seqCountProvider.bitWidth() << " not allowed" << std::endl;
+#else
+#endif
+    // Yeah, what am I supposed to do here? Can't throw an exception in the FSFW..
+    transactionParams.seqCountWidth = cfdp::WidthInBytes::ONE_BYTE;
+  }
+}
 
 cfdp::SourceHandler::FsmResult& cfdp::SourceHandler::fsmNacked() {
   ReturnValue_t result;
@@ -22,6 +41,7 @@ cfdp::SourceHandler::FsmResult& cfdp::SourceHandler::fsmNacked() {
     step = TransactionStep::TRANSACTION_START;
   }
   if (step == TransactionStep::TRANSACTION_START) {
+    sourceParams.user.transactionIndication(transactionParams.id);
     step = TransactionStep::CRC_PROCEDURE;
   }
   if (step == TransactionStep::CRC_PROCEDURE) {
@@ -135,6 +155,7 @@ ReturnValue_t cfdp::SourceHandler::putRequest(PutRequestFull& putRequest, Remote
   // Only used for PDU forwarding, file is sent to file receiver regularly here.
   transactionParams.pduConf.direction = Direction::TOWARDS_RECEIVER;
   transactionParams.pduConf.sourceId = sourceParams.cfg.localId;
+  transactionParams.id.seqNum.setValue(sourceParams.seqCountProvider.getAndIncrement());
 
   if (transactionParams.pduConf.mode == TransmissionMode::ACKNOWLEDGED) {
     state = cfdp::CfdpState::BUSY_CLASS_2_ACKED;

src/fsfw/cfdp/handler/SourceHandler.h

@@ -11,15 +11,17 @@
 #include "fsfw/events/EventReportingProxyIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+#include "fsfw/util/ProvidesSeqCountIF.h"
 
 namespace cfdp {
 
 struct SourceHandlerParams {
-  SourceHandlerParams(LocalEntityCfg cfg, UserBase& user) : cfg(std::move(cfg)), user(user) {}
+  SourceHandlerParams(LocalEntityCfg cfg, UserBase& user, ProvidesSeqCountIF& seqCountProvider)
+      : cfg(std::move(cfg)), user(user), seqCountProvider(seqCountProvider) {}
 
   LocalEntityCfg cfg;
   UserBase& user;
-  size_t maxFilePathSize = 256;
+  ProvidesSeqCountIF& seqCountProvider;
 };
 
 class SourceHandler {
@@ -69,6 +71,9 @@ class SourceHandler {
     bool closureRequested = false;
     RemoteEntityCfg remoteCfg;
     PduConfig pduConf;
+    cfdp::TransactionId id{};
+    cfdp::WidthInBytes seqCountWidth;
+    uint32_t seqNum = 0;
   } transactionParams;
   cfdp::CfdpState state = cfdp::CfdpState::IDLE;
   TransactionStep step = TransactionStep::IDLE;

src/fsfw/cfdp/pdu/HeaderReader.cpp

@@ -103,11 +103,11 @@ void PduHeaderReader::getTransactionSeqNum(cfdp::TransactionSeqNum &seqNum) cons
 }
 
 void PduHeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInBytes width,
-                                        void *sourcePtr) const {
+                                        void *sourcePtr) {
   switch (width) {
     case (cfdp::WidthInBytes::ONE_BYTE): {
       auto *fieldTyped = static_cast<uint8_t *>(sourcePtr);
-      field->setValue(width, *fieldTyped);
+      field->setValueAndWidth(width, *fieldTyped);
       break;
     }
     case (cfdp::WidthInBytes::TWO_BYTES): {
@@ -115,7 +115,7 @@ void PduHeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInB
       size_t deserSize = 0;
       SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
                                     SerializeIF::Endianness::NETWORK);
-      field->setValue(width, fieldTyped);
+      field->setValueAndWidth(width, fieldTyped);
       break;
     }
     case (cfdp::WidthInBytes::FOUR_BYTES): {
@@ -123,7 +123,15 @@ void PduHeaderReader::assignVarLenField(cfdp::VarLenField *field, cfdp::WidthInB
       size_t deserSize = 0;
       SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
                                     SerializeIF::Endianness::NETWORK);
-      field->setValue(width, fieldTyped);
+      field->setValueAndWidth(width, fieldTyped);
+      break;
+    }
+    case (cfdp::WidthInBytes::EIGHT_BYTES): {
+      uint64_t fieldTyped = 0;
+      size_t deserSize = 0;
+      SerializeAdapter::deSerialize(&fieldTyped, static_cast<uint8_t *>(sourcePtr), &deserSize,
+                                    SerializeIF::Endianness::NETWORK);
+      field->setValueAndWidth(width, fieldTyped);
       break;
     }
   }

src/fsfw/cfdp/pdu/PduHeaderReader.h

@@ -105,7 +105,8 @@ class PduHeaderReader : public RedirectableDataPointerIF, public PduHeaderIF {
    * @return
    */
   ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args) override;
-  void assignVarLenField(cfdp::VarLenField* field, cfdp::WidthInBytes width, void* sourcePtr) const;
+  static void assignVarLenField(cfdp::VarLenField* field, cfdp::WidthInBytes width,
+                                void* sourcePtr);
   void* sourceIdRaw = nullptr;
   void* seqNumRaw = nullptr;
   void* destIdRaw = nullptr;

src/fsfw/util/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE)

src/fsfw/util/ProvidesSeqCountIF.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+
+class ProvidesSeqCountIF {
+ public:
+  virtual ~ProvidesSeqCountIF() = default;
+
+  [[nodiscard]] virtual unsigned int bitWidth() const = 0;
+
+  virtual uint64_t get() = 0;
+  virtual void increment() = 0;
+
+  virtual uint64_t getAndIncrement() {
+    uint64_t val = get();
+    increment();
+    return val;
+  }
+};

src/fsfw/util/SeqCountProvider.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <type_traits>
+
+#include "ProvidesSeqCountIF.h"
+
+template <typename T>
+class SeqCountProvider : public ProvidesSeqCountIF {
+  static_assert(std::is_same<T, uint8_t>::value || std::is_same<T, uint16_t>::value ||
+                    std::is_same<T, uint32_t>::value,
+                "Only uint8_t, uint16_t, and uint32_t are allowed.");
+
+ public:
+  [[nodiscard]] unsigned int bitWidth() const override { return sizeof(T) * 8; }
+  uint64_t get() override { return counter; }
+  void increment() override { counter++; }
+
+ private:
+  T counter{};
+};
+
+using SeqCountProviderU8 = SeqCountProvider<uint8_t>;
+using SeqCountProviderU16 = SeqCountProvider<uint16_t>;
+using SeqCountProviderU32 = SeqCountProvider<uint32_t>;