From 1446ce94bf9d96596ed89b23ced889c08bcb8894 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 3 Feb 2021 16:31:03 +0100 Subject: [PATCH 1/8] small tweaks --- datapoollocal/LocalDataPoolManager.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index 2c5c4e0e..c8d1e30d 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -848,7 +848,6 @@ MutexIF* LocalDataPoolManager::getLocalPoolMutex() { object_id_t LocalDataPoolManager::getCreatorObjectId() const { return owner->getObjectId(); - //return owner->getObjectId(); } void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, @@ -885,7 +884,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, if(outputType == sif::OutputTypes::OUT_WARNING) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "LocalDataPoolManager::" << functionName - << ": Object ID " << std::setw(8) << std::setfill('0') + << ": Object ID 0x" << std::setw(8) << std::setfill('0') << std::hex << owner->getObjectId() << " | " << errorPrint << std::dec << std::setfill(' ') << std::endl; #else @@ -896,7 +895,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, else if(outputType == sif::OutputTypes::OUT_ERROR) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::error << "LocalDataPoolManager::" << functionName - << ": Object ID " << std::setw(8) << std::setfill('0') + << ": Object ID 0x" << std::setw(8) << std::setfill('0') << std::hex << owner->getObjectId() << " | " << errorPrint << std::dec << std::setfill(' ') << std::endl; #else From 2bca40c527de985495220ee9ed734cb1f7bf6d2c Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 3 Feb 2021 18:04:55 +0100 Subject: [PATCH 2/8] printout improvements --- datapoollocal/LocalPoolDataSetBase.cpp | 2 +- pus/Service3Housekeeping.cpp | 27 +++++++++++++++++--------- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp index 035ba694..d5c0556c 100644 --- a/datapoollocal/LocalPoolDataSetBase.cpp +++ b/datapoollocal/LocalPoolDataSetBase.cpp @@ -83,7 +83,7 @@ ReturnValue_t LocalPoolDataSetBase::lockDataPool( ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer, size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) const { - ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; uint8_t validityMaskSize = std::ceil(static_cast(fillCount)/8.0); uint8_t validityMask[validityMaskSize]; uint8_t validBufferIndex = 0; diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp index ba7ff6ee..16116ee6 100644 --- a/pus/Service3Housekeeping.cpp +++ b/pus/Service3Housekeeping.cpp @@ -223,8 +223,11 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply, default: #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::error << "Service3Housekeeping::handleReply: Invalid reply with " + sif::warning << "Service3Housekeeping::handleReply: Invalid reply with " << "reply command " << command << "!" << std::endl; +#else + sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with " + "reply command %hu!\n", command); #endif return CommandingServiceBase::INVALID_REPLY; } @@ -250,20 +253,26 @@ void Service3Housekeeping::handleUnrequestedReply( break; } - default: + default: { #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::error << "Service3Housekeeping::handleUnrequestedReply: Invalid " - << "reply with " << "reply command " << command << "!" - << std::endl; + sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply " + "command " << command << "!" << std::endl; +#else + sif::printWarning("Service3Housekeeping::handleUnrequestedReply: Invalid reply with " + "reply command %hu!\n", command); #endif - return; + return; + } } if(result != HasReturnvaluesIF::RETURN_OK) { - // Configuration error + /* Configuration error */ #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::debug << "Service3Housekeeping::handleUnrequestedReply:" - << "Could not generate reply!" << std::endl; + sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" << + std::endl; +#else + sif::printWarning("Service3Housekeeping::handleUnrequestedReply: " + "Could not generate reply!\n"); #endif } } From cdb012fe5a683a4bbd29c0ea1853971e2f0fdf69 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 3 Feb 2021 22:09:22 +0100 Subject: [PATCH 3/8] important bugfix --- datapoollocal/LocalDataPoolManager.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index c8d1e30d..48b4a038 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -714,7 +714,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { return; } - if(periodicHelper->checkOpNecessary()) { + if(not periodicHelper->checkOpNecessary()) { return; } @@ -723,11 +723,10 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { if(result != HasReturnvaluesIF::RETURN_OK) { // configuration error #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::warning << "LocalDataPoolManager::performHkOperation: " - << "HK generation failed." << std::endl; + sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." << + std::endl; #else - sif::printWarning("LocalDataPoolManager::performHkOperation: " - "HK generation failed.\n"); + sif::printWarning("LocalDataPoolManager::performHkOperation: HK generation failed.\n"); #endif } } From f7c1aae464ec533092ac0ea2906e9d06bb03a2ff Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 3 Feb 2021 22:18:00 +0100 Subject: [PATCH 4/8] small tweak --- pus/Service3Housekeeping.cpp | 442 ++++++++++++++++++----------------- 1 file changed, 225 insertions(+), 217 deletions(-) diff --git a/pus/Service3Housekeeping.cpp b/pus/Service3Housekeeping.cpp index 16116ee6..5456764d 100644 --- a/pus/Service3Housekeeping.cpp +++ b/pus/Service3Housekeeping.cpp @@ -4,199 +4,199 @@ Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, - uint8_t serviceId): - CommandingServiceBase(objectId, apid, serviceId, - NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {} + uint8_t serviceId): + CommandingServiceBase(objectId, apid, serviceId, + NUM_OF_PARALLEL_COMMANDS, COMMAND_TIMEOUT_SECONDS) {} Service3Housekeeping::~Service3Housekeeping() {} ReturnValue_t Service3Housekeeping::isValidSubservice(uint8_t subservice) { - switch(static_cast(subservice)) { - 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: - case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES : - 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: - return HasReturnvaluesIF::RETURN_OK; - // Telemetry or invalid subservice. - case Subservice::HK_DEFINITIONS_REPORT: - case Subservice::DIAGNOSTICS_DEFINITION_REPORT: - case Subservice::HK_REPORT: - case Subservice::DIAGNOSTICS_REPORT: - default: - return AcceptsTelecommandsIF::INVALID_SUBSERVICE; - } + switch(static_cast(subservice)) { + 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: + case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES : + 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: + return HasReturnvaluesIF::RETURN_OK; + // Telemetry or invalid subservice. + case Subservice::HK_DEFINITIONS_REPORT: + case Subservice::DIAGNOSTICS_DEFINITION_REPORT: + case Subservice::HK_REPORT: + case Subservice::DIAGNOSTICS_REPORT: + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } } ReturnValue_t Service3Housekeeping::getMessageQueueAndObject(uint8_t subservice, - const uint8_t *tcData, size_t tcDataLen, - MessageQueueId_t *id, object_id_t *objectId) { - ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen); - if(result != RETURN_OK) { - return result; - } - return checkInterfaceAndAcquireMessageQueue(id,objectId); + const uint8_t *tcData, size_t tcDataLen, + MessageQueueId_t *id, object_id_t *objectId) { + ReturnValue_t result = checkAndAcquireTargetID(objectId,tcData,tcDataLen); + if(result != RETURN_OK) { + return result; + } + return checkInterfaceAndAcquireMessageQueue(id,objectId); } ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID( - object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) { - if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen, - SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) { - return CommandingServiceBase::INVALID_TC; - } - return HasReturnvaluesIF::RETURN_OK; + object_id_t* objectIdToSet, const uint8_t* tcData, size_t tcDataLen) { + if(SerializeAdapter::deSerialize(objectIdToSet, &tcData, &tcDataLen, + SerializeIF::Endianness::BIG) != HasReturnvaluesIF::RETURN_OK) { + return CommandingServiceBase::INVALID_TC; + } + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { - // check HasLocalDataPoolIF property of target - HasLocalDataPoolIF* possibleTarget = - objectManager->get(*objectId); - if(possibleTarget == nullptr){ - return CommandingServiceBase::INVALID_OBJECT; - } - *messageQueueToSet = possibleTarget->getCommandQueue(); - return HasReturnvaluesIF::RETURN_OK; + MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { + // check HasLocalDataPoolIF property of target + HasLocalDataPoolIF* possibleTarget = + objectManager->get(*objectId); + if(possibleTarget == nullptr){ + return CommandingServiceBase::INVALID_OBJECT; + } + *messageQueueToSet = possibleTarget->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; } 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)) { - case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION: - return prepareReportingTogglingCommand(message, objectId, true, false, - tcData, tcDataLen); - case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION: - return prepareReportingTogglingCommand(message, objectId, false, false, - tcData, tcDataLen); - case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: - return prepareReportingTogglingCommand(message, objectId, true, true, - tcData, tcDataLen); - case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: - return prepareReportingTogglingCommand(message, objectId, false, true, - tcData, tcDataLen); - case Subservice::REPORT_HK_REPORT_STRUCTURES: - return prepareStructureReportingCommand(message, objectId, false, tcData, - tcDataLen); - case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES: - return prepareStructureReportingCommand(message, objectId, true, tcData, - tcDataLen); - case Subservice::GENERATE_ONE_PARAMETER_REPORT: - return prepareOneShotReportCommand(message, objectId, false, - tcData, tcDataLen); - case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT: - return prepareOneShotReportCommand(message, objectId, true, - tcData, tcDataLen); - case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL: - return prepareCollectionIntervalModificationCommand(message, objectId, - false, tcData, tcDataLen); - case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL: - return prepareCollectionIntervalModificationCommand(message, objectId, - true, tcData, tcDataLen); - case Subservice::HK_DEFINITIONS_REPORT: - case Subservice::DIAGNOSTICS_DEFINITION_REPORT: - case Subservice::HK_REPORT: - case Subservice::DIAGNOSTICS_REPORT: - // Those are telemetry packets. - return CommandingServiceBase::INVALID_TC; - default: - // should never happen, subservice was already checked. - return HasReturnvaluesIF::RETURN_FAILED; - } - return HasReturnvaluesIF::RETURN_OK; + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + uint32_t *state, object_id_t objectId) { + switch(static_cast(subservice)) { + case Subservice::ENABLE_PERIODIC_HK_REPORT_GENERATION: + return prepareReportingTogglingCommand(message, objectId, true, false, + tcData, tcDataLen); + case Subservice::DISABLE_PERIODIC_HK_REPORT_GENERATION: + return prepareReportingTogglingCommand(message, objectId, false, false, + tcData, tcDataLen); + case Subservice::ENABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: + return prepareReportingTogglingCommand(message, objectId, true, true, + tcData, tcDataLen); + case Subservice::DISABLE_PERIODIC_DIAGNOSTICS_REPORT_GENERATION: + return prepareReportingTogglingCommand(message, objectId, false, true, + tcData, tcDataLen); + case Subservice::REPORT_HK_REPORT_STRUCTURES: + return prepareStructureReportingCommand(message, objectId, false, tcData, + tcDataLen); + case Subservice::REPORT_DIAGNOSTICS_REPORT_STRUCTURES: + return prepareStructureReportingCommand(message, objectId, true, tcData, + tcDataLen); + case Subservice::GENERATE_ONE_PARAMETER_REPORT: + return prepareOneShotReportCommand(message, objectId, false, + tcData, tcDataLen); + case Subservice::GENERATE_ONE_DIAGNOSTICS_REPORT: + return prepareOneShotReportCommand(message, objectId, true, + tcData, tcDataLen); + case Subservice::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL: + return prepareCollectionIntervalModificationCommand(message, objectId, + false, tcData, tcDataLen); + case Subservice::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL: + return prepareCollectionIntervalModificationCommand(message, objectId, + true, tcData, tcDataLen); + case Subservice::HK_DEFINITIONS_REPORT: + case Subservice::DIAGNOSTICS_DEFINITION_REPORT: + case Subservice::HK_REPORT: + case Subservice::DIAGNOSTICS_REPORT: + // Those are telemetry packets. + return CommandingServiceBase::INVALID_TC; + default: + // should never happen, subservice was already checked. + return HasReturnvaluesIF::RETURN_FAILED; + } + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand( - 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; - } + 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); - return HasReturnvaluesIF::RETURN_OK; + sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); + HousekeepingMessage::setToggleReportingCommand(command, targetSid, + enableReporting, isDiagnostics); + return HasReturnvaluesIF::RETURN_OK; } 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; - } + 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); - return HasReturnvaluesIF::RETURN_OK; + sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); + HousekeepingMessage::setStructureReportingCommand(command, targetSid, + isDiagnostics); + return HasReturnvaluesIF::RETURN_OK; } 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; - } + 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); - return HasReturnvaluesIF::RETURN_OK; + sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); + HousekeepingMessage::setOneShotReportCommand(command, targetSid, + isDiagnostics); + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand( - 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 intervL. - return CommandingServiceBase::INVALID_TC; - } + 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 intervL. + 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); - return HasReturnvaluesIF::RETURN_OK; + sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen); + float newCollectionInterval = 0; + SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen, + SerializeIF::Endianness::BIG); + HousekeepingMessage::setCollectionIntervalModificationCommand(command, + targetSid, newCollectionInterval, isDiagnostics); + return HasReturnvaluesIF::RETURN_OK; } ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply, - Command_t previousCommand, uint32_t *state, - CommandMessage* optionalNextCommand, object_id_t objectId, - bool *isStep) { - Command_t command = reply->getCommand(); - switch(command) { + 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(Subservice::HK_REPORT)); - if(result != HasReturnvaluesIF::RETURN_OK) { - return result; - } - return CommandingServiceBase::EXECUTION_COMPLETE; - } + case(HousekeepingMessage::HK_REPORT): { + ReturnValue_t result = generateHkReply(reply, + static_cast(Subservice::HK_REPORT)); + if(result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return CommandingServiceBase::EXECUTION_COMPLETE; + } - case(HousekeepingMessage::DIAGNOSTICS_REPORT): { - ReturnValue_t result = generateHkReply(reply, - static_cast(Subservice::DIAGNOSTICS_REPORT)); - if(result != HasReturnvaluesIF::RETURN_OK) { - return result; - } - return CommandingServiceBase::EXECUTION_COMPLETE; - } + case(HousekeepingMessage::DIAGNOSTICS_REPORT): { + ReturnValue_t result = generateHkReply(reply, + static_cast(Subservice::DIAGNOSTICS_REPORT)); + if(result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return CommandingServiceBase::EXECUTION_COMPLETE; + } case(HousekeepingMessage::HK_DEFINITIONS_REPORT): { return generateHkReply(reply, static_cast( @@ -209,51 +209,59 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply, break; } - case(HousekeepingMessage::HK_REQUEST_SUCCESS): { - return CommandingServiceBase::EXECUTION_COMPLETE; - } + case(HousekeepingMessage::HK_REQUEST_SUCCESS): { + return CommandingServiceBase::EXECUTION_COMPLETE; + } - case(HousekeepingMessage::HK_REQUEST_FAILURE): { - failureParameter1 = objectId; - ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED; - HousekeepingMessage::getHkRequestFailureReply(reply,&error); - failureParameter2 = error; - return CommandingServiceBase::EXECUTION_COMPLETE; - } + case(HousekeepingMessage::HK_REQUEST_FAILURE): { + failureParameter1 = objectId; + ReturnValue_t error = HasReturnvaluesIF::RETURN_FAILED; + HousekeepingMessage::getHkRequestFailureReply(reply,&error); + failureParameter2 = error; + return CommandingServiceBase::EXECUTION_COMPLETE; + } - default: + default: #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::warning << "Service3Housekeeping::handleReply: Invalid reply with " - << "reply command " << command << "!" << std::endl; + sif::warning << "Service3Housekeeping::handleReply: Invalid reply with " + << "reply command " << command << "!" << std::endl; #else - sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with " - "reply command %hu!\n", command); + sif::printWarning("Service3Housekeeping::handleReply: Invalid reply with " + "reply command %hu!\n", command); #endif - return CommandingServiceBase::INVALID_REPLY; - } - return HasReturnvaluesIF::RETURN_OK; + return CommandingServiceBase::INVALID_REPLY; + } + return HasReturnvaluesIF::RETURN_OK; } void Service3Housekeeping::handleUnrequestedReply( - CommandMessage* reply) { - ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; - Command_t command = reply->getCommand(); + CommandMessage* reply) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + Command_t command = reply->getCommand(); - switch(command) { + switch(command) { - case(HousekeepingMessage::DIAGNOSTICS_REPORT): { - result = generateHkReply(reply, - static_cast(Subservice::DIAGNOSTICS_REPORT)); - break; - } + case(HousekeepingMessage::DIAGNOSTICS_REPORT): { + result = generateHkReply(reply, + static_cast(Subservice::DIAGNOSTICS_REPORT)); + break; + } - case(HousekeepingMessage::HK_REPORT): { - result = generateHkReply(reply, - static_cast(Subservice::HK_REPORT)); - break; - } + case(HousekeepingMessage::HK_REPORT): { + result = generateHkReply(reply, + static_cast(Subservice::HK_REPORT)); + break; + } - default: { + case(HousekeepingMessage::HK_REQUEST_SUCCESS): { + break; + } + + case(HousekeepingMessage::HK_REQUEST_FAILURE): { + break; + } + + default: { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply " "command " << command << "!" << std::endl; @@ -262,49 +270,49 @@ void Service3Housekeeping::handleUnrequestedReply( "reply command %hu!\n", command); #endif return; - } - } + } + } - if(result != HasReturnvaluesIF::RETURN_OK) { - /* Configuration error */ + if(result != HasReturnvaluesIF::RETURN_OK) { + /* Configuration error */ #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" << - std::endl; + sif::warning << "Service3Housekeeping::handleUnrequestedReply: Could not generate reply!" << + std::endl; #else - sif::printWarning("Service3Housekeeping::handleUnrequestedReply: " - "Could not generate reply!\n"); + sif::printWarning("Service3Housekeeping::handleUnrequestedReply: " + "Could not generate reply!\n"); #endif - } + } } MessageQueueId_t Service3Housekeeping::getHkQueue() const { - return commandQueue->getId(); + return commandQueue->getId(); } ReturnValue_t Service3Housekeeping::generateHkReply( - const CommandMessage* hkMessage, uint8_t subserviceId) { - store_address_t storeId; + const CommandMessage* hkMessage, uint8_t subserviceId) { + store_address_t storeId; - sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId); - auto resultPair = IPCStore->getData(storeId); - if(resultPair.first != HasReturnvaluesIF::RETURN_OK) { - return resultPair.first; - } + sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId); + auto resultPair = IPCStore->getData(storeId); + if(resultPair.first != HasReturnvaluesIF::RETURN_OK) { + return resultPair.first; + } - HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size()); - return sendTmPacket(static_cast(subserviceId), - hkPacket.hkData, hkPacket.hkSize, nullptr, 0); + HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size()); + return sendTmPacket(static_cast(subserviceId), + hkPacket.hkData, hkPacket.hkSize, nullptr, 0); } 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; + 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; } From 255d4a90a9861cc448a60be31e2e2f45f741d234 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 3 Feb 2021 22:23:31 +0100 Subject: [PATCH 5/8] extended controller base --- controller/CMakeLists.txt | 6 +++--- controller/ExtendedControllerBase.cpp | 3 +++ controller/ExtendedControllerBase.h | 1 + 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/controller/CMakeLists.txt b/controller/CMakeLists.txt index b7624d98..550acfcd 100644 --- a/controller/CMakeLists.txt +++ b/controller/CMakeLists.txt @@ -1,4 +1,4 @@ -target_sources(${LIB_FSFW_NAME} - PRIVATE - ControllerBase.cpp +target_sources(${LIB_FSFW_NAME} PRIVATE + ControllerBase.cpp + ExtendedControllerBase.cpp ) \ No newline at end of file diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp index 397c8c10..cc93efa8 100644 --- a/controller/ExtendedControllerBase.cpp +++ b/controller/ExtendedControllerBase.cpp @@ -8,6 +8,9 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, actionHelper(this, commandQueue) { } +ExtendedControllerBase::~ExtendedControllerBase() { +} + ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t *data, size_t size) { // needs to be overriden and implemented by child class. diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h index bcb414dd..ae59b758 100644 --- a/controller/ExtendedControllerBase.h +++ b/controller/ExtendedControllerBase.h @@ -22,6 +22,7 @@ class ExtendedControllerBase: public ControllerBase, public: ExtendedControllerBase(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 3); + virtual ~ExtendedControllerBase(); /** SystemObjectIF overrides */ virtual ReturnValue_t initialize() override; From 1829d9cf0a04b4ee9a01c3740db87a95e7568898 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 4 Feb 2021 01:31:46 +0100 Subject: [PATCH 6/8] lpid replaced by gpid --- controller/ExtendedControllerBase.h | 10 +++---- datapoollocal/HasLocalDataPoolIF.h | 2 +- datapoollocal/LocalDataPoolManager.cpp | 12 ++++---- .../ProvidesDataPoolSubscriptionIF.h | 4 +-- housekeeping/HousekeepingMessage.cpp | 30 ++++++++++++------- housekeeping/HousekeepingMessage.h | 10 ++++--- 6 files changed, 39 insertions(+), 29 deletions(-) diff --git a/controller/ExtendedControllerBase.h b/controller/ExtendedControllerBase.h index ae59b758..f069819b 100644 --- a/controller/ExtendedControllerBase.h +++ b/controller/ExtendedControllerBase.h @@ -24,12 +24,12 @@ public: size_t commandQueueDepth = 3); virtual ~ExtendedControllerBase(); - /** SystemObjectIF overrides */ + /* SystemObjectIF overrides */ virtual ReturnValue_t initialize() override; virtual MessageQueueId_t getCommandQueue() const override; - /** ExecutableObjectIF overrides */ + /* ExecutableObjectIF overrides */ virtual ReturnValue_t performOperation(uint8_t opCode) override; virtual ReturnValue_t initializeAfterTaskCreation() override; @@ -50,15 +50,15 @@ protected: */ virtual void performControlOperation() = 0; - /** Handle the four messages mentioned above */ + /* Handle the four messages mentioned above */ void handleQueue() override; - /** HasActionsIF overrides */ + /* HasActionsIF overrides */ virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, const uint8_t* data, size_t size) override; - /** HasLocalDatapoolIF overrides */ + /* HasLocalDatapoolIF overrides */ virtual LocalDataPoolManager* getHkManagerHandle() override; virtual object_id_t getObjectId() const override; virtual ReturnValue_t initializeLocalDataPool( diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h index 1d87d47c..05570175 100644 --- a/datapoollocal/HasLocalDataPoolIF.h +++ b/datapoollocal/HasLocalDataPoolIF.h @@ -80,7 +80,7 @@ public: * @param storeId If a snapshot was requested, data will be located inside * the IPC store with this store ID. */ - virtual void handleChangedPoolVariable(lp_id_t poolId, + virtual void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId = storeId::INVALID_STORE_ADDRESS) { return; } diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index 48b4a038..dd009684 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -166,7 +166,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive // prepare and send update notification. CommandMessage notification; HousekeepingMessage::setUpdateNotificationVariableCommand(¬ification, - receiver.dataId.localPoolId); + gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId)); ReturnValue_t result = hkQueue->sendMessage( receiver.destinationQueue, ¬ification); if(result != HasReturnvaluesIF::RETURN_OK) { @@ -238,7 +238,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot( CommandMessage notification; HousekeepingMessage::setUpdateSnapshotVariableCommand(¬ification, - receiver.dataId.localPoolId, storeId); + gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId), storeId); result = hkQueue->sendMessage(receiver.destinationQueue, ¬ification); if (result != HasReturnvaluesIF::RETURN_OK) { @@ -563,9 +563,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage( return HasReturnvaluesIF::RETURN_OK; } case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): { - lp_id_t locPoolId = HousekeepingMessage:: + gp_id_t globPoolId = HousekeepingMessage:: getUpdateNotificationVariableCommand(message); - owner->handleChangedPoolVariable(locPoolId); + owner->handleChangedPoolVariable(globPoolId); return HasReturnvaluesIF::RETURN_OK; } case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): { @@ -576,9 +576,9 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage( } case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): { store_address_t storeId; - lp_id_t localPoolId = HousekeepingMessage:: + gp_id_t globPoolId = HousekeepingMessage:: getUpdateSnapshotVariableCommand(message, &storeId); - owner->handleChangedPoolVariable(localPoolId, storeId); + owner->handleChangedPoolVariable(globPoolId, storeId); return HasReturnvaluesIF::RETURN_OK; } diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h index a0d73b93..4a6cdb9f 100644 --- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h +++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h @@ -38,7 +38,6 @@ public: bool isDiagnostics, object_id_t packetDestination) = 0; - /** * @brief Subscribe for a notification message which will be sent * if a dataset has changed. @@ -54,8 +53,7 @@ public: * @return */ virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId, - object_id_t destinationObject, - MessageQueueId_t targetQueueId, + object_id_t destinationObject, MessageQueueId_t targetQueueId, bool generateSnapshot) = 0; /** diff --git a/housekeeping/HousekeepingMessage.cpp b/housekeeping/HousekeepingMessage.cpp index 5d732961..d9803ef6 100644 --- a/housekeeping/HousekeepingMessage.cpp +++ b/housekeeping/HousekeepingMessage.cpp @@ -125,8 +125,10 @@ sid_t HousekeepingMessage::getSid(const CommandMessage* message) { return sid; } -void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) { - std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw)); +gp_id_t HousekeepingMessage::getGpid(const CommandMessage* message) { + gp_id_t globalPoolId; + std::memcpy(&globalPoolId.raw, message->getData(), sizeof(globalPoolId.raw)); + return globalPoolId; } void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply, @@ -169,9 +171,9 @@ void HousekeepingMessage::setUpdateNotificationSetCommand( } void HousekeepingMessage::setUpdateNotificationVariableCommand( - CommandMessage *command, lp_id_t localPoolId) { + CommandMessage *command, gp_id_t globalPoolId) { command->setCommand(UPDATE_NOTIFICATION_VARIABLE); - command->setParameter(localPoolId); + setGpid(command, globalPoolId); } void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command, @@ -182,9 +184,9 @@ void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command, } void HousekeepingMessage::setUpdateSnapshotVariableCommand( - CommandMessage *command, lp_id_t localPoolId, store_address_t storeId) { + CommandMessage *command, gp_id_t globalPoolId, store_address_t storeId) { command->setCommand(UPDATE_SNAPSHOT_VARIABLE); - command->setParameter(localPoolId); + setGpid(command, globalPoolId); command->setParameter3(storeId.raw); } @@ -193,9 +195,9 @@ sid_t HousekeepingMessage::getUpdateNotificationSetCommand( return getSid(command); } -lp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand( +gp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand( const CommandMessage *command) { - return command->getParameter(); + return getGpid(command); } sid_t HousekeepingMessage::getUpdateSnapshotSetCommand( @@ -206,10 +208,18 @@ sid_t HousekeepingMessage::getUpdateSnapshotSetCommand( return getSid(command); } -lp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand( +gp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand( const CommandMessage *command, store_address_t *storeId) { if(storeId != nullptr) { *storeId = command->getParameter3(); } - return command->getParameter(); + return getGpid(command); +} + +void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) { + std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw)); +} + +void HousekeepingMessage::setGpid(CommandMessage *message, gp_id_t globalPoolId) { + std::memcpy(message->getData(), &globalPoolId.raw, sizeof(globalPoolId.raw)); } diff --git a/housekeeping/HousekeepingMessage.h b/housekeeping/HousekeepingMessage.h index 0c7680dc..a38ff73f 100644 --- a/housekeeping/HousekeepingMessage.h +++ b/housekeeping/HousekeepingMessage.h @@ -75,6 +75,7 @@ public: //static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134); static sid_t getSid(const CommandMessage* message); + static gp_id_t getGpid(const CommandMessage* message); /* Housekeeping Interface Messages */ @@ -123,26 +124,27 @@ public: static void setUpdateNotificationSetCommand(CommandMessage* command, sid_t sid); static void setUpdateNotificationVariableCommand(CommandMessage* command, - lp_id_t localPoolId); + gp_id_t globalPoolId); static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid, store_address_t storeId); static void setUpdateSnapshotVariableCommand(CommandMessage* command, - lp_id_t localPoolId, store_address_t storeId); + gp_id_t globalPoolId, store_address_t storeId); static sid_t getUpdateNotificationSetCommand(const CommandMessage* command); - static lp_id_t getUpdateNotificationVariableCommand( + static gp_id_t getUpdateNotificationVariableCommand( const CommandMessage* command); static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command, store_address_t* storeId); - static lp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command, + static gp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command, store_address_t* storeId); /** Utility */ static void clear(CommandMessage* message); private: static void setSid(CommandMessage* message, sid_t sid); + static void setGpid(CommandMessage* message, gp_id_t globalPoolId); }; From 6be6d593a32476fb811eeee983ae7ea61fe5c36c Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 4 Feb 2021 13:46:27 +0100 Subject: [PATCH 7/8] minor tweaks --- datapoollocal/LocalDataPoolManager.cpp | 8 ++++++-- datapoollocal/LocalPoolDataSetBase.cpp | 1 + devicehandlers/DeviceHandlerBase.cpp | 17 +++++++---------- osal/host/QueueMapManager.cpp | 23 ++++++++++++++--------- osal/host/QueueMapManager.h | 2 +- 5 files changed, 29 insertions(+), 22 deletions(-) diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index dd009684..e13337da 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -881,6 +881,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, } if(outputType == sif::OutputTypes::OUT_WARNING) { +#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8) << std::setfill('0') @@ -889,9 +890,11 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, #else sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, owner->getObjectId(), errorPrint); -#endif +#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */ +#endif /* FSFW_VERBOSE_LEVEL >= 1 */ } else if(outputType == sif::OutputTypes::OUT_ERROR) { +#if FSFW_VERBOSE_LEVEL >= 1 #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8) << std::setfill('0') @@ -900,7 +903,8 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType, #else sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, owner->getObjectId(), errorPrint); -#endif +#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */ +#endif /* FSFW_VERBOSE_LEVEL >= 1 */ } } diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp index d5c0556c..00293645 100644 --- a/datapoollocal/LocalPoolDataSetBase.cpp +++ b/datapoollocal/LocalPoolDataSetBase.cpp @@ -51,6 +51,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner); if(accessor != nullptr) { mutexIfSingleDataCreator = accessor->getLocalPoolMutex(); + poolManager = accessor->getPoolManagerHandle(); } } diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp index a1ad9548..35d34bf9 100644 --- a/devicehandlers/DeviceHandlerBase.cpp +++ b/devicehandlers/DeviceHandlerBase.cpp @@ -435,8 +435,7 @@ ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId, } } -ReturnValue_t DeviceHandlerBase::insertInCommandMap( - DeviceCommandId_t deviceCommand) { +ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceCommand) { DeviceCommandInfo info; info.expectedReplies = 0; info.isExecuting = false; @@ -701,13 +700,11 @@ void DeviceHandlerBase::parseReply(const uint8_t* receivedData, ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; DeviceCommandId_t foundId = DeviceHandlerIF::NO_COMMAND_ID; size_t foundLen = 0; - // The loop may not execute more often than the number of received bytes - // (worst case). This approach avoids infinite loops due to buggy - // scanForReply routines. + /* The loop may not execute more often than the number of received bytes + (worst case). This approach avoids infinite loops due to buggy scanForReply routines. */ uint32_t remainingLength = receivedDataLen; for (uint32_t count = 0; count < receivedDataLen; count++) { - result = scanForReply(receivedData, remainingLength, &foundId, - &foundLen); + result = scanForReply(receivedData, remainingLength, &foundId, &foundLen); switch (result) { case RETURN_OK: handleReply(receivedData, foundId, foundLen); @@ -790,9 +787,9 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData, replyToReply(iter, result); } else { - // Other completion failure messages are created by timeout. - // Powering down the device might take some time during which periodic - // replies may still come in. + /* Other completion failure messages are created by timeout. + Powering down the device might take some time during which periodic + replies may still come in. */ if (mode != _MODE_WAIT_OFF) { triggerEvent(DEVICE_UNREQUESTED_REPLY, foundId); } diff --git a/osal/host/QueueMapManager.cpp b/osal/host/QueueMapManager.cpp index 7ffd4758..9fb8b7a3 100644 --- a/osal/host/QueueMapManager.cpp +++ b/osal/host/QueueMapManager.cpp @@ -18,17 +18,19 @@ QueueMapManager* QueueMapManager::instance() { ReturnValue_t QueueMapManager::addMessageQueue( MessageQueueIF* queueToInsert, MessageQueueId_t* id) { - // Not thread-safe, but it is assumed all message queues are created - // at software initialization now. If this is to be made thread-safe in - // the future, it propably would be sufficient to lock the increment - // operation here + /* Not thread-safe, but it is assumed all message queues are created at software initialization + now. If this is to be made thread-safe in the future, it propably would be sufficient to lock + the increment operation here. */ uint32_t currentId = queueCounter++; auto returnPair = queueMap.emplace(currentId, queueToInsert); if(not returnPair.second) { - // this should never happen for the atomic variable. + /* This should never happen for the atomic variable. */ #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::error << "QueueMapManager: This ID is already inside the map!" - << std::endl; + sif::error << "QueueMapManager::addMessageQueue This ID is already " + "inside the map!" << std::endl; +#else + sif::printError("QueueMapManager::addMessageQueue This ID is already " + "inside the map!\n"); #endif return HasReturnvaluesIF::RETURN_FAILED; } @@ -47,8 +49,11 @@ MessageQueueIF* QueueMapManager::getMessageQueue( } else { #if FSFW_CPP_OSTREAM_ENABLED == 1 - sif::warning << "QueueMapManager::getQueueHandle: The ID " << - messageQueueId << " does not exists in the map" << std::endl; + sif::warning << "QueueMapManager::getQueueHandle: The ID " << messageQueueId << + " does not exists in the map!" << std::endl; +#else + sif::printWarning("QueueMapManager::getQueueHandle: The ID %d does not exist in the map!\n", + messageQueueId); #endif return nullptr; } diff --git a/osal/host/QueueMapManager.h b/osal/host/QueueMapManager.h index d7d5c915..3610ca63 100644 --- a/osal/host/QueueMapManager.h +++ b/osal/host/QueueMapManager.h @@ -36,7 +36,7 @@ public: private: //! External instantiation is forbidden. QueueMapManager(); - uint32_t queueCounter = 1; + uint32_t queueCounter = 0; MutexIF* mapLock; QueueMap queueMap; static QueueMapManager* mqManagerInstance; From 3bd7ba961ea0980d081bd7f82d93c9e2fafac2ac Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 4 Feb 2021 15:04:52 +0100 Subject: [PATCH 8/8] just form stuff --- datapoollocal/LocalDataPoolManager.cpp | 56 ++++++++----------- .../ProvidesDataPoolSubscriptionIF.h | 24 ++++---- 2 files changed, 36 insertions(+), 44 deletions(-) diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index e13337da..44769163 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -102,7 +102,7 @@ ReturnValue_t LocalDataPoolManager::performHkOperation() { switch(receiver.reportingType) { case(ReportingType::PERIODIC): { if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) { - // Periodic packets shall only be generated from datasets. + /* Periodic packets shall only be generated from datasets */ continue; } performPeriodicHkGeneration(receiver); @@ -156,19 +156,17 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) { LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId); - //LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId); if(poolObj == nullptr) { printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate", POOLOBJECT_NOT_FOUND); return POOLOBJECT_NOT_FOUND; } if(poolObj->hasChanged()) { - // prepare and send update notification. + /* Prepare and send update notification. */ CommandMessage notification; HousekeepingMessage::setUpdateNotificationVariableCommand(¬ification, - gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId)); - ReturnValue_t result = hkQueue->sendMessage( - receiver.destinationQueue, ¬ification); + gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId)); + ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, ¬ification); if(result != HasReturnvaluesIF::RETURN_OK) { status = result; } @@ -185,10 +183,10 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive return DATASET_NOT_FOUND; } if(dataSet->hasChanged()) { - // prepare and send update notification + /* Prepare and send update notification */ CommandMessage notification; - HousekeepingMessage::setUpdateNotificationSetCommand( - ¬ification, receiver.dataId.sid); + HousekeepingMessage::setUpdateNotificationSetCommand(¬ification, + receiver.dataId.sid); ReturnValue_t result = hkQueue->sendMessage( receiver.destinationQueue, ¬ification); if(result != HasReturnvaluesIF::RETURN_OK) { @@ -198,8 +196,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive } } if(toReset != nullptr) { - handleChangeResetLogic(receiver.dataType, - receiver.dataId, toReset); + handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset); } return HasReturnvaluesIF::RETURN_OK; } @@ -207,7 +204,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receive ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot( HkReceiver& receiver, ReturnValue_t& status) { MarkChangedIF* toReset = nullptr; - // check whether data has changed and send messages in case it has. + /* Check whether data has changed and send messages in case it has */ if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) { LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId); @@ -221,14 +218,14 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot( return HasReturnvaluesIF::RETURN_OK; } - // prepare and send update snapshot. + /* Prepare and send update snapshot */ timeval now; Clock::getClock_timeval(&now); CCSDSTime::CDS_short cds; CCSDSTime::convertToCcsds(&cds, &now); - HousekeepingSnapshot updatePacket(reinterpret_cast(&cds), - sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, - receiver.dataId.localPoolId)); + HousekeepingSnapshot updatePacket(reinterpret_cast(&cds), sizeof(cds), + HasLocalDpIFManagerAttorney::getPoolObjectHandle( + owner,receiver.dataId.localPoolId)); store_address_t storeId; ReturnValue_t result = addUpdateToStore(updatePacket, storeId); @@ -259,7 +256,7 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot( return HasReturnvaluesIF::RETURN_OK; } - // prepare and send update snapshot. + /* Prepare and send update snapshot */ timeval now; Clock::getClock_timeval(&now); CCSDSTime::CDS_short cds; @@ -309,7 +306,7 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore( void LocalDataPoolManager::handleChangeResetLogic( DataType type, DataId dataId, MarkChangedIF* toReset) { if(hkUpdateResetList == nullptr) { - // config error! + /* Config error */ return; } HkUpdateResetList& listRef = *hkUpdateResetList; @@ -326,16 +323,16 @@ void LocalDataPoolManager::handleChangeResetLogic( continue; } - // only one update recipient, we can reset changes status immediately. + /* Only one update recipient, we can reset changes status immediately */ if(changeInfo.updateCounter <= 1) { toReset->setChanged(false); } - // All recipients have been notified, reset the changed flag. + /* All recipients have been notified, reset the changed flag */ if(changeInfo.currentUpdateCounter <= 1) { toReset->setChanged(false); changeInfo.currentUpdateCounter = 0; } - // Not all recipiens have been notified yet, decrement. + /* Not all recipiens have been notified yet, decrement */ else { changeInfo.currentUpdateCounter--; } @@ -371,7 +368,6 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, hkReceiver.destinationQueue = hkReceiverObject->getHkQueue(); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); - //LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid); if(dataSet != nullptr) { LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting); LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics); @@ -557,14 +553,13 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage( dataSet, true); } - // Notification handling. + /* Notification handling */ case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): { owner->handleChangedDataset(sid); return HasReturnvaluesIF::RETURN_OK; } case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): { - gp_id_t globPoolId = HousekeepingMessage:: - getUpdateNotificationVariableCommand(message); + gp_id_t globPoolId = HousekeepingMessage::getUpdateNotificationVariableCommand(message); owner->handleChangedPoolVariable(globPoolId); return HasReturnvaluesIF::RETURN_OK; } @@ -576,8 +571,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage( } case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): { store_address_t storeId; - gp_id_t globPoolId = HousekeepingMessage:: - getUpdateSnapshotVariableCommand(message, &storeId); + gp_id_t globPoolId = HousekeepingMessage::getUpdateSnapshotVariableCommand(message, + &storeId); owner->handleChangedPoolVariable(globPoolId, storeId); return HasReturnvaluesIF::RETURN_OK; } @@ -693,7 +688,6 @@ void LocalDataPoolManager::setNonDiagnosticIntervalFactor( void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { sid_t sid = receiver.dataId.sid; - //LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); if(dataSet == nullptr) { printWarningOrError(sif::OutputTypes::OUT_WARNING, @@ -710,7 +704,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet); if(periodicHelper == nullptr) { - // Configuration error. + /* Configuration error */ return; } @@ -721,7 +715,7 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { ReturnValue_t result = generateHousekeepingPacket( sid, dataSet, true); if(result != HasReturnvaluesIF::RETURN_OK) { - // configuration error + /* Configuration error */ #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "LocalDataPoolManager::performHkOperation: HK generation failed." << std::endl; @@ -734,7 +728,6 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) { ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool enable, bool isDiagnostics) { - //LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or (not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) { @@ -752,7 +745,6 @@ ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, float newCollectionInterval, bool isDiagnostics) { - //LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid); LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid); bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet); if((targetIsDiagnostics and not isDiagnostics) or diff --git a/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/datapoollocal/ProvidesDataPoolSubscriptionIF.h index 4a6cdb9f..ead479cc 100644 --- a/datapoollocal/ProvidesDataPoolSubscriptionIF.h +++ b/datapoollocal/ProvidesDataPoolSubscriptionIF.h @@ -44,12 +44,12 @@ public: * @details * This subscription mechanism will generally be used internally by * other software components. - * @param setId Set ID of the set to receive update messages from. - * @param destinationObject - * @param targetQueueId - * @param generateSnapshot If this is set to true, a copy of the current - * data with a timestamp will be generated and sent via message. - * Otherwise, only an notification message is sent. + * @param setId Set ID of the set to receive update messages from. + * @param destinationObject Object ID of the receiver. + * @param targetQueueId Receiver queue ID + * @param generateSnapshot If this is set to true, a copy of the current data with a + * timestamp will be generated and sent via message. + * Otherwise, only an notification message is sent. * @return */ virtual ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId, @@ -62,12 +62,12 @@ public: * @details * This subscription mechanism will generally be used internally by * other software components. - * @param localPoolId Pool ID of the pool variable - * @param destinationObject - * @param targetQueueId - * @param generateSnapshot If this is set to true, a copy of the current - * data with a timestamp will be generated and sent via message. - * Otherwise, only an notification message is sent. + * @param localPoolId Pool ID of the pool variable + * @param destinationObject Object ID of the receiver + * @param targetQueueId Receiver queue ID + * @param generateSnapshot If this is set to true, a copy of the current data with a + * timestamp will be generated and sent via message. Otherwise, + * only an notification message is sent. * @return */ virtual ReturnValue_t subscribeForVariableUpdateMessages(