KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

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

Browse Source
This commit is contained in:
Robin Müller 2022-08-30 15:40:52 +02:00
commit eedf57624f
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
5 changed files with 60 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -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.

38
src/fsfw/devicehandlers/DeviceHandlerBase.cpp
View File

@ -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

4
src/fsfw/devicehandlers/DeviceHandlerBase.h
View File

@ -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(const uint8_t *data, size_t dataSize, DeviceCommandId_t replyId,
void handleDeviceTm(util::DataWrapper dataWrapper, DeviceCommandId_t replyId,
bool forceDirectTm = false);
virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,

33
src/fsfw/devicehandlers/DeviceTmReportingWrapper.cpp
View File

@ -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;
}

26
src/fsfw/devicehandlers/DeviceTmReportingWrapper.h
View File

@ -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_ */