2021-07-13 20:58:45 +02:00
|
|
|
#include "fsfw/pus/Service3Housekeeping.h"
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2021-07-13 20:58:45 +02:00
|
|
|
#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
|
2022-02-02 10:29:30 +01:00
|
|
|
#include "fsfw/objectmanager/ObjectManager.h"
|
|
|
|
#include "fsfw/pus/servicepackets/Service3Packets.h"
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId)
|
2022-08-01 11:00:36 +02:00
|
|
|
: CommandingServiceBase(objectId, apid, "PUS 3 HK", serviceId, NUM_OF_PARALLEL_COMMANDS,
|
2022-02-02 10:29:30 +01:00
|
|
|
COMMAND_TIMEOUT_SECONDS) {}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
|
|
|
Service3Housekeeping::~Service3Housekeeping() {}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) {
|
2022-02-02 10:29:30 +01:00
|
|
|
switch (static_cast<Subservice>(subservice)) {
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
|
|
|
|
case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
|
|
|
|
case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
|
|
|
|
case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
|
|
|
|
case Subservice::REPORT_HK_REPORT_STRUCTURES:
|
2022-02-02 10:29:30 +01:00
|
|
|
case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::GENERATE_ONE_PARAMETER_REPORT:
|
|
|
|
case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
|
|
|
|
case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
|
|
|
|
case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2022-02-02 10:29:30 +01:00
|
|
|
// Telemetry or invalid subservice.
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::HK_DEFINITIONS_REPORT:
|
|
|
|
case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
|
|
|
|
case Subservice::HK_REPORT:
|
|
|
|
case Subservice::DIAGNOSTICS_REPORT:
|
|
|
|
default:
|
2022-02-02 10:29:30 +01:00
|
|
|
return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
|
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice,
|
2022-02-02 10:29:30 +01:00
|
|
|
const uint8_t* tcData,
|
|
|
|
size_t tcDataLen, MessageQueueId_t* id,
|
|
|
|
object_id_t* objectId) {
|
|
|
|
ReturnValue_t result = checkAndAcquireTargetID(objectId, tcData, tcDataLen);
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return checkInterfaceAndAcquireMessageQueue(id, objectId);
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(object_id_t* objectIdToSet,
|
|
|
|
const uint8_t* tcData,
|
|
|
|
size_t tcDataLen) {
|
|
|
|
if (SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen,
|
2022-08-16 01:08:26 +02:00
|
|
|
SerializeIF::Endianness::BIG) != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return CommandingServiceBase::INVALID_TC;
|
|
|
|
}
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
|
2022-02-02 10:29:30 +01:00
|
|
|
MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
|
|
|
|
// check HasLocalDataPoolIF property of target
|
|
|
|
HasLocalDataPoolIF* possibleTarget =
|
|
|
|
ObjectManager::instance()->get<HasLocalDataPoolIF>(*objectId);
|
|
|
|
if (possibleTarget == nullptr) {
|
|
|
|
return CommandingServiceBase::INVALID_OBJECT;
|
|
|
|
}
|
|
|
|
*messageQueueToSet = possibleTarget->getCommandQueue();
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t Service3Housekeeping::prepareCommand(CommandMessage* message, uint8_t subservice,
|
|
|
|
const uint8_t* tcData, size_t tcDataLen,
|
|
|
|
uint32_t* state, object_id_t objectId) {
|
|
|
|
switch (static_cast<Subservice>(subservice)) {
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareReportingTogglingCommand(message, objectId, true, false, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareReportingTogglingCommand(message, objectId, false, false, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareReportingTogglingCommand(message, objectId, true, true, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareReportingTogglingCommand(message, objectId, false, true, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::REPORT_HK_REPORT_STRUCTURES:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareStructureReportingCommand(message, objectId, false, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareStructureReportingCommand(message, objectId, true, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::GENERATE_ONE_PARAMETER_REPORT:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareOneShotReportCommand(message, objectId, false, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareOneShotReportCommand(message, objectId, true, tcData, tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareCollectionIntervalModificationCommand(message, objectId, false, tcData,
|
|
|
|
tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL:
|
2022-02-02 10:29:30 +01:00
|
|
|
return prepareCollectionIntervalModificationCommand(message, objectId, true, tcData,
|
|
|
|
tcDataLen);
|
2021-02-03 22:18:00 +01:00
|
|
|
case Subservice::HK_DEFINITIONS_REPORT:
|
|
|
|
case Subservice::DIAGNOSTICS_DEFINITION_REPORT:
|
|
|
|
case Subservice::HK_REPORT:
|
|
|
|
case Subservice::DIAGNOSTICS_REPORT:
|
2022-02-02 10:29:30 +01:00
|
|
|
// Those are telemetry packets.
|
|
|
|
return CommandingServiceBase::INVALID_TC;
|
2021-02-03 22:18:00 +01:00
|
|
|
default:
|
2022-02-02 10:29:30 +01:00
|
|
|
// should never happen, subservice was already checked.
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::FAILED;
|
2022-02-02 10:29:30 +01:00
|
|
|
}
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(
|
2022-02-02 10:29:30 +01:00
|
|
|
CommandMessage* command, object_id_t objectId, bool enableReporting, bool isDiagnostics,
|
|
|
|
const uint8_t* tcData, size_t tcDataLen) {
|
|
|
|
if (tcDataLen < sizeof(sid_t)) {
|
|
|
|
// TC data should consist of object ID and set ID.
|
|
|
|
return CommandingServiceBase::INVALID_TC;
|
|
|
|
}
|
|
|
|
|
|
|
|
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
|
|
|
|
HousekeepingMessage::setToggleReportingCommand(command, targetSid, enableReporting,
|
|
|
|
isDiagnostics);
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(CommandMessage* command,
|
|
|
|
object_id_t objectId,
|
|
|
|
bool isDiagnostics,
|
|
|
|
const uint8_t* tcData,
|
|
|
|
size_t tcDataLen) {
|
|
|
|
if (tcDataLen < sizeof(sid_t)) {
|
|
|
|
// TC data should consist of object ID and set ID.
|
|
|
|
return CommandingServiceBase::INVALID_TC;
|
|
|
|
}
|
|
|
|
|
|
|
|
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
|
|
|
|
HousekeepingMessage::setStructureReportingCommand(command, targetSid, isDiagnostics);
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(CommandMessage* command,
|
|
|
|
object_id_t objectId,
|
|
|
|
bool isDiagnostics,
|
|
|
|
const uint8_t* tcData,
|
|
|
|
size_t tcDataLen) {
|
|
|
|
if (tcDataLen < sizeof(sid_t)) {
|
|
|
|
// TC data should consist of object ID and set ID.
|
|
|
|
return CommandingServiceBase::INVALID_TC;
|
|
|
|
}
|
|
|
|
|
|
|
|
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
|
|
|
|
HousekeepingMessage::setOneShotReportCommand(command, targetSid, isDiagnostics);
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
|
2022-02-02 10:29:30 +01:00
|
|
|
CommandMessage* command, object_id_t objectId, bool isDiagnostics, const uint8_t* tcData,
|
|
|
|
size_t tcDataLen) {
|
|
|
|
if (tcDataLen < sizeof(sid_t) + sizeof(float)) {
|
|
|
|
/* SID plus the size of the new collection interval. */
|
|
|
|
return CommandingServiceBase::INVALID_TC;
|
|
|
|
}
|
|
|
|
|
|
|
|
sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
|
|
|
|
float newCollectionInterval = 0;
|
|
|
|
SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
|
|
|
|
SerializeIF::Endianness::BIG);
|
|
|
|
HousekeepingMessage::setCollectionIntervalModificationCommand(
|
|
|
|
command, targetSid, newCollectionInterval, isDiagnostics);
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
|
2022-02-02 10:29:30 +01:00
|
|
|
Command_t previousCommand, uint32_t* state,
|
|
|
|
CommandMessage* optionalNextCommand,
|
|
|
|
object_id_t objectId, bool* isStep) {
|
|
|
|
Command_t command = reply->getCommand();
|
|
|
|
switch (command) {
|
|
|
|
case (HousekeepingMessage::HK_REPORT): {
|
|
|
|
ReturnValue_t result = generateHkReply(reply, static_cast<uint8_t>(Subservice::HK_REPORT));
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return CommandingServiceBase::EXECUTION_COMPLETE;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::DIAGNOSTICS_REPORT): {
|
|
|
|
ReturnValue_t result =
|
|
|
|
generateHkReply(reply, static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return CommandingServiceBase::EXECUTION_COMPLETE;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_DEFINITIONS_REPORT): {
|
|
|
|
return generateHkReply(reply, static_cast<uint8_t>(Subservice::HK_DEFINITIONS_REPORT));
|
|
|
|
break;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::DIAGNOSTICS_DEFINITION_REPORT): {
|
|
|
|
return generateHkReply(reply,
|
|
|
|
static_cast<uint8_t>(Subservice::DIAGNOSTICS_DEFINITION_REPORT));
|
|
|
|
break;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_REQUEST_SUCCESS): {
|
|
|
|
return CommandingServiceBase::EXECUTION_COMPLETE;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_REQUEST_FAILURE): {
|
|
|
|
failureParameter1 = objectId;
|
2022-08-16 01:08:26 +02:00
|
|
|
ReturnValue_t error = returnvalue::FAILED;
|
2022-02-02 10:29:30 +01:00
|
|
|
HousekeepingMessage::getHkRequestFailureReply(reply, &error);
|
|
|
|
failureParameter2 = error;
|
2022-08-24 17:25:45 +02:00
|
|
|
return returnvalue::FAILED;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2021-02-03 22:18:00 +01:00
|
|
|
default:
|
2021-01-03 14:16:52 +01:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
|
2022-04-04 20:34:31 +02:00
|
|
|
<< "reply command " << command << std::endl;
|
2021-02-03 18:04:55 +01:00
|
|
|
#else
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::printWarning(
|
|
|
|
"Service3Housekeeping::handleReply: Invalid reply with "
|
2022-04-04 20:34:31 +02:00
|
|
|
"reply command %hu\n",
|
2022-02-02 10:29:30 +01:00
|
|
|
command);
|
2021-01-03 13:58:18 +01:00
|
|
|
#endif
|
2022-02-02 10:29:30 +01:00
|
|
|
return CommandingServiceBase::INVALID_REPLY;
|
|
|
|
}
|
2022-08-16 01:08:26 +02:00
|
|
|
return returnvalue::OK;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
|
2022-08-16 01:08:26 +02:00
|
|
|
ReturnValue_t result = returnvalue::OK;
|
2022-02-02 10:29:30 +01:00
|
|
|
Command_t command = reply->getCommand();
|
2021-02-03 22:18:00 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
switch (command) {
|
|
|
|
case (HousekeepingMessage::DIAGNOSTICS_REPORT): {
|
|
|
|
result = generateHkReply(reply, static_cast<uint8_t>(Subservice::DIAGNOSTICS_REPORT));
|
|
|
|
break;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_REPORT): {
|
|
|
|
result = generateHkReply(reply, static_cast<uint8_t>(Subservice::HK_REPORT));
|
|
|
|
break;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_REQUEST_SUCCESS): {
|
|
|
|
break;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
case (HousekeepingMessage::HK_REQUEST_FAILURE): {
|
|
|
|
break;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2022-06-21 00:49:58 +02:00
|
|
|
case (CommandMessage::REPLY_REJECTED): {
|
2022-08-15 11:18:53 +02:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-05-25 14:30:00 +02:00
|
|
|
sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
|
2022-06-21 00:49:58 +02:00
|
|
|
"rejected with error code"
|
|
|
|
<< reply->getParameter() << std::endl;
|
2022-08-15 11:18:53 +02:00
|
|
|
#else
|
|
|
|
#endif
|
2022-05-25 14:30:00 +02:00
|
|
|
break;
|
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2021-02-03 22:18:00 +01:00
|
|
|
default: {
|
2021-01-03 14:16:52 +01:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
|
2022-06-21 00:49:58 +02:00
|
|
|
"command "
|
|
|
|
<< command << "" << std::endl;
|
2021-02-03 18:04:55 +01:00
|
|
|
#else
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::printWarning(
|
|
|
|
"Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
|
2022-05-25 14:30:00 +02:00
|
|
|
"reply command %hu\n",
|
2022-02-02 10:29:30 +01:00
|
|
|
command);
|
2021-01-03 13:58:18 +01:00
|
|
|
#endif
|
2022-05-25 14:30:00 +02:00
|
|
|
break;
|
2021-02-03 22:18:00 +01:00
|
|
|
}
|
2022-02-02 10:29:30 +01:00
|
|
|
}
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-08-16 01:08:26 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
/* Configuration error */
|
2021-01-03 14:16:52 +01:00
|
|
|
#if FSFW_CPP_OSTREAM_ENABLED == 1
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!"
|
|
|
|
<< std::endl;
|
2021-02-03 18:04:55 +01:00
|
|
|
#else
|
2022-02-02 10:29:30 +01:00
|
|
|
sif::printWarning(
|
|
|
|
"Service3Housekeeping::handleUnrequestedReply: "
|
|
|
|
"Could not generate reply!\n");
|
2021-01-03 13:58:18 +01:00
|
|
|
#endif
|
2022-02-02 10:29:30 +01:00
|
|
|
}
|
2022-05-25 14:30:00 +02:00
|
|
|
CommandingServiceBase::handleUnrequestedReply(reply);
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
MessageQueueId_t Service3Housekeeping::getHkQueue() const { return commandQueue->getId(); }
|
2020-12-15 22:42:50 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t Service3Housekeeping::generateHkReply(const CommandMessage* hkMessage,
|
|
|
|
uint8_t subserviceId) {
|
|
|
|
store_address_t storeId;
|
2021-02-03 22:18:00 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
|
2022-07-20 22:21:15 +02:00
|
|
|
auto resultPair = ipcStore->getData(storeId);
|
2022-08-16 01:08:26 +02:00
|
|
|
if (resultPair.first != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return resultPair.first;
|
|
|
|
}
|
2021-02-03 22:18:00 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
|
2022-07-26 13:59:09 +02:00
|
|
|
return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize);
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
sid_t Service3Housekeeping::buildSid(object_id_t objectId, const uint8_t** tcData,
|
|
|
|
size_t* tcDataLen) {
|
|
|
|
sid_t targetSid;
|
|
|
|
targetSid.objectId = objectId;
|
|
|
|
// skip deserialization of object ID, was already done.
|
|
|
|
*tcData += sizeof(object_id_t);
|
|
|
|
*tcDataLen -= sizeof(object_id_t);
|
|
|
|
// size check is expected to be performed beforehand!
|
|
|
|
SerializeAdapter::deSerialize(&targetSid.ownerSetId, tcData, tcDataLen,
|
|
|
|
SerializeIF::Endianness::BIG);
|
|
|
|
return targetSid;
|
2020-12-15 22:42:50 +01:00
|
|
|
}
|