src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1325,6 +1325,67 @@ void DeviceHandlerBase::handleDeviceTM(SerializeIF* dataSet, DeviceCommandId_t r
   }
 }
 
+void DeviceHandlerBase::handleDeviceTM(const uint8_t* data, size_t dataSize,
+                                       DeviceCommandId_t replyId, bool forceDirectTm) {
+  // TODO: Horrible duplicate code. Avoiding this would require using the Serializable union
+  //       type. Furthermore, DeviceTmReportingWrapper needs to be extended to allow using raw
+  //       buffers.
+  if (data == nullptr) {
+    return;
+  }
+
+  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+  if (iter == deviceReplyMap.end()) {
+    triggerEvent(DEVICE_UNKNOWN_REPLY, replyId);
+    return;
+  }
+
+  /* Regular replies to a command */
+  if (iter->second.command != deviceCommandMap.end()) {
+    MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
+
+    if (queueId != NO_COMMANDER) {
+      /* This may fail, but we'll ignore the fault. */
+      actionHelper.reportData(queueId, replyId, data, dataSize);
+    }
+
+    /* This check should make sure we get any TM but don't get anything doubled. */
+    // TODO: The wrapper does not support this..
+    //    if (wiretappingMode == TM && (requestedRawTraffic != queueId)) {
+    //      DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data, dataSize);
+    //      actionHelper.reportData(requestedRawTraffic, replyId, &wrapper);
+    //    }
+
+    else if (forceDirectTm and (defaultRawReceiver != queueId) and
+             (defaultRawReceiver != MessageQueueIF::NO_QUEUE)) {
+      // 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, data, dataSize, true);
+    }
+  }
+  /* Unrequested or aperiodic replies */
+  // TODO: The wrapper does not support this..
+  //  else {
+  //    DeviceTmReportingWrapper wrapper(getObjectId(), replyId, data, dataSize);
+  //    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
+  //      actionHelper.reportData(defaultRawReceiver, replyId, &wrapper, true);
+  //    }
+  //  }
+}
+
 ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                                const uint8_t* data, size_t size) {
   ReturnValue_t result = acceptExternalDeviceCommands();

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -1070,8 +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(const uint8_t *data, size_t dataSize, DeviceCommandId_t replyId,
+                      bool forceDirectTm = false);
 
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                          uint32_t *msToReachTheMode);

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/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/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;