Merge remote-tracking branch 'upstream/mueller/dhb-handle-device-tm' into develop

CHANGELOG.md

@@ -12,6 +12,10 @@ 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.

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. */
+      reportData(queueId);
-      actionHelper.reportData(queueId, replyId, dataSet);
     }
 
-    /* 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,8 +1070,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   bool isAwaitingReply();
 
-  void handleDeviceTM(SerializeIF *dataSet, DeviceCommandId_t replyId, bool forceDirectTm = false);
+  void handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
-  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,

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)
+                                                   util::DataWrapper data)
-    : objectId(objectId), actionId(actionId), data(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);
+  return returnvalue::FAILED;
-  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);
 }

src/fsfw/devicehandlers/DeviceTmReportingWrapper.h

@@ -1,27 +1,29 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 
-#include "../action/HasActionsIF.h"
+#include "fsfw/action/HasActionsIF.h"
-#include "../objectmanager/SystemObjectIF.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
-#include "../serialize/SerializeIF.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);
+  DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, util::DataWrapper data);
-  virtual ~DeviceTmReportingWrapper();
+  ~DeviceTmReportingWrapper() override;
 
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override;
+                          Endianness streamEndianness) const override;
 
-  virtual size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
-
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) 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_ */