From 2a75440b325b70b7ca90269159440a1f9a4a6e2a Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sat, 27 Aug 2022 01:01:29 +0200 Subject: [PATCH] allow device tm in raw format --- src/fsfw/devicehandlers/DeviceHandlerBase.cpp | 61 +++++++++++++++++++ src/fsfw/devicehandlers/DeviceHandlerBase.h | 4 +- src/fsfw/health/HasHealthIF.h | 9 +-- src/fsfw/parameters/HasParametersIF.h | 3 +- src/fsfw/tmtcservices/SourceSequenceCounter.h | 12 +--- 5 files changed, 71 insertions(+), 18 deletions(-) diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp index 1b64e1e2..15dbca97 100644 --- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp +++ b/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(); diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.h b/src/fsfw/devicehandlers/DeviceHandlerBase.h index 8864c821..7f7c2751 100644 --- a/src/fsfw/devicehandlers/DeviceHandlerBase.h +++ b/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); diff --git a/src/fsfw/health/HasHealthIF.h b/src/fsfw/health/HasHealthIF.h index bf696e15..16666bbc 100644 --- a/src/fsfw/health/HasHealthIF.h +++ b/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 diff --git a/src/fsfw/parameters/HasParametersIF.h b/src/fsfw/parameters/HasParametersIF.h index 5d70c328..8dc99644 100644 --- a/src/fsfw/parameters/HasParametersIF.h +++ b/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, diff --git a/src/fsfw/tmtcservices/SourceSequenceCounter.h b/src/fsfw/tmtcservices/SourceSequenceCounter.h index 9b8e85d1..43b6945c 100644 --- a/src/fsfw/tmtcservices/SourceSequenceCounter.h +++ b/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;