this api works as well

Reviewed-on: #113

src/fsfw/cfdp/handler/DestHandler.cpp

@@ -425,21 +425,31 @@ ReturnValue_t cfdp::DestHandler::sendFinishedPdu() {
   store_address_t storeId;
   uint8_t* dataPtr = nullptr;
   ReturnValue_t result =
-      fp.tcStore->getFreeElement(&storeId, finishedPdu.getSerializedSize(), &dataPtr);
+      fp.tmStore->getFreeElement(&storeId, finishedPdu.getSerializedSize(), &dataPtr);
   if (result != OK) {
-    // TODO: Error handling and event, this is a non CFDP specific error (most likely store is full)
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler:sendFinishedPdu: Getting store slot failed" << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::STORE_ERROR, result, 0);
     return result;
   }
   size_t serLen = 0;
   result = finishedPdu.serialize(dataPtr, serLen, finishedPdu.getSerializedSize());
   if (result != OK) {
-    // TODO: Error printout, this really should not happen
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler::sendFinishedPdu: Serializing Finished PDU failed"
+                 << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::SERIALIZATION_ERROR, result, 0);
     return result;
   }
   TmTcMessage msg(storeId);
   result = fp.msgQueue->sendMessage(fp.packetDest.getReportReceptionQueue(), &msg);
   if (result != OK) {
-    // TODO: Error handling and event, this is a non CFDP specific error (most likely store is full)
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "cfdp::DestHandler::sendFinishedPdu: Sending PDU failed" << std::endl;
+#endif
+    fp.eventReporter->forwardEvent(events::MSG_QUEUE_ERROR, result, 0);
     return result;
   }
   fsmRes.packetsSent++;

src/fsfw/cfdp/handler/defs.h

@@ -5,5 +5,15 @@ namespace cfdp {
 
 enum class CfdpStates { IDLE, BUSY_CLASS_1_NACKED, BUSY_CLASS_2_ACKED, SUSPENDED };
 
-}
+static constexpr uint8_t SSID = SUBSYSTEM_ID::CFDP;
+
+namespace events {
+
+static constexpr Event STORE_ERROR = event::makeEvent(SSID, 0, severity::LOW);
+static constexpr Event MSG_QUEUE_ERROR = event::makeEvent(SSID, 1, severity::LOW);
+static constexpr Event SERIALIZATION_ERROR = event::makeEvent(SSID, 2, severity::LOW);
+
+}  // namespace events
+
+}  // namespace cfdp
 #endif  // FSFW_CFDP_HANDLER_DEFS_H

src/fsfw/cfdp/pdu/FinishedPduCreator.cpp

@@ -17,7 +17,7 @@ ReturnValue_t FinishPduCreator::serialize(uint8_t **buffer, size_t *size, size_t
   if (result != returnvalue::OK) {
     return result;
   }
-  if (*size + 1 >= maxSize) {
+  if (*size + 1 > maxSize) {
     return SerializeIF::BUFFER_TOO_SHORT;
   }
   **buffer = finishInfo.getConditionCode() << 4 | finishInfo.getDeliveryCode() << 2 |

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -467,7 +467,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
   info.expectedReplies = 0;
   info.isExecuting = false;
   info.sendReplyTo = NO_COMMANDER;
-  info.useAlternativeReplyId = alternativeReplyId;
+  info.useAlternativeReplyId = useAlternativeReply;
   info.alternativeReplyId = alternativeReplyId;
   auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
   if (resultPair.second) {
@@ -1601,3 +1601,14 @@ void DeviceHandlerBase::disableCommandsAndReplies() {
     }
   }
 }
+
+ReturnValue_t DeviceHandlerBase::finishAction(bool success, DeviceCommandId_t action,
+		ReturnValue_t result) {
+	  auto commandIter = deviceCommandMap.find(action);
+	  if (commandIter == deviceCommandMap.end()) {
+	    return MessageQueueIF::NO_QUEUE;
+	  }
+	  commandIter->second.isExecuting = false;
+	  actionHelper.finish(success, commandIter->second.sendReplyTo, action, result);
+	  return returnvalue::OK;
+}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -399,6 +399,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) = 0;
   MessageQueueId_t getCommanderQueueId(DeviceCommandId_t replyId) const;
+  ReturnValue_t finishAction(bool success, DeviceCommandId_t action, ReturnValue_t result);
+
   /**
    * Helper function to get pending command. This is useful for devices
    * like SPI sensors to identify the last sent command.
@@ -1138,6 +1140,22 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual ReturnValue_t doSendReadHook();
 
+  /**
+   * Send a RMAP getRead command.
+   *
+   * The size of the getRead command is #maxDeviceReplyLen.
+   * This is always executed, independently from the current mode.
+   */
+  virtual void doSendRead(void);
+  /**
+   * Check the getRead reply and the contained data.
+   *
+   * If data was received scanForReply() and, if successful, handleReply()
+   * are called. If the current mode is @c MODE_RAW, the received packet
+   * is sent to the commanding object via commandQueue.
+   */
+  virtual void doGetRead();
+
  private:
   /**
    * State a cookie is in.
@@ -1273,21 +1291,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * - if the action was successful, the reply timout counter is initialized
    */
   void doGetWrite(void);
-  /**
-   * Send a RMAP getRead command.
-   *
-   * The size of the getRead command is #maxDeviceReplyLen.
-   * This is always executed, independently from the current mode.
-   */
-  void doSendRead(void);
-  /**
-   * Check the getRead reply and the contained data.
-   *
-   * If data was received scanForReply() and, if successful, handleReply()
-   * are called. If the current mode is @c MODE_RAW, the received packet
-   * is sent to the commanding object via commandQueue.
-   */
-  void doGetRead(void);
 
   /**
    * @brief Resets replies which use a timeout to detect missed replies.

src/fsfw/events/fwSubsystemIdRanges.h

@@ -33,6 +33,7 @@ enum : uint8_t {
   PUS_SERVICE_23 = 103,
   MGM_LIS3MDL = 106,
   MGM_RM3100 = 107,
+  CFDP = 108,
 
   FW_SUBSYSTEM_ID_RANGE
 };

src/fsfw/filesystem/HasFileSystemIF.h

@@ -40,6 +40,7 @@ class HasFileSystemIF {
   //! [EXPORT] : P1: Can be file system specific error code
   static constexpr ReturnValue_t GENERIC_FILE_ERROR = MAKE_RETURN_CODE(0);
   static constexpr ReturnValue_t GENERIC_DIR_ERROR = MAKE_RETURN_CODE(1);
+  static constexpr ReturnValue_t FILESYSTEM_INACTIVE = MAKE_RETURN_CODE(2);
   static constexpr ReturnValue_t GENERIC_RENAME_ERROR = MAKE_RETURN_CODE(3);
 
   //! [EXPORT] : File system is currently busy

src/fsfw/globalfunctions/DleParser.cpp

@@ -3,159 +3,95 @@
 #include <fsfw/serviceinterface/ServiceInterface.h>
 
 #include <cstdio>
+#include <fstream>
+#include <iostream>
 
 DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-                     BufPair decodedBuf, UserHandler handler, void* args)
+                     BufPair decodedBuf)
     : decodeRingBuf(decodeRingBuf),
       decoder(decoder),
       encodedBuf(encodedBuf),
-      decodedBuf(decodedBuf),
-      handler(handler),
-      ctx(args) {
-  if (handler == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
-#else
-    sif::printError("DleParser::DleParser: Invalid user handler\n");
-#endif
-  }
+      decodedBuf(decodedBuf) {
 }
 
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
-  if (data == nullptr or len == 0 or handler == nullptr) {
+ReturnValue_t DleParser::passData(const uint8_t* data, size_t len) {
+  if (data == nullptr or len == 0) {
     return returnvalue::FAILED;
   }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = returnvalue::OK;
-  bool startFoundInThisPacket = false;
-  for (size_t idx = 0; idx < len; idx++) {
-    if (data[idx] == DleEncoder::STX_CHAR) {
-      if (not startFound and not startFoundInThisPacket) {
-        startIdx = idx;
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
+  return decodeRingBuf.writeData(data, len);
+}
+
+ReturnValue_t DleParser::parseRingBuf(size_t& readSize) {
+  ctx.setType(DleParser::ContextType::NONE);
+  size_t availableData = decodeRingBuf.getAvailableReadData();
+  if(availableData == 0) {
+    return NO_PACKET_FOUND;
+  }
+  if (availableData > encodedBuf.second) {
+    ErrorInfo info;
+    info.len = decodeRingBuf.getAvailableReadData();
+    setErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = decodeRingBuf.readData(encodedBuf.first, availableData);
+  if (result != returnvalue::OK) {
+    ErrorInfo info;
+    info.res = result;
+    setErrorContext(ErrorTypes::RING_BUF_ERROR, info);
+    return result;
+  }
+  bool stxFound = false;
+  size_t stxIdx = 0;
+  for (size_t vectorIdx = 0; vectorIdx < availableData; vectorIdx++) {
+    // handle STX char
+    if (encodedBuf.first[vectorIdx] == DleEncoder::STX_CHAR) {
+      if (not stxFound) {
+        stxFound = true;
+        stxIdx = vectorIdx;
       } else {
-        // Maybe print warning, should not happen
-        decodeRingBuf.clear();
+        // might be lost packet, so we should advance the read pointer
+        // without skipping the STX
+        readSize = vectorIdx;
         ErrorInfo info;
-        info.len = idx;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
-        handler(ctx);
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
+        setErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
+        return POSSIBLE_PACKET_LOSS;
       }
-      startFound = true;
-      startFoundInThisPacket = true;
-    } else if (data[idx] == DleEncoder::ETX_CHAR) {
-      if (startFoundInThisPacket) {
-        size_t readLen = 0;
+    }
+    // handle ETX char
+    if (encodedBuf.first[vectorIdx] == DleEncoder::ETX_CHAR) {
+      if (stxFound) {
+        // This is propably a packet, so we decode it.
         size_t decodedLen = 0;
-        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
-                                decodedBuf.second, &decodedLen);
+        size_t dummy = 0;
+
+        ReturnValue_t result =
+            decoder.decode(&encodedBuf.first[stxIdx], availableData - stxIdx, &dummy,
+                           decodedBuf.first, decodedBuf.second, &decodedLen);
         if (result == returnvalue::OK) {
           ctx.setType(ContextType::PACKET_FOUND);
           ctx.decodedPacket.first = decodedBuf.first;
           ctx.decodedPacket.second = decodedLen;
-          this->handler(ctx);
-        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
+          readSize = ++vectorIdx;
+          return returnvalue::OK;
+        } else {
+          // invalid packet, skip.
+          readSize = ++vectorIdx;
           ErrorInfo info;
           info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        } else {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        }
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      } else if (startFound) {
-        // ETX found but STX was found in another mini packet. Reconstruct the full packet
-        // to decode it
-        result = decodeRingBuf.writeData(data, idx + 1);
-        if (result != returnvalue::OK) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-          handler(ctx);
-        }
-        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
-        if (fullEncodedLen > encodedBuf.second) {
-          ErrorInfo info;
-          info.len = fullEncodedLen;
-          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
-          handler(ctx);
-          decodeRingBuf.clear();
-        } else {
-          size_t decodedLen = 0;
-          size_t readLen = 0;
-          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
-          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
-                                  decodedBuf.second, &decodedLen);
-          if (result == returnvalue::OK) {
-            if (this->handler != nullptr) {
-              ctx.setType(ContextType::PACKET_FOUND);
-              ctx.decodedPacket.first = decodedBuf.first;
-              ctx.decodedPacket.second = decodedLen;
-              this->handler(ctx);
-            }
-          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-            handler(ctx);
-          } else {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
-            handler(ctx);
-          }
-          decodeRingBuf.clear();
-          startFound = false;
-          startFoundInThisPacket = false;
-          if ((idx + 1) < len) {
-            copyIntoRingBufFromHere = idx + 1;
-            copyAmount = len - idx - 1;
-          } else {
-            copyAmount = 0;
-          }
+          setErrorContext(ErrorTypes::DECODE_ERROR, info);
+          return POSSIBLE_PACKET_LOSS;
         }
       } else {
-        // End data without preceeding STX
+        // might be lost packet, so we should advance the read pointer
+        readSize = ++vectorIdx;
         ErrorInfo info;
-        info.len = idx + 1;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
-        handler(ctx);
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
+        info.len = 0;
+        setErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
+        return POSSIBLE_PACKET_LOSS;
       }
-      startFoundInThisPacket = false;
-      startFound = false;
     }
   }
-  if (copyAmount > 0) {
-    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
-    if (result != returnvalue::OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
-    }
-  }
-  return returnvalue::OK;
+  return NO_PACKET_FOUND;
 }
 
 void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
@@ -169,8 +105,12 @@ void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* arg
 #endif
 }
 
-void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
-  switch (err) {
+void DleParser::defaultErrorHandler() {
+  if(ctx.getType() != DleParser::ContextType::ERROR) {
+    errorPrinter("No error");
+    return;
+  }
+  switch (ctx.error.first) {
     case (ErrorTypes::NONE): {
       errorPrinter("No error");
       break;
@@ -186,8 +126,8 @@ void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
     case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
     case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
       char opt[64];
-      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
-      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
+      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.decodedPacket.second);
+      if (ctx.error.first == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
         errorPrinter("Encoded buf too small", opt);
       } else {
         errorPrinter("Decoding buf too small", opt);
@@ -218,13 +158,20 @@ void DleParser::errorPrinter(const char* str, const char* opt) {
 #endif
 }
 
-void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
+void DleParser::setErrorContext(ErrorTypes err, ErrorInfo info) {
   ctx.setType(ContextType::ERROR);
   ctx.error.first = err;
   ctx.error.second = info;
 }
 
+ReturnValue_t DleParser::confirmBytesRead(size_t bytesRead) {
+  return decodeRingBuf.deleteData(bytesRead);
+}
+
+const DleParser::Context& DleParser::getContext() {
+  return ctx;
+}
+
 void DleParser::reset() {
-  startFound = false;
   decodeRingBuf.clear();
 }

src/fsfw/globalfunctions/DleParser.h

@@ -18,9 +18,11 @@
  */
 class DleParser {
  public:
+  static constexpr ReturnValue_t NO_PACKET_FOUND = returnvalue::makeCode(1, 1);
+  static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS = returnvalue::makeCode(1, 2);
   using BufPair = std::pair<uint8_t*, size_t>;
 
-  enum class ContextType { PACKET_FOUND, ERROR };
+  enum class ContextType { NONE, PACKET_FOUND, ERROR };
 
   enum class ErrorTypes {
     NONE,
@@ -41,7 +43,7 @@ class DleParser {
 
   struct Context {
    public:
-    Context(void* args) : userArgs(args) { setType(ContextType::PACKET_FOUND); }
+    Context() { setType(ContextType::PACKET_FOUND); }
 
     void setType(ContextType type) {
       this->type = type;
@@ -58,14 +60,11 @@ class DleParser {
 
     BufPair decodedPacket = {};
     ErrorPair error;
-    void* userArgs;
 
    private:
     ContextType type;
   };
 
-  using UserHandler = void (*)(const Context& ctx);
-
   /**
    * Base class constructor
    * @param decodeRingBuf Ring buffer used to store multiple packets to allow detecting DLE packets
@@ -79,7 +78,7 @@ class DleParser {
    * @param args Arbitrary user argument
    */
   DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-            BufPair decodedBuf, UserHandler handler, void* args);
+            BufPair decodedBuf);
 
   /**
    * This function allows to pass new data into the parser. It then scans for DLE packets
@@ -88,8 +87,13 @@ class DleParser {
    * @param len
    * @return
    */
-  ReturnValue_t passData(uint8_t* data, size_t len);
+  ReturnValue_t passData(const uint8_t* data, size_t len);
 
+  ReturnValue_t parseRingBuf(size_t& bytesRead);
+
+  ReturnValue_t confirmBytesRead(size_t bytesRead);
+
+  const Context& getContext();
   /**
    * Example found packet handler
    * function call
@@ -104,11 +108,11 @@ class DleParser {
    *  - For buffer length errors, will be set to the detected packet length which is too large
    *  - For decode or ring buffer errors, will be set to the result returned from the failed call
    */
-  static void defaultErrorHandler(ErrorTypes err, ErrorInfo ctx);
+  void defaultErrorHandler();
 
   static void errorPrinter(const char* str, const char* opt = nullptr);
 
-  void prepareErrorContext(ErrorTypes err, ErrorInfo ctx);
+  void setErrorContext(ErrorTypes err, ErrorInfo ctx);
   /**
    * Resets the parser by resetting the internal states and clearing the decoding ring buffer
    */
@@ -119,7 +123,5 @@ class DleParser {
   DleEncoder& decoder;
   BufPair encodedBuf;
   BufPair decodedBuf;
-  UserHandler handler = nullptr;
   Context ctx;
-  bool startFound = false;
 };

src/fsfw/pus/Service5EventReporting.cpp

@@ -15,8 +15,8 @@ Service5EventReporting::Service5EventReporting(PsbParams params, size_t maxNumbe
       maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
   auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
   psbParams.name = "PUS 5 Event Reporting";
-  eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth,
-    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue(
+      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 Service5EventReporting::~Service5EventReporting() {

src/fsfw/tmtcpacket/ccsds/SpacePacketCreator.cpp

@@ -14,6 +14,7 @@ SpacePacketCreator::SpacePacketCreator(ccsds::PacketType packetType, bool secHea
     : params(SpacePacketParams(PacketId(packetType, secHeaderFlag, apid),
                                PacketSeqCtrl(seqFlags, seqCount), dataLen)) {
   params.version = version;
+  checkFieldValidity();
 }
 
 uint16_t SpacePacketCreator::getPacketIdRaw() const { return params.packetId.raw(); }

src/fsfw/tmtcservices/AcceptsTelemetryIF.h

@@ -21,9 +21,9 @@ class AcceptsTelemetryIF {
    * 			receiving message queue.
    * @return	The telemetry reception message queue id.
    */
-  virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) = 0;
+  [[nodiscard]] virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) const = 0;
 
-  virtual MessageQueueId_t getReportReceptionQueue() { return getReportReceptionQueue(0); }
+  [[nodiscard]] virtual MessageQueueId_t getReportReceptionQueue() const { return getReportReceptionQueue(0); }
 };
 
 #endif /* FSFW_TMTCSERVICES_ACCEPTSTELEMETRYIF_H_ */

src/fsfw/tmtcservices/TmTcBridge.cpp

@@ -245,7 +245,7 @@ void TmTcBridge::registerCommDisconnect() {
   }
 }
 
-MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
+MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) const {
   return tmTcReceptionQueue->getId();
 }
 

src/fsfw/tmtcservices/TmTcBridge.h

@@ -65,7 +65,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
   /** AcceptsTelemetryIF override */
-  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;
+  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) const override;
 
   /** AcceptsTelecommandsIF override */
   uint32_t getIdentifier() const override;

src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -214,7 +214,7 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod
 }
 
 ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
-  gpioMapIter = gpioMap.find(gpioId);
+  auto gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
@@ -244,7 +244,7 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
 }
 
 ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
-  gpioMapIter = gpioMap.find(gpioId);
+  auto gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::pullLow: Unknown GPIO ID " << gpioId << std::endl;
@@ -295,7 +295,7 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId, GpiodRegularBase& regul
 }
 
 ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, gpio::Levels& gpioState) {
-  gpioMapIter = gpioMap.find(gpioId);
+  auto gpioMapIter = gpioMap.find(gpioId);
   if (gpioMapIter == gpioMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LinuxLibgpioIF::readGpio: Unknown GPIOD ID " << gpioId << std::endl;
@@ -377,7 +377,7 @@ ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
                                                     gpio::GpioTypes expectedType,
                                                     GpioMap& mapToAdd) {
   // Cross check with private map
-  gpioMapIter = gpioMap.find(gpioIdToCheck);
+  auto gpioMapIter = gpioMap.find(gpioIdToCheck);
   if (gpioMapIter != gpioMap.end()) {
     auto& gpioType = gpioMapIter->second->gpioType;
     bool eraseDuplicateDifferentType = false;

src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h

@@ -44,7 +44,6 @@ class LinuxLibgpioIF : public GpioIF, public SystemObject {
 
   // Holds the information and configuration of all used GPIOs
   GpioUnorderedMap gpioMap;
-  GpioUnorderedMapIter gpioMapIter;
 
   /**
    * @brief	This functions drives line of a GPIO specified by the GPIO ID.

src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -41,7 +41,7 @@ ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
 
   i2cAddress = i2cCookie->getAddress();
 
-  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  auto i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
     size_t maxReplyLen = i2cCookie->getMaxReplyLen();
     I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
@@ -89,7 +89,7 @@ ReturnValue_t I2cComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, s
   }
 
   address_t i2cAddress = i2cCookie->getAddress();
-  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  auto i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
@@ -140,20 +140,19 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
 #endif
-    i2cDeviceMapIter->second.replyLen = 0;
     return NULLPOINTER;
   }
 
   address_t i2cAddress = i2cCookie->getAddress();
-  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  auto i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
                << "registered in i2cDeviceMap" << std::endl;
 #endif
-    i2cDeviceMapIter->second.replyLen = 0;
     return returnvalue::FAILED;
   }
+  i2cDeviceMapIter->second.replyLen = 0;
 
   deviceFile = i2cCookie->getDeviceFile();
   UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
@@ -162,7 +161,6 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
   }
   result = openDevice(deviceFile, i2cAddress, &fd);
   if (result != returnvalue::OK) {
-    i2cDeviceMapIter->second.replyLen = 0;
     return result;
   }
 
@@ -183,7 +181,10 @@ ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLe
 #else
 #endif
 #endif
-    i2cDeviceMapIter->second.replyLen = 0;
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "I2cComIF::requestReceiveMessage: Read " << readLen << " of " << requestLen
+               << " bytes" << std::endl;
+#endif
     return returnvalue::FAILED;
   }
 
@@ -206,7 +207,7 @@ ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   }
 
   address_t i2cAddress = i2cCookie->getAddress();
-  i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+  auto i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
   if (i2cDeviceMapIter == i2cDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
@@ -216,7 +217,7 @@ ReturnValue_t I2cComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   }
   *buffer = i2cDeviceMapIter->second.replyBuffer.data();
   *size = i2cDeviceMapIter->second.replyLen;
-
+  i2cDeviceMapIter->second.replyLen = 0;
   return returnvalue::OK;
 }
 

src/fsfw_hal/linux/i2c/I2cComIF.h

@@ -36,12 +36,10 @@ class I2cComIF : public DeviceCommunicationIF, public SystemObject {
   };
 
   using I2cDeviceMap = std::unordered_map<address_t, I2cInstance>;
-  using I2cDeviceMapIter = I2cDeviceMap::iterator;
 
   /* In this map all i2c devices will be registered with their address and
    * the appropriate file descriptor will be stored */
   I2cDeviceMap i2cDeviceMap;
-  I2cDeviceMapIter i2cDeviceMapIter;
 
   /**
    * @brief	This function opens an I2C device and binds the opened file

src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -15,18 +15,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 #include "fsfw_hal/linux/utility.h"
 
-SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF)
+SpiComIF::SpiComIF(object_id_t objectId, std::string devname, GpioIF& gpioComIF)
     : SystemObject(objectId), gpioComIF(gpioComIF), dev(std::move(devname)) {
-  if (gpioComIF == nullptr) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "SpiComIF::SpiComIF: GPIO communication interface invalid!" << std::endl;
-#else
-    sif::printError("SpiComIF::SpiComIF: GPIO communication interface invalid!\n");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* FSFW_VERBOSE_LEVEL >= 1 */
-  }
-
   csMutex = MutexFactory::instance()->createMutex();
 }
 
@@ -75,7 +65,7 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF* cookie) {
   /* Pull CS high in any case to be sure that device is inactive */
   gpioId_t gpioId = spiCookie->getChipSelectPin();
   if (gpioId != gpio::NO_GPIO) {
-    gpioComIF->pullHigh(gpioId);
+    gpioComIF.pullHigh(gpioId);
   }
 
   uint32_t spiSpeed = 0;
@@ -215,7 +205,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
       return result;
     }
     updateLinePolarity(fileDescriptor);
-    result = gpioComIF->pullLow(gpioId);
+    result = gpioComIF.pullLow(gpioId);
     if (result != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -256,7 +246,7 @@ ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie* spiCookie, const
   }
 
   if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    gpioComIF->pullHigh(gpioId);
+    gpioComIF.pullHigh(gpioId);
     result = csMutex->unlockMutex();
     if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -317,7 +307,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
 #endif
       return result;
     }
-    gpioComIF->pullLow(gpioId);
+    gpioComIF.pullLow(gpioId);
   }
 
   if (read(fileDescriptor, rxBuf, readSize) != static_cast<ssize_t>(readSize)) {
@@ -332,7 +322,7 @@ ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
   }
 
   if (gpioId != gpio::NO_GPIO and not csLockManual) {
-    gpioComIF->pullHigh(gpioId);
+    gpioComIF.pullHigh(gpioId);
     result = csMutex->unlockMutex();
     if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -397,7 +387,7 @@ ReturnValue_t SpiComIF::getReadBuffer(address_t spiAddress, uint8_t** buffer) {
   return returnvalue::OK;
 }
 
-GpioIF* SpiComIF::getGpioInterface() { return gpioComIF; }
+GpioIF& SpiComIF::getGpioInterface() { return gpioComIF; }
 
 void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed) {
   int retval = ioctl(spiFd, SPI_IOC_WR_MODE, reinterpret_cast<uint8_t*>(&mode));

src/fsfw_hal/linux/spi/SpiComIF.h

@@ -31,7 +31,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
       returnvalue::makeCode(spiRetvalId, 2);
 
-  SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
+  SpiComIF(object_id_t objectId, std::string devname, GpioIF& gpioComIF);
 
   ReturnValue_t initializeInterface(CookieIF* cookie) override;
   ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
@@ -57,7 +57,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
   ReturnValue_t performRegularSendOperation(SpiCookie* spiCookie, const uint8_t* sendData,
                                             size_t sendLen);
 
-  GpioIF* getGpioInterface();
+  GpioIF& getGpioInterface();
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
   void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
 
@@ -83,7 +83,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
     std::vector<uint8_t> replyBuffer;
   };
 
-  GpioIF* gpioComIF = nullptr;
+  GpioIF& gpioComIF;
   std::string dev = "";
   /**
    * Protects the chip select operations. Lock when GPIO is pulled low, unlock after it was

src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -16,7 +16,6 @@ UartComIF::~UartComIF() {}
 
 ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
 
   if (cookie == nullptr) {
     return NULLPOINTER;
@@ -32,7 +31,7 @@ ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
 
   deviceFile = uartCookie->getDeviceFile();
 
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter == uartDeviceMap.end()) {
     int fileDescriptor = configureUartPort(uartCookie);
     if (fileDescriptor < 0) {
@@ -193,7 +192,6 @@ void UartComIF::setFixedOptions(struct termios* options) {
 ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
   int fd = 0;
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
 
   if (sendLen == 0) {
     return returnvalue::OK;
@@ -215,7 +213,7 @@ ReturnValue_t UartComIF::sendMessage(CookieIF* cookie, const uint8_t* sendData,
   }
 
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter == uartDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "UartComIF::sendMessage: Device file " << deviceFile << "not in UART map"
@@ -241,7 +239,6 @@ ReturnValue_t UartComIF::getSendSuccess(CookieIF* cookie) { return returnvalue::
 
 ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
 
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
@@ -253,7 +250,7 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
 
   UartModes uartMode = uartCookie->getUartMode();
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
 
   if (uartMode == UartModes::NON_CANONICAL and requestLen == 0) {
     return returnvalue::OK;
@@ -276,7 +273,7 @@ ReturnValue_t UartComIF::requestReceiveMessage(CookieIF* cookie, size_t requestL
   }
 }
 
-ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
                                              size_t requestLen) {
   ReturnValue_t result = returnvalue::OK;
   uint8_t maxReadCycles = uartCookie.getReadCycles();
@@ -334,7 +331,7 @@ ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceM
   return result;
 }
 
-ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
                                                 size_t requestLen) {
   int fd = iter->second.fileDescriptor;
   auto bufferPtr = iter->second.replyBuffer.data();
@@ -370,7 +367,6 @@ ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie& uartCookie, UartDevi
 
 ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
 
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
@@ -381,7 +377,7 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
   }
 
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter == uartDeviceMap.end()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::debug << "UartComIF::readReceivedMessage: Device file " << deviceFile << " not in uart map"
@@ -401,7 +397,6 @@ ReturnValue_t UartComIF::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
 
 ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -410,7 +405,7 @@ ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCIFLUSH);
@@ -421,7 +416,6 @@ ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF* cookie) {
 
 ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -430,7 +424,7 @@ ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCOFLUSH);
@@ -441,7 +435,6 @@ ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF* cookie) {
 
 ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
   std::string deviceFile;
-  UartDeviceMapIter uartDeviceMapIter;
   UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
   if (uartCookie == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -450,7 +443,7 @@ ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF* cookie) {
     return NULLPOINTER;
   }
   deviceFile = uartCookie->getDeviceFile();
-  uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+  auto uartDeviceMapIter = uartDeviceMap.find(deviceFile);
   if (uartDeviceMapIter != uartDeviceMap.end()) {
     int fd = uartDeviceMapIter->second.fileDescriptor;
     tcflush(fd, TCIOFLUSH);

src/fsfw_hal/linux/uart/UartComIF.h

@@ -64,7 +64,6 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
   };
 
   using UartDeviceMap = std::unordered_map<UartDeviceFile_t, UartElements>;
-  using UartDeviceMapIter = UartDeviceMap::iterator;
 
   /**
    * The uart devie map stores informations of initialized uart ports.
@@ -103,9 +102,9 @@ class UartComIF : public DeviceCommunicationIF, public SystemObject {
    */
   void setDatasizeOptions(struct termios* options, UartCookie* uartCookie);
 
-  ReturnValue_t handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+  ReturnValue_t handleCanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
                                     size_t requestLen);
-  ReturnValue_t handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+  ReturnValue_t handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMap::iterator& iter,
                                        size_t requestLen);
 };
 

src/fsfw_hal/linux/uart/helper.cpp

@@ -71,16 +71,14 @@ void uart::setBaudrate(struct termios& options, UartBaudRate baud) {
       cfsetospeed(&options, B19200);
       break;
     case UartBaudRate::RATE_38400:
-      cfsetispeed(&options, B38400);
-      cfsetospeed(&options, B38400);
+      cfsetspeed(&options, B38400);
       break;
     case UartBaudRate::RATE_57600:
       cfsetispeed(&options, B57600);
       cfsetospeed(&options, B57600);
       break;
     case UartBaudRate::RATE_115200:
-      cfsetispeed(&options, B115200);
-      cfsetospeed(&options, B115200);
+      cfsetspeed(&options, B115200);
       break;
     case UartBaudRate::RATE_230400:
       cfsetispeed(&options, B230400);