From 6b2b788308bef172e6a83c46a44ea20bf3106f41 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Fri, 10 Jul 2020 14:16:55 +0200 Subject: [PATCH 01/12] added new pus services --- framework.mk | 13 +- pus/CService200ModeCommanding.cpp | 119 +++++++++++++++++ pus/CService200ModeCommanding.h | 85 ++++++++++++ pus/Service1TelecommandVerification.cpp | 100 ++++++++++++++ pus/Service1TelecommandVerification.h | 94 +++++++++++++ pus/Service2DeviceAccess.cpp | 167 ++++++++++++++++++++++++ pus/Service2DeviceAccess.h | 92 +++++++++++++ pus/Service5EventReporting.cpp | 91 +++++++++++++ pus/Service5EventReporting.h | 86 ++++++++++++ pus/Service8FunctionManagement.cpp | 135 +++++++++++++++++++ pus/Service8FunctionManagement.h | 67 ++++++++++ pus/servicepackets/Service1Packets.h | 166 +++++++++++++++++++++++ pus/servicepackets/Service200Packets.h | 63 +++++++++ pus/servicepackets/Service2Packets.h | 76 +++++++++++ pus/servicepackets/Service5Packets.h | 76 +++++++++++ pus/servicepackets/Service8Packets.h | 136 +++++++++++++++++++ 16 files changed, 1562 insertions(+), 4 deletions(-) create mode 100644 pus/CService200ModeCommanding.cpp create mode 100644 pus/CService200ModeCommanding.h create mode 100644 pus/Service1TelecommandVerification.cpp create mode 100644 pus/Service1TelecommandVerification.h create mode 100644 pus/Service2DeviceAccess.cpp create mode 100644 pus/Service2DeviceAccess.h create mode 100644 pus/Service5EventReporting.cpp create mode 100644 pus/Service5EventReporting.h create mode 100644 pus/Service8FunctionManagement.cpp create mode 100644 pus/Service8FunctionManagement.h create mode 100644 pus/servicepackets/Service1Packets.h create mode 100644 pus/servicepackets/Service200Packets.h create mode 100644 pus/servicepackets/Service2Packets.h create mode 100644 pus/servicepackets/Service5Packets.h create mode 100644 pus/servicepackets/Service8Packets.h diff --git a/framework.mk b/framework.mk index a5a65364..5db96b5b 100644 --- a/framework.mk +++ b/framework.mk @@ -1,5 +1,5 @@ -# This file needs FRAMEWORK_PATH and API set correctly -# Valid API settings: rtems, linux, freeRTOS +# This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile. +# Valid API settings: rtems, linux, freeRTOS, host CXXSRC += $(wildcard $(FRAMEWORK_PATH)/action/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/container/*.cpp) @@ -8,11 +8,13 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp) +CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp) +CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp) +CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/fdir/*.cpp) -CXXSRC += $(wildcard $(FRAMEWORK_PATH)/framework.mk/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/matching/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/math/*.cpp) @@ -32,8 +34,10 @@ else ifeq ($(OS),linux) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp) else ifeq ($(OS),freeRTOS) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp) +else ifeq ($(OS),host) +CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp) else -$(error invalid OS specified, valid OS are rtems, linux, freeRTOS) +$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host) endif CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp) @@ -54,3 +58,4 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp) +CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp) diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp new file mode 100644 index 00000000..fd6da67e --- /dev/null +++ b/pus/CService200ModeCommanding.cpp @@ -0,0 +1,119 @@ +#include +#include + +#include +#include +#include +#include + +CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId, + uint16_t apid, uint8_t serviceId): + CommandingServiceBase(objectId, apid, serviceId, + NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {} + +CService200ModeCommanding::~CService200ModeCommanding() {} + +ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) { + switch(subservice) { + case(Subservice::COMMAND_MODE_COMMAND): + case(Subservice::COMMAND_MODE_READ): + case(Subservice::COMMAND_MODE_ANNCOUNCE): + return RETURN_OK; + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + + +ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject( + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + MessageQueueId_t *id, object_id_t *objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, + SerializeIF::Endianness::BIG); + + return checkInterfaceAndAcquireMessageQueue(id,objectId); +} + +ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { + HasModesIF * destination = objectManager->get(*objectId); + if(destination == nullptr) { + return CommandingServiceBase::INVALID_OBJECT; + + } + + *messageQueueToSet = destination->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t CService200ModeCommanding::prepareCommand( + CommandMessage* message,uint8_t subservice, const uint8_t *tcData, + size_t tcDataLen, uint32_t *state, object_id_t objectId) { + ModePacket modeCommandPacket; + ReturnValue_t result = modeCommandPacket.deSerialize(&tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + return result; + } + + ModeMessage::setModeMessage(dynamic_cast(message), + ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(), + modeCommandPacket.getSubmode()); + return result; +} + + +ReturnValue_t CService200ModeCommanding::handleReply( + const CommandMessage* reply, Command_t previousCommand, + uint32_t *state, CommandMessage* optionalNextCommand, + object_id_t objectId, bool *isStep) { + Command_t replyId = reply->getCommand(); + ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; + switch(replyId) { + case(ModeMessage::REPLY_MODE_REPLY): { + result = prepareModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_WRONG_MODE_REPLY): { + result = prepareWrongModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_CANT_REACH_MODE): { + result = prepareCantReachModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_MODE_INFO): + result = INVALID_REPLY; + break; + default: + result = RETURN_FAILED; + } + return result; +} + +ReturnValue_t CService200ModeCommanding::prepareModeReply( + const CommandMessage *reply, object_id_t objectId) { + ModePacket modeReplyPacket(objectId, + ModeMessage::getMode(reply), + ModeMessage::getSubmode(reply)); + return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket); +} + +ReturnValue_t CService200ModeCommanding::prepareWrongModeReply( + const CommandMessage *reply, object_id_t objectId) { + ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), + ModeMessage::getSubmode(reply)); + return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply); +} + +ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply( + const CommandMessage *reply, object_id_t objectId) { + CantReachModePacket cantReachModePacket(objectId, + ModeMessage::getCantReachModeReason(reply)); + return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, + &cantReachModePacket); +} diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h new file mode 100644 index 00000000..ede61a84 --- /dev/null +++ b/pus/CService200ModeCommanding.h @@ -0,0 +1,85 @@ +#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ +#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ + +#include + +/** + * @brief Custom PUS service to set mode of all objects implementing HasModesIF + * + * Examples: Device Handlers, Assemblies or Subsystems. + * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A + * Dissertation Baetz p. 115, 116, 165-167. + * + * This is a gateway service. It relays device commands using the software bus. + * @ingroup pus_services + */ +class CService200ModeCommanding: public CommandingServiceBase { +public: + static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4; + static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60; + + CService200ModeCommanding(object_id_t objectId, + uint16_t apid, uint8_t serviceId); + virtual~ CService200ModeCommanding(); + +protected: + //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + uint32_t *state, object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + +private: + ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet, + const uint8_t* tcData, uint32_t tcDataLen); + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* MessageQueueToSet, object_id_t* objectId); + + ReturnValue_t prepareModeReply(const CommandMessage *reply, + object_id_t objectId); + ReturnValue_t prepareWrongModeReply(const CommandMessage *reply, + object_id_t objectId); + ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply, + object_id_t objectId); + + enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices + //!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode + COMMAND_MODE_COMMAND = 1, + //!< [EXPORT] : [COMMAND] Command to set the specified Mode, + //! regardless of external control flag + COMMAND_MODE_COMMAND_FORCED = 2, + //!< [EXPORT] : [COMMAND] Read the current mode and + //! reply with a REPLY_MODE_REPLY + COMMAND_MODE_READ = 3, + //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event. + //! This command does NOT have a reply + COMMAND_MODE_ANNCOUNCE = 4, + //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this + //! command to every child. This command does NOT have a reply. + COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5, + //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ + REPLY_MODE_REPLY = 6, + //!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed. + REPLY_CANT_REACH_MODE = 7, + //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a + //! mode was commanded and a transition started but was aborted, + //! the parameters contain the mode that was reached + REPLY_WRONG_MODE_REPLY = 8 + }; + + enum modeParameters { + MODE_OFF = 0, + MODE_ON = 1, + MODE_NORMAL = 2, + MODE_RAW = 3 + }; +}; + +#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */ diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp new file mode 100644 index 00000000..4ce2ce54 --- /dev/null +++ b/pus/Service1TelecommandVerification.cpp @@ -0,0 +1,100 @@ +#include +#include + +#include +#include +#include +#include +#include +#include + + +Service1TelecommandVerification::Service1TelecommandVerification( + object_id_t objectId, uint16_t apid, uint8_t serviceId, + object_id_t targetDestination): + SystemObject(objectId), apid(apid), serviceId(serviceId), + targetDestination(targetDestination) { + tmQueue = QueueFactory::instance()->createMessageQueue(); +} + +Service1TelecommandVerification::~Service1TelecommandVerification() {} + +MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){ + return tmQueue->getId(); +} + + +ReturnValue_t Service1TelecommandVerification::performOperation( + uint8_t operationCode){ + PusVerificationMessage message; + ReturnValue_t status = tmQueue->receiveMessage(&message); + while(status == HasReturnvaluesIF::RETURN_OK) { + status = sendVerificationReport(&message); + if(status != HasReturnvaluesIF::RETURN_OK) { + return status; + } + status = tmQueue->receiveMessage(&message); + } + if (status == MessageQueueIF::EMPTY) { + return HasReturnvaluesIF::RETURN_OK; + } + else { + return status; + } +} + + +ReturnValue_t Service1TelecommandVerification::sendVerificationReport( + PusVerificationMessage* message) { + ReturnValue_t result; + if(message->getReportId() % 2 == 0) { + result = generateFailureReport(message); + } else { + result = generateSuccessReport(message); + } + if(result != HasReturnvaluesIF::RETURN_OK){ + sif::error << "Service1TelecommandVerification::initialize: " + "Sending verification packet failed !" << std::endl; + } + return result; +} + +ReturnValue_t Service1TelecommandVerification::generateFailureReport( + PusVerificationMessage *message) { + FailureReport report( + message->getReportId(), message->getTcPacketId(), + message->getTcSequenceControl(), message->getStep(), + message->getErrorCode(), message->getParameter1(), + message->getParameter2()); + TmPacketStored tmPacket(apid, serviceId, message->getReportId(), + packetSubCounter++, &report); + ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), + tmQueue->getId()); + return result; +} + +ReturnValue_t Service1TelecommandVerification::generateSuccessReport( + PusVerificationMessage *message) { + SuccessReport report(message->getReportId(),message->getTcPacketId(), + message->getTcSequenceControl(),message->getStep()); + TmPacketStored tmPacket(apid, serviceId, message->getReportId(), + packetSubCounter++, &report); + ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), + tmQueue->getId()); + return result; +} + + +ReturnValue_t Service1TelecommandVerification::initialize() { + // Get target object for TC verification messages + AcceptsTelemetryIF* funnel = objectManager-> + get(targetDestination); + if(funnel == nullptr){ + sif::error << "Service1TelecommandVerification::initialize: Specified" + " TM funnel invalid. Make sure it is set up and implements" + " AcceptsTelemetryIF." << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; + } + tmQueue->setDefaultDestination(funnel->getReportReceptionQueue()); + return SystemObject::initialize(); +} diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h new file mode 100644 index 00000000..1d4b6719 --- /dev/null +++ b/pus/Service1TelecommandVerification.h @@ -0,0 +1,94 @@ +#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ +#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ + +#include +#include +#include +#include +#include +#include + +/** + * @brief Verify TC acceptance, start, progress and execution. + * + * Full Documentation: ECSS-E70-41A p.51 + * + * The telecommand verification service provides the capability for + * explicit verification of each distinct stage of execution of a telecommand + * packet, from on-board acceptance through to completion of execution. + * + * Minimum capabilities of this service: + * + * - TM[1,1]: Telecommand Acceptance Report - Success. + * - TM[1,2]: Telecommand Acceptance Report - Failure. + * + * Additional capabilities of this service: + * + * - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4). + * - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3). + * - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6). + * - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5). + * - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8). + * - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7). + * + * This Service is not inherited from PUSServiceBase unlike other PUS Services + * because all services implementing PUSServiceBase use this service to + * generate verification reports. + * @ingroup pus_services + */ +class Service1TelecommandVerification: public AcceptsVerifyMessageIF, + public SystemObject, + public ExecutableObjectIF, + public HasReturnvaluesIF { +public: + static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1; + + Service1TelecommandVerification(object_id_t objectId, + uint16_t apid, uint8_t serviceId, object_id_t targetDestination); + virtual ~Service1TelecommandVerification(); + + /** + * + * @return ID of Verification Queue + */ + virtual MessageQueueId_t getVerificationQueue(); + + /** + * Performs the service periodically as specified in init_mission(). + * Triggers the handlePacket function to send TC verification messages + * @param operationCode + * @return + */ + ReturnValue_t performOperation(uint8_t operationCode = 0) override; + + /** + * Initializes the destination for TC verification messages and initializes + * Service 1 as a system object + * @return + */ + ReturnValue_t initialize() override; +private: + uint16_t apid = 0; + uint8_t serviceId = 0; + + object_id_t targetDestination = objects::NO_OBJECT; + + ReturnValue_t sendVerificationReport(PusVerificationMessage* message); + ReturnValue_t generateFailureReport(PusVerificationMessage* message); + ReturnValue_t generateSuccessReport(PusVerificationMessage* message); + + uint16_t packetSubCounter = 0; + + MessageQueueIF* tmQueue = nullptr; + + enum class Subservice: uint8_t { + VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM] + VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM] + VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM] + VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM] + VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM] + VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM] + }; +}; + +#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */ diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp new file mode 100644 index 00000000..1d5f21eb --- /dev/null +++ b/pus/Service2DeviceAccess.cpp @@ -0,0 +1,167 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId, + uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands, + uint16_t commandTimeoutSeconds): + CommandingServiceBase(objectId, apid, serviceId, + numberOfParallelCommands, commandTimeoutSeconds) {} + +Service2DeviceAccess::~Service2DeviceAccess() {} + + +ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) { + switch(static_cast(subservice)){ + case Subservice::RAW_COMMANDING: + case Subservice::TOGGLE_WIRETAPPING: + return HasReturnvaluesIF::RETURN_OK; + default: + sif::error << "Invalid Subservice" << std::endl; + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + +ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject( + uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, + MessageQueueId_t* id, object_id_t* objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + + ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId); + return result; +} + +ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t * messageQueueToSet, object_id_t *objectId) { + DeviceHandlerIF* possibleTarget = + objectManager->get(*objectId); + if(possibleTarget == nullptr) { + return CommandingServiceBase::INVALID_OBJECT; + } + *messageQueueToSet = possibleTarget->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t Service2DeviceAccess::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::RAW_COMMANDING: { + return prepareRawCommand(dynamic_cast(message), + tcData, tcDataLen); + } + break; + case Subservice::TOGGLE_WIRETAPPING: { + return prepareWiretappingCommand(dynamic_cast(message), + tcData, tcDataLen); + } + break; + default: + return HasReturnvaluesIF::RETURN_FAILED; + } +} + +ReturnValue_t Service2DeviceAccess::prepareRawCommand( + CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) { + RawCommand RawCommand(tcData,tcDataLen); + // store command into the Inter Process Communication Store + store_address_t storeAddress; + ReturnValue_t result = IPCStore->addData(&storeAddress, + RawCommand.getCommand(), RawCommand.getCommandSize()); + DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, + storeAddress); + return result; +} + +ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand( + CommandMessage *messageToSet, const uint8_t *tcData, + size_t tcDataLen) { + if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) { + return CommandingServiceBase::INVALID_TC; + } + WiretappingToggle command; + ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen, + SerializeIF::Endianness::BIG); + DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet, + command.getWiretappingMode()); + return result; +} + + +ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t* state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool* isStep) { + switch(reply->getCommand()) { + case CommandMessage::REPLY_COMMAND_OK: + return HasReturnvaluesIF::RETURN_OK; + case CommandMessage::REPLY_REJECTED: + return reply->getReplyRejectedReason(); + default: + return CommandingServiceBase::INVALID_REPLY; + } +} + +// All device handlers set service 2 as default raw receiver for wiretapping +// so we have to handle those unrequested messages. +void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) { + switch(reply->getCommand()) { + case DeviceHandlerMessage::REPLY_RAW_COMMAND: + sendWiretappingTm(reply, + static_cast(Subservice::WIRETAPPING_RAW_TC)); + break; + case DeviceHandlerMessage::REPLY_RAW_REPLY: + sendWiretappingTm(reply, + static_cast(Subservice::RAW_REPLY)); + break; + default: + sif::error << "Unknown message in Service2DeviceAccess::" + "handleUnrequestedReply with command ID " << + reply->getCommand() << std::endl; + break; + } + //Must be reached by all cases to clear message + reply->clear(); +} + +void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply, + uint8_t subservice) { + // Raw Wiretapping + // Get Address of Data from Message + store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply); + const uint8_t* data = nullptr; + size_t size = 0; + ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size); + if(result != HasReturnvaluesIF::RETURN_OK){ + sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in " + "handleUnrequestedReply with failure ID "<< result + << std::endl; + return; + } + + // Init our dummy packet and correct endianness of object ID before + // sending it back. + WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), + data); + TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId); + sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast( + &TmPacket.objectId), sizeof(TmPacket.objectId)); +} + +MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { + return commandQueue->getId(); +} + diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h new file mode 100644 index 00000000..1a0bede0 --- /dev/null +++ b/pus/Service2DeviceAccess.h @@ -0,0 +1,92 @@ +#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ +#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ + +#include +#include +#include + +/** + * @brief Raw Commanding and Wiretapping of devices. + * @details + * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A + * Dissertation Baetz p. 115, 116, 165-167. + * + * This service provides the capability to communicate with devices in their + * native protocols with raw commands through the DeviceHandlerIF. + * + * This is a gateway service. It relays device commands to the software bus. + * This service is very closely tied to the CommandingServiceBase + * template class. + * + * There are 4 adaption points for component implementation through the + * CommandingServiceBase. + * + * This service employs custom subservices exclusively. This includes a + * wiretapping subservice to monitor all traffic between target devices and + * this service. + * + * - TC[2,128]: Raw Commanding + * - TC[2,129]: Toggle Wiretapping + * - TM[2,130]: Wiretapping Packet TM + * - TM[2,131]: Wiretapping Packet TC + * @ingroup pus_services + */ +class Service2DeviceAccess : public CommandingServiceBase, + public AcceptsDeviceResponsesIF +{ +public: + Service2DeviceAccess(object_id_t objectId, uint16_t apid, + uint8_t serviceId, uint8_t numberOfParallelCommands = 4, + uint16_t commandTimeoutSeconds = 60); + virtual ~Service2DeviceAccess(); + +protected: + //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, uint32_t *state, + object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + + /** + * @brief Generates TM packets containing either the TC wiretapping + * packets or the TM wiretapping packets. + * Note that for service 2, all telemetry will be treated as an + * unrequested reply regardless of wiretapping mode. + * @param reply + */ + void handleUnrequestedReply(CommandMessage* reply) override; + + MessageQueueId_t getDeviceQueue() override; +private: + /** + * Generates TM packets for Wiretapping Service + * @param reply + * @param subservice + */ + void sendWiretappingTm(CommandMessage* reply,uint8_t subservice); + + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId); + + ReturnValue_t prepareRawCommand(CommandMessage* messageToSet, + const uint8_t* tcData, size_t tcDataLen); + ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet, + const uint8_t* tcData, size_t tcDataLen); + + enum class Subservice { + RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol + TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication + RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device + WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler + }; +}; + + +#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */ diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp new file mode 100644 index 00000000..1dfbe229 --- /dev/null +++ b/pus/Service5EventReporting.cpp @@ -0,0 +1,91 @@ +#include +#include + +#include +#include +#include +#include + + +Service5EventReporting::Service5EventReporting(object_id_t objectId, + uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle): + PusServiceBase(objectId, apid, serviceId), + maxNumberReportsPerCycle(maxNumberReportsPerCycle) { + eventQueue = QueueFactory::instance()->createMessageQueue(); +} + +Service5EventReporting::~Service5EventReporting(){} + +ReturnValue_t Service5EventReporting::performService() { + EventMessage message; + ReturnValue_t status = RETURN_OK; + for(uint8_t counter = 0; + counter < maxNumberReportsPerCycle; + counter++) + { + // Receive messages even if reporting is disabled for now. + status = eventQueue->receiveMessage(&message); + if(status == MessageQueueIF::EMPTY) { + return HasReturnvaluesIF::RETURN_OK; + } + + if(enableEventReport) { + status = generateEventReport(message); + if(status != HasReturnvaluesIF::RETURN_OK) { + return status; + } + } + } + sif::debug << "Service5EventReporting::generateEventReport:" + " Too many events" << std::endl; + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t Service5EventReporting::generateEventReport( + EventMessage message) +{ + EventReport report(message.getEventId(),message.getReporter(), + message.getParameter1(),message.getParameter2()); + TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId, + message.getSeverity(), packetSubCounter++, &report); + ReturnValue_t result = tmPacket.sendPacket( + requestQueue->getDefaultDestination(),requestQueue->getId()); + if(result != HasReturnvaluesIF::RETURN_OK) { + sif::debug << "Service5EventReporting::generateEventReport:" + " Could not send TM packet" << std::endl; + } + return result; +} + +ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) { + switch(subservice) { + case Subservice::ENABLE: { + enableEventReport = true; + return HasReturnvaluesIF::RETURN_OK; + } + case Subservice::DISABLE: { + enableEventReport = false; + return HasReturnvaluesIF::RETURN_OK; + } + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + + +// In addition to the default PUSServiceBase initialization, this service needs +// to be registered to the event manager to listen for events. +ReturnValue_t Service5EventReporting::initialize() { + EventManagerIF* manager = objectManager->get( + objects::EVENT_MANAGER); + if (manager == NULL) { + return RETURN_FAILED; + } + // register Service 5 as listener for events + ReturnValue_t result = manager->registerListener(eventQueue->getId(),true); + if(result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return PusServiceBase::initialize(); +} diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h new file mode 100644 index 00000000..79b7c5e7 --- /dev/null +++ b/pus/Service5EventReporting.h @@ -0,0 +1,86 @@ +#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_ +#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_ + +#include +#include + +/** + * @brief Report on-board events like information or errors + * @details + * Full Documentation: ECSS-E70-41A p.79 + * Implements the PusServiceBase template class. + * Documentation: Dissertation Baetz p.135,136 + * + * This service provides for the reporting to the service user of information of + * operational significance. + * 1. reporting of failures or anomalies detected on-board; + * 2. reporting of autonomous on-board actions; + * 3. reporting of normal progress of operations and activities, e.g. + * detection of events which are not anomalous (such as payload events), + * reaching of predefined steps in an operation. Some reports can combine + * more than one of these events. + * + * Minimum capabilities of this service: + * + * - TM[5,1]: Normal/Progress Report + * - TM[5,2]: Error/Anomaly Report - Low Severity + * - TM[5,3]: Error/Anomaly Report - Medium Severity + * - TM[5,4]: Error/Anomaly Report - High Severity + * + * Events can be translated by using translator files located in + * /config/objects/ and /config/events/. Description to events can be added by + * adding a comment behind the event definition with [//!<] as leading string + * + * Additional capabilities of this service: + * + * - TC[5,5]: Enable Event Report Generation (Req. 6) + * - TC[5,6]: Disable Event Report Generation (Req. 5) + * @author R. Mueller + * @ingroup pus_services + */ +class Service5EventReporting: public PusServiceBase { +public: + + Service5EventReporting(object_id_t objectId, uint16_t apid, + uint8_t serviceId, size_t maxNumberReportsPerCycle = 10); + virtual ~Service5EventReporting(); + + /*** + * Check for events and generate event reports if required. + * @return + */ + ReturnValue_t performService() override; + + /*** + * Turn event generation on or off. + * @return + */ + ReturnValue_t handleRequest(uint8_t subservice) override; + + /** + * The default PusServiceBase initialize has been overridden but is still + * executed. Registers this service as a listener for events at the + * EventManager. + * @return + */ + ReturnValue_t initialize() override; + + enum Subservice: uint8_t { + NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report + ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity + ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity + ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity + ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation + DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation + }; + +private: + uint16_t packetSubCounter = 0; + MessageQueueIF* eventQueue = nullptr; + bool enableEventReport = true; + const uint8_t maxNumberReportsPerCycle; + + ReturnValue_t generateEventReport(EventMessage message); +}; + +#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */ diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp new file mode 100644 index 00000000..812398b9 --- /dev/null +++ b/pus/Service8FunctionManagement.cpp @@ -0,0 +1,135 @@ +#include +#include + +#include +#include +#include +#include +#include + +Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id, + uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands, + uint16_t commandTimeoutSeconds): + CommandingServiceBase(object_id, apid, serviceId, numParallelCommands, + commandTimeoutSeconds) {} + +Service8FunctionManagement::~Service8FunctionManagement() {} + + +ReturnValue_t Service8FunctionManagement::isValidSubservice( + uint8_t subservice) { + switch(static_cast(subservice)) { + case Subservice::DIRECT_COMMANDING: + return HasReturnvaluesIF::RETURN_OK; + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + +ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject( + uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, + MessageQueueId_t* id, object_id_t* objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + + return checkInterfaceAndAcquireMessageQueue(id,objectId); +} + +ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { + // check HasActionIF property of target + HasActionsIF* possibleTarget = objectManager->get(*objectId); + if(possibleTarget == nullptr){ + return CommandingServiceBase::INVALID_OBJECT; + } + *messageQueueToSet = possibleTarget->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t Service8FunctionManagement::prepareCommand( + CommandMessage* message, uint8_t subservice, const uint8_t* tcData, + size_t tcDataLen, uint32_t* state, object_id_t objectId) { + return prepareDirectCommand(dynamic_cast(message), + tcData, tcDataLen); +} + +ReturnValue_t Service8FunctionManagement::prepareDirectCommand( + CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) { + // Create direct command instance by extracting data from Telecommand + DirectCommand command(tcData,tcDataLen); + + // store additional parameters into the IPC Store + store_address_t parameterAddress; + ReturnValue_t result = IPCStore->addData(¶meterAddress, + command.getParameters(),command.getParametersSize()); + + // setCommand expects a Command Message, an Action ID and a store adress + // pointing to additional parameters + ActionMessage::setCommand(message,command.getActionId(),parameterAddress); + return result; +} + + +ReturnValue_t Service8FunctionManagement::handleReply( + const CommandMessage* reply, Command_t previousCommand, + uint32_t* state, CommandMessage* optionalNextCommand, + object_id_t objectId, bool* isStep) { + Command_t replyId = reply->getCommand(); + ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; + ActionId_t actionId = ActionMessage::getActionId(reply); + ReturnValue_t returnCode = ActionMessage::getReturnCode(reply); + + switch(replyId) { + case ActionMessage::COMPLETION_SUCCESS: { + DirectReply completionReply(objectId, actionId,returnCode); + result = CommandingServiceBase::EXECUTION_COMPLETE; + break; + } + case ActionMessage::STEP_SUCCESS: { + *isStep = true; + result = HasReturnvaluesIF::RETURN_OK; + break; + } + case ActionMessage::DATA_REPLY: { + result = handleDataReply(reply, objectId, actionId); + break; + } + case ActionMessage::STEP_FAILED: + *isStep = true; + /*No break, falls through*/ + case ActionMessage::COMPLETION_FAILED: + result = ActionMessage::getReturnCode(reply); + break; + default: + result = INVALID_REPLY; + } + return result; +} + +ReturnValue_t Service8FunctionManagement::handleDataReply( + const CommandMessage* reply, object_id_t objectId, + ActionId_t actionId) { + store_address_t storeId = ActionMessage::getStoreId(reply); + size_t size = 0; + const uint8_t * buffer = nullptr; + ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size); + if(result != RETURN_OK) { + sif::error << "Service 8: Could not retrieve data for data reply" + << std::endl; + return result; + } + DataReply dataReply(objectId, actionId, buffer, size); + result = sendTmPacket(static_cast( + Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply); + + auto deletionResult = IPCStore->deleteData(storeId); + if(deletionResult != HasReturnvaluesIF::RETURN_OK) { + sif::warning << "Service8FunctionManagement::handleReply: Deletion" + << " of data in pool failed." << std::endl; + } + return result; +} diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h new file mode 100644 index 00000000..e2c7a84f --- /dev/null +++ b/pus/Service8FunctionManagement.h @@ -0,0 +1,67 @@ +#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ +#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ + +#include +#include + +/** + * @brief Functional commanding. + * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451 + * Dissertation Baetz p. 115, 116, 165-167 + * + * This service provides the capability to perform functions of an + * application process and provides high-level commanding as opposed to the + * Raw Access provided by Service 2. Examples for these functions can include + * control and operation of payload or the AOCS subsystem. + * This service will be the primary means to control the spacecraft as it is + * considered safer than the Raw Access provided + * by Service 2 and is generally sufficient for most tasks. + * + * This is a gateway service. It relays device commands using the software bus. + * This service is very closely tied to the Commanding Service Base template + * class. There is constant interaction between this Service Base und a + * subclass like this service. + * + * Service Capability: + * - TC[8,128]: Direct Commanding + * - TM[8,130]: Direct Commanding Data Reply + * + * @ingroup pus_services + */ +class Service8FunctionManagement : public CommandingServiceBase +{ +public: + Service8FunctionManagement(object_id_t objectId, uint16_t apid, + uint8_t serviceId, uint8_t numParallelCommands = 4, + uint16_t commandTimeoutSeconds = 60); + virtual ~Service8FunctionManagement(); + +protected: + /* CSB abstract functions implementation . See CSB documentation. */ + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + uint32_t *state, object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + +private: + enum class Subservice { + DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding + DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply + }; + + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId); + ReturnValue_t prepareDirectCommand(CommandMessage* message, + const uint8_t* tcData, size_t tcDataLen); + ReturnValue_t handleDataReply(const CommandMessage* reply, + object_id_t objectId, ActionId_t actionId); +}; + +#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */ diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h new file mode 100644 index 00000000..b01942c6 --- /dev/null +++ b/pus/servicepackets/Service1Packets.h @@ -0,0 +1,166 @@ +/** + * @defgroup spacepackets PUS Packet Definitions + * This group contains all implemented TM or TM packages that are sent to + * or sent by the OBC.They are exported later to display + * packet structures in Mission Information Base (MIB). + */ + +#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ +#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ + +#include +#include + +/** + * @brief FailureReport class to serialize a failure report + * @brief Subservice 1, 3, 5, 7 + * @ingroup spacepackets + */ +class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7 +public: + FailureReport(uint8_t failureSubtype_, uint16_t packetId_, + uint16_t packetSequenceControl_, uint8_t stepNumber_, + ReturnValue_t errorCode_, uint32_t errorParameter1_, + uint32_t errorParameter2_) : + packetId(packetId_), packetSequenceControl(packetSequenceControl_), + stepNumber(stepNumber_), errorCode(errorCode_), + errorParameter1(errorParameter1_), errorParameter2(errorParameter2_), + failureSubtype(failureSubtype_) {} + + /** + * This function is called by the FSFW when calling the tm packet send + * function and supplying the SerializeIF* as parameter + * @param buffer Object content is serialized into the buffer + * @param size + * @param max_size + * @param bigEndian + * @return + */ + virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, + size_t maxSize, SerializeIF::Endianness streamEndianness + ) const override { + ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer, + size, maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(&packetSequenceControl, buffer, + size, maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) { + result = SerializeAdapter::serialize(&stepNumber, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + } + result = SerializeAdapter::serialize(&errorCode, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(&errorParameter1, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + + result = SerializeAdapter::serialize(&errorParameter2, buffer, size, + maxSize, streamEndianness); + return result; + } + + + virtual size_t getSerializedSize() const { + size_t size = 0; + size += SerializeAdapter::getSerializedSize(&packetId); + size += sizeof(packetSequenceControl); + if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){ + size += SerializeAdapter::getSerializedSize(&stepNumber); + } + size += SerializeAdapter::getSerializedSize(&errorCode); + size += SerializeAdapter::getSerializedSize(&errorParameter1); + size += SerializeAdapter::getSerializedSize(&errorParameter2); + return size; + } + + /** + * Deserialization is not allowed for a report. + * @param buffer + * @param size + * @param bigEndian + * @return + */ + ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, + SerializeIF::Endianness streamEndianness) override { + return HasReturnvaluesIF::RETURN_FAILED; + } +private: + uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand + uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand + uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6 + ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file + uint32_t errorParameter1; + uint32_t errorParameter2; + const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE] +}; + +/** + * @brief Subservices 2, 4, 6, 8 + * @ingroup spacepackets + */ +class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8 +public: + SuccessReport(uint8_t subtype_, uint16_t packetId_, + uint16_t packetSequenceControl_,uint8_t stepNumber_) : + packetId(packetId_), packetSequenceControl(packetSequenceControl_), + stepNumber(stepNumber_), subtype(subtype_) {} + + virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, + size_t maxSize, SerializeIF::Endianness streamEndianness + ) const override { + ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer, + size, maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(&packetSequenceControl, buffer, + size, maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + if (subtype == TC_VERIFY::PROGRESS_SUCCESS) { + result = SerializeAdapter::serialize(&stepNumber, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + } + return result; + } + + virtual size_t getSerializedSize() const override { + size_t size = 0; + size += SerializeAdapter::getSerializedSize(&packetId); + size += sizeof(packetSequenceControl); + if(subtype == TC_VERIFY::PROGRESS_SUCCESS){ + size += SerializeAdapter::getSerializedSize(&stepNumber); + } + return size; + + } + + ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, + SerializeIF::Endianness streamEndianness) override { + return HasReturnvaluesIF::RETURN_FAILED; + } +private: + uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand + uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand + uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6 + const uint8_t subtype; //!< [EXPORT] : [IGNORE] +}; + +#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */ diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h new file mode 100644 index 00000000..1b5bf236 --- /dev/null +++ b/pus/servicepackets/Service200Packets.h @@ -0,0 +1,63 @@ +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ + +#include +#include +#include + +/** + * @brief Subservice 1, 2, 3, 4, 5 + * @ingroup spacepackets + */ +class ModePacket : public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6 +public: + + ModePacket() { + setLinks(); + } + + ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) : + objectId(objectId), mode(mode), submode(submode) { + setLinks(); + } + + Mode_t getMode() { + return mode.entry; + } + + Submode_t getSubmode() { + return submode.entry; + } + + // Forbid copying, pointers are used. + ModePacket(const ModePacket&) = delete; + ModePacket& operator=(const ModePacket&) = delete; +private: + + void setLinks() { + setStart(&objectId); + objectId.setNext(&mode); + mode.setNext(&submode); + } + SerializeElement objectId; //!< [EXPORT] : [COMMENT] Target or source object + SerializeElement mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW + SerializeElement submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible +}; + +/** + * @brief Subservice 7 + * @ingroup spacepackets + */ +class CantReachModePacket: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 7 +public: + CantReachModePacket(object_id_t objectId, ReturnValue_t reason): + objectId(objectId), reason(reason) { + setStart(&this->objectId); + this->objectId.setNext(&this->reason); + } + + SerializeElement objectId; //!< [EXPORT] : [COMMENT] Reply source object + SerializeElement reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */ diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h new file mode 100644 index 00000000..f292611e --- /dev/null +++ b/pus/servicepackets/Service2Packets.h @@ -0,0 +1,76 @@ +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ + +#include +#include +#include +#include + +/** + * @brief Subservice 128 + * @ingroup spacepackets + */ +class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128 +public: + RawCommand(const uint8_t* buffer, size_t size) { + // Deserialize Adapter to get correct endianness + SerializeAdapter::deSerialize(&objectId, &buffer, &size, + SerializeIF::Endianness::BIG); + commandBuffer = buffer; + // size is decremented by AutoSerializeAdapter, + // remaining size is data size + dataSize = size; + } + object_id_t getObjectId() const { + return objectId; + } + + const uint8_t* getCommand() { + return commandBuffer; + } + + size_t getCommandSize() const { + return dataSize; + } +private: + object_id_t objectId = 0; + const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes + size_t dataSize = 0; //!< [EXPORT] : [IGNORE] +}; + + +/** + * @brief Subservice 129: Command packet to set wiretapping mode + * @ingroup spacepackets + */ +class WiretappingToggle: public SerialLinkedListAdapter{ //!< [EXPORT] : [SUBSERVICE] 129 +public: + static const size_t WIRETAPPING_COMMAND_SIZE = 5; + WiretappingToggle(){ + setStart(&objectId); + objectId.setNext(&wiretappingMode); + } + + uint8_t getWiretappingMode() const { + return wiretappingMode.entry; + } +private: + SerializeElement objectId; + SerializeElement wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW +}; + + +/** + * @brief Subservices 130 and 131: TM packets + * @ingroup spacepackets + */ +class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131 +public: + object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object + const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size + WiretappingPacket(object_id_t objectId, const uint8_t* buffer): + objectId(objectId), data(buffer) { + } +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */ diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h new file mode 100644 index 00000000..14219c93 --- /dev/null +++ b/pus/servicepackets/Service5Packets.h @@ -0,0 +1,76 @@ +#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ +#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ + +#include +#include + + +/** + * @brief Subservice 1, 2, 3, 4 + * Structure of Event Report. + * It consists of: + * 1. Report ID(RID). This is the Event ID in the FSFW + * 2. Object ID of the reporter (e.g. subsystem) + * 2. Parameter 1 + * 3. Parameter 2 + * + * @ingroup spacepackets + */ +class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4 +public: + + EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_, + uint32_t parameter2_): + reportId(reportId_),objectId(objectId_), parameter1(parameter1_), + parameter2(parameter2_) {} + + virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, + size_t maxSize, + SerializeIF::Endianness streamEndianness) const override + { + ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer, + size, maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(&objectId, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(¶meter1, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + result = SerializeAdapter::serialize(¶meter2, buffer, size, + maxSize, streamEndianness); + if (result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return result; + } + + virtual size_t getSerializedSize() const override { + uint32_t size = 0; + size += SerializeAdapter::getSerializedSize(&reportId); + size += SerializeAdapter::getSerializedSize(&objectId); + size += SerializeAdapter::getSerializedSize(¶meter1); + size += SerializeAdapter::getSerializedSize(¶meter2); + return size; + + } + + virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, + SerializeIF::Endianness streamEndianness) override { + return HasReturnvaluesIF::RETURN_FAILED; + } +private: + EventId_t reportId; + object_id_t objectId; + uint32_t parameter1; + uint32_t parameter2; +}; + + +#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */ diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h new file mode 100644 index 00000000..5ef91280 --- /dev/null +++ b/pus/servicepackets/Service8Packets.h @@ -0,0 +1,136 @@ +/** + * \file Service8Packets.h + * + * \brief Structure of a Direct Command. + * Normal reply (subservice 130) consists of + * 1. Target object ID + * 2. Action ID (taget device has specified functions with action IDs) + * 3. Return Code + * 4. Optional step number for step replies + * + * Data reply (subservice 132) consists of + * 1. Target Object ID + * 2. Action ID + * 3. Data + * + * \date 01.07.2019 + * \author R. Mueller + */ + +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ + +#include +#include +#include +#include +#include +#include + + +/** + * \brief Subservice 128 + * \ingroup spacepackets + */ +class DirectCommand: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 128 +public: + //typedef uint16_t typeOfMaxData; + //static const typeOfMaxData MAX_DATA = 256; + DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) { + size_t size = sizeof(objectId); + SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size, + SerializeIF::Endianness::BIG); + size = sizeof(actionId); + SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size, + SerializeIF::Endianness::BIG); + parameterBuffer = dataBuffer_; + parametersSize = size_ - sizeof(objectId) - sizeof(actionId); + } + ActionId_t getActionId() const { + return actionId; + } + + object_id_t getObjectId() const { + return objectId; + } + + const uint8_t* getParameters() { + return parameterBuffer; + } + + uint32_t getParametersSize() const { + return parametersSize; + } + +private: + DirectCommand(const DirectCommand &command); + object_id_t objectId; + ActionId_t actionId; + uint32_t parametersSize; //!< [EXPORT] : [IGNORE] + const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes + +}; + + +/** + * \brief Subservice 130 + * \ingroup spacepackets + */ +class DataReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 130 +public: + typedef uint16_t typeOfMaxDataSize; + static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); + DataReply(object_id_t objectId_, ActionId_t actionId_, + const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0): + objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){ + setLinks(); + } + +private: + DataReply(const DataReply &reply); + void setLinks() { + setStart(&objectId); + objectId.setNext(&actionId); + actionId.setNext(&replyData); + } + SerializeElement objectId; + SerializeElement actionId; + SerializeElement> replyData; +}; + + +/** + * \brief Subservice 132 + * \ingroup spacepackets + */ +class DirectReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 132 +public: + typedef uint16_t typeOfMaxDataSize; + static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); + + DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_, + bool isStep_ = false, uint8_t step_ = 0): + isStep(isStep_), objectId(objectId_), actionId(actionId_), + returnCode(returnCode_),step(step_) { + setLinks(); + } +private: + + void setLinks() { + setStart(&objectId); + objectId.setNext(&actionId); + actionId.setNext(&returnCode); + if(isStep) { + returnCode.setNext(&step); + } + } + bool isDataReply; //!< [EXPORT] : [IGNORE] + bool isStep; //!< [EXPORT] : [IGNORE] + SerializeElement objectId; //!< [EXPORT] : [IGNORE] + SerializeElement actionId; //!< [EXPORT] : [IGNORE] + SerializeElement returnCode; //!< [EXPORT] : [IGNORE] + SerializeElement step; //!< [EXPORT] : [OPTIONAL] [IGNORE] + +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */ From 97b01f837ceaf876ec2939150c444c23e7d6040e Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Fri, 10 Jul 2020 14:29:17 +0200 Subject: [PATCH 02/12] srv8 improvements --- pus/Service8FunctionManagement.cpp | 9 +++++- pus/servicepackets/Service8Packets.h | 41 ++++++++++++++-------------- 2 files changed, 29 insertions(+), 21 deletions(-) diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp index 812398b9..50102b04 100644 --- a/pus/Service8FunctionManagement.cpp +++ b/pus/Service8FunctionManagement.cpp @@ -59,8 +59,15 @@ ReturnValue_t Service8FunctionManagement::prepareCommand( ReturnValue_t Service8FunctionManagement::prepareDirectCommand( CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) { + if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) { + sif::debug << "Service8FunctionManagement::prepareDirectCommand:" + << " TC size smaller thant minimum size of direct command." + << std::endl; + return CommandingServiceBase::INVALID_TC; + } + // Create direct command instance by extracting data from Telecommand - DirectCommand command(tcData,tcDataLen); + DirectCommand command(tcData, tcDataLen); // store additional parameters into the IPC Store store_address_t parameterAddress; diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h index 5ef91280..86681c14 100644 --- a/pus/servicepackets/Service8Packets.h +++ b/pus/servicepackets/Service8Packets.h @@ -8,10 +8,7 @@ * 3. Return Code * 4. Optional step number for step replies * - * Data reply (subservice 132) consists of - * 1. Target Object ID - * 2. Action ID - * 3. Data + * * \date 01.07.2019 * \author R. Mueller @@ -29,23 +26,21 @@ /** - * \brief Subservice 128 - * \ingroup spacepackets + * @brief Subservice 128 + * @ingroup spacepackets */ class DirectCommand: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 128 public: - //typedef uint16_t typeOfMaxData; - //static const typeOfMaxData MAX_DATA = 256; - DirectCommand(const uint8_t* dataBuffer_, uint32_t size_) { - size_t size = sizeof(objectId); - SerializeAdapter::deSerialize(&objectId,&dataBuffer_,&size, + + DirectCommand(const uint8_t* tcData, size_t size) { + SerializeAdapter::deSerialize(&objectId, &tcData, &size, SerializeIF::Endianness::BIG); - size = sizeof(actionId); - SerializeAdapter::deSerialize(&actionId,&dataBuffer_,&size, + SerializeAdapter::deSerialize(&actionId, &tcData, &size, SerializeIF::Endianness::BIG); - parameterBuffer = dataBuffer_; - parametersSize = size_ - sizeof(objectId) - sizeof(actionId); + parameterBuffer = tcData; + parametersSize = size; } + ActionId_t getActionId() const { return actionId; } @@ -73,8 +68,12 @@ private: /** - * \brief Subservice 130 - * \ingroup spacepackets + * @brief Subservice 130 + * Data reply (subservice 130) consists of + * 1. Target Object ID + * 2. Action ID + * 3. Data + * @ingroup spacepackets */ class DataReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 130 public: @@ -100,8 +99,10 @@ private: /** - * \brief Subservice 132 - * \ingroup spacepackets + * @brief Subservice 132 + * @details + * Not used yet. Telecommand Verification takes care of this. + * @ingroup spacepackets */ class DirectReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 132 public: @@ -124,7 +125,7 @@ private: returnCode.setNext(&step); } } - bool isDataReply; //!< [EXPORT] : [IGNORE] + bool isStep; //!< [EXPORT] : [IGNORE] SerializeElement objectId; //!< [EXPORT] : [IGNORE] SerializeElement actionId; //!< [EXPORT] : [IGNORE] From 85d24b9dfef5b13b8ae5dd4ffd8eadf60c38fd8b Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Fri, 10 Jul 2020 14:31:58 +0200 Subject: [PATCH 03/12] removed file header comment --- pus/servicepackets/Service8Packets.h | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h index 86681c14..8ea0d108 100644 --- a/pus/servicepackets/Service8Packets.h +++ b/pus/servicepackets/Service8Packets.h @@ -1,19 +1,3 @@ -/** - * \file Service8Packets.h - * - * \brief Structure of a Direct Command. - * Normal reply (subservice 130) consists of - * 1. Target object ID - * 2. Action ID (taget device has specified functions with action IDs) - * 3. Return Code - * 4. Optional step number for step replies - * - - * - * \date 01.07.2019 - * \author R. Mueller - */ - #ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ #define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ From aca0c94c514a3cfb6401f291e1021b2fe6c662d5 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Thu, 16 Jul 2020 11:47:11 +0200 Subject: [PATCH 04/12] CSB new update init --- tmtcservices/CommandingServiceBase.cpp | 396 ++++++++++++++----------- tmtcservices/CommandingServiceBase.h | 256 ++++++++++------ 2 files changed, 379 insertions(+), 273 deletions(-) diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp index aa41f334..4c9b5375 100644 --- a/tmtcservices/CommandingServiceBase.cpp +++ b/tmtcservices/CommandingServiceBase.cpp @@ -1,26 +1,35 @@ -/* - * CommandingServiceBase.cpp - * - * Created on: 28.08.2019 - * Author: gaisser - */ +#include +#include +#include #include +#include +#include +#include +#include + +object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT; +object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT; CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId, uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands, - uint16_t commandTimeout_seconds, object_id_t setPacketSource, - object_id_t setPacketDestination, size_t queueDepth) : - SystemObject(setObjectId), apid(apid), service(service), timeout_seconds( - commandTimeout_seconds), tmPacketCounter(0), IPCStore(NULL), TCStore( - NULL), commandQueue(NULL), requestQueue(NULL), commandMap( - numberOfParallelCommands), failureParameter1(0), failureParameter2( - 0), packetSource(setPacketSource), packetDestination( - setPacketDestination),executingTask(NULL) { + uint16_t commandTimeoutSeconds, size_t queueDepth) : + SystemObject(setObjectId), apid(apid), service(service), + timeoutSeconds(commandTimeoutSeconds), + commandMap(numberOfParallelCommands) { commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth); requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth); } +void CommandingServiceBase::setPacketSource(object_id_t packetSource) { + this->packetSource = packetSource; +} + +void CommandingServiceBase::setPacketDestination( + object_id_t packetDestination) { + this->packetDestination = packetDestination; +} + CommandingServiceBase::~CommandingServiceBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); @@ -53,12 +62,22 @@ ReturnValue_t CommandingServiceBase::initialize() { return result; } + if(packetDestination == objects::NO_OBJECT) { + packetDestination = defaultPacketDestination; + } AcceptsTelemetryIF* packetForwarding = objectManager->get(packetDestination); + + if(packetSource == objects::NO_OBJECT) { + packetSource = defaultPacketSource; + } PUSDistributorIF* distributor = objectManager->get( packetSource); - if ((packetForwarding == NULL) && (distributor == NULL)) { - return RETURN_FAILED; + + if (packetForwarding == nullptr or distributor == nullptr) { + sif::error << "CommandingServiceBase::intialize: Packet source or " + "packet destination invalid!" << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; } distributor->registerService(this); @@ -68,8 +87,10 @@ ReturnValue_t CommandingServiceBase::initialize() { IPCStore = objectManager->get(objects::IPC_STORE); TCStore = objectManager->get(objects::TC_STORE); - if ((IPCStore == NULL) || (TCStore == NULL)) { - return RETURN_FAILED; + if (IPCStore == nullptr or TCStore == nullptr) { + sif::error << "CommandingServiceBase::intialize: IPC store or TC store " + "not initialized yet!" << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; } return RETURN_OK; @@ -77,97 +98,126 @@ ReturnValue_t CommandingServiceBase::initialize() { } void CommandingServiceBase::handleCommandQueue() { - CommandMessage reply, nextCommand; - ReturnValue_t result, sendResult = RETURN_OK; - bool isStep = false; + CommandMessage reply; + ReturnValue_t result = RETURN_FAILED; for (result = commandQueue->receiveMessage(&reply); result == RETURN_OK; result = commandQueue->receiveMessage(&reply)) { - isStep = false; - typename FixedMap::Iterator iter; - if (reply.getSender() == MessageQueueIF::NO_QUEUE) { - handleUnrequestedReply(&reply); - continue; - } - if ((iter = commandMap.find(reply.getSender())) == commandMap.end()) { - handleUnrequestedReply(&reply); - continue; - } - nextCommand.setCommand(CommandMessage::CMD_NONE); - result = handleReply(&reply, iter->command, &iter->state, &nextCommand, - iter->objectId, &isStep); - switch (result) { - case EXECUTION_COMPLETE: - case RETURN_OK: - case NO_STEP_MESSAGE: - iter->command = nextCommand.getCommand(); - if (nextCommand.getCommand() != CommandMessage::CMD_NONE) { - sendResult = commandQueue->sendMessage(reply.getSender(), - &nextCommand); - } - if (sendResult == RETURN_OK) { - if (isStep) { - if (result != NO_STEP_MESSAGE) { - verificationReporter.sendSuccessReport( - TC_VERIFY::PROGRESS_SUCCESS, - iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, - iter->tcInfo.tcSequenceControl, ++iter->step); - } - } else { - verificationReporter.sendSuccessReport( - TC_VERIFY::COMPLETION_SUCCESS, - iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, - iter->tcInfo.tcSequenceControl, 0); - checkAndExecuteFifo(&iter); - } - } else { - if (isStep) { - nextCommand.clearCommandMessage(); - verificationReporter.sendFailureReport( - TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags, - iter->tcInfo.tcPacketId, - iter->tcInfo.tcSequenceControl, sendResult, - ++iter->step, failureParameter1, failureParameter2); - } else { - nextCommand.clearCommandMessage(); - verificationReporter.sendFailureReport( - TC_VERIFY::COMPLETION_FAILURE, - iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, - iter->tcInfo.tcSequenceControl, sendResult, 0, - failureParameter1, failureParameter2); - } - failureParameter1 = 0; - failureParameter2 = 0; - checkAndExecuteFifo(&iter); - } - break; - case INVALID_REPLY: - //might be just an unrequested reply at a bad moment - handleUnrequestedReply(&reply); - break; - default: - if (isStep) { - verificationReporter.sendFailureReport( - TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags, - iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, - result, ++iter->step, failureParameter1, - failureParameter2); - } else { - verificationReporter.sendFailureReport( - TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags, - iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, - result, 0, failureParameter1, failureParameter2); - } - failureParameter1 = 0; - failureParameter2 = 0; - checkAndExecuteFifo(&iter); - break; - } - + handleCommandMessage(&reply); } } +void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) { + bool isStep = false; + CommandMessage nextCommand; + CommandMapIter iter = commandMap.find(reply->getSender()); + + // handle unrequested reply first + if (reply->getSender() == MessageQueueIF::NO_QUEUE or + iter == commandMap.end()) { + handleUnrequestedReply(reply); + return; + } + nextCommand.setCommand(CommandMessage::CMD_NONE); + + + // Implemented by child class, specifies what to do with reply. + ReturnValue_t result = handleReply(reply, iter->command, &iter->state, + &nextCommand, iter->objectId, &isStep); + + /* If the child implementation does not implement special handling for + * rejected replies (RETURN_FAILED is returned), a failure verification + * will be generated with the reason as the return code and the initial + * command as failure parameter 1 */ + if(reply->getCommand() == CommandMessage::REPLY_REJECTED and + result == RETURN_FAILED) { + result = reply->getReplyRejectedReason(); + failureParameter1 = iter->command; + } + + switch (result) { + case EXECUTION_COMPLETE: + case RETURN_OK: + case NO_STEP_MESSAGE: + // handle result of reply handler implemented by developer. + handleReplyHandlerResult(result, iter, &nextCommand, reply, isStep); + break; + case INVALID_REPLY: + //might be just an unrequested reply at a bad moment + handleUnrequestedReply(reply); + break; + default: + if (isStep) { + verificationReporter.sendFailureReport( + TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags, + iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, + result, ++iter->step, failureParameter1, + failureParameter2); + } else { + verificationReporter.sendFailureReport( + TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags, + iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, + result, 0, failureParameter1, failureParameter2); + } + failureParameter1 = 0; + failureParameter2 = 0; + checkAndExecuteFifo(iter); + break; + } + +} + +void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result, + CommandMapIter iter, CommandMessage* nextCommand, + CommandMessage* reply, bool& isStep) { + iter->command = nextCommand->getCommand(); + + // In case a new command is to be sent immediately, this is performed here. + // If no new command is sent, only analyse reply result by initializing + // sendResult as RETURN_OK + ReturnValue_t sendResult = RETURN_OK; + if (nextCommand->getCommand() != CommandMessage::CMD_NONE) { + sendResult = commandQueue->sendMessage(reply->getSender(), + nextCommand); + } + + if (sendResult == RETURN_OK) { + if (isStep and result != NO_STEP_MESSAGE) { + verificationReporter.sendSuccessReport( + TC_VERIFY::PROGRESS_SUCCESS, + iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, + iter->tcInfo.tcSequenceControl, ++iter->step); + } + else { + verificationReporter.sendSuccessReport( + TC_VERIFY::COMPLETION_SUCCESS, + iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, + iter->tcInfo.tcSequenceControl, 0); + checkAndExecuteFifo(iter); + } + } + else { + if (isStep) { + nextCommand->clearCommandMessage(); + verificationReporter.sendFailureReport( + TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags, + iter->tcInfo.tcPacketId, + iter->tcInfo.tcSequenceControl, sendResult, + ++iter->step, failureParameter1, failureParameter2); + } else { + nextCommand->clearCommandMessage(); + verificationReporter.sendFailureReport( + TC_VERIFY::COMPLETION_FAILURE, + iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, + iter->tcInfo.tcSequenceControl, sendResult, 0, + failureParameter1, failureParameter2); + } + failureParameter1 = 0; + failureParameter2 = 0; + checkAndExecuteFifo(iter); + } +} + void CommandingServiceBase::handleRequestQueue() { TmTcMessage message; ReturnValue_t result; @@ -180,8 +230,8 @@ void CommandingServiceBase::handleRequestQueue() { address = message.getStorageId(); packet.setStoreAddress(address); - if ((packet.getSubService() == 0) - || (isValidSubservice(packet.getSubService()) != RETURN_OK)) { + if (packet.getSubService() == 0 + or isValidSubservice(packet.getSubService()) != RETURN_OK) { rejectPacket(TC_VERIFY::START_FAILURE, &packet, INVALID_SUBSERVICE); continue; } @@ -194,8 +244,7 @@ void CommandingServiceBase::handleRequestQueue() { } //Is a command already active for the target object? - typename FixedMap::Iterator iter; + CommandMapIter iter; iter = commandMap.find(queue); if (iter != commandMap.end()) { @@ -210,7 +259,7 @@ void CommandingServiceBase::handleRequestQueue() { if (result != RETURN_OK) { rejectPacket(TC_VERIFY::START_FAILURE, &packet, BUSY); } else { - startExecution(&packet, &iter); + startExecution(&packet, iter); } } @@ -218,9 +267,9 @@ void CommandingServiceBase::handleRequestQueue() { } -void CommandingServiceBase::sendTmPacket(uint8_t subservice, - const uint8_t* data, uint32_t dataLen, const uint8_t* headerData, - uint32_t headerSize) { +ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice, + const uint8_t* data, size_t dataLen, const uint8_t* headerData, + size_t headerSize) { TmPacketStored tmPacketStored(this->apid, this->service, subservice, this->tmPacketCounter, data, dataLen, headerData, headerSize); ReturnValue_t result = tmPacketStored.sendPacket( @@ -228,79 +277,79 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice, if (result == HasReturnvaluesIF::RETURN_OK) { this->tmPacketCounter++; } + return result; } -void CommandingServiceBase::sendTmPacket(uint8_t subservice, - object_id_t objectId, const uint8_t *data, uint32_t dataLen) { - uint8_t buffer[sizeof(object_id_t)]; - uint8_t* pBuffer = buffer; - size_t size = 0; - SerializeAdapter::serialize(&objectId, &pBuffer, &size, - sizeof(object_id_t), SerializeIF::Endianness::BIG); - TmPacketStored tmPacketStored(this->apid, this->service, subservice, - this->tmPacketCounter, data, dataLen, buffer, size); - ReturnValue_t result = tmPacketStored.sendPacket( - requestQueue->getDefaultDestination(), requestQueue->getId()); - if (result == HasReturnvaluesIF::RETURN_OK) { - this->tmPacketCounter++; - } - +ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice, + object_id_t objectId, const uint8_t *data, size_t dataLen) { + uint8_t buffer[sizeof(object_id_t)]; + uint8_t* pBuffer = buffer; + size_t size = 0; + SerializeAdapter::serialize(&objectId, &pBuffer, &size, + sizeof(object_id_t), SerializeIF::Endianness::BIG); + TmPacketStored tmPacketStored(this->apid, this->service, subservice, + this->tmPacketCounter, data, dataLen, buffer, size); + ReturnValue_t result = tmPacketStored.sendPacket( + requestQueue->getDefaultDestination(), requestQueue->getId()); + if (result == HasReturnvaluesIF::RETURN_OK) { + this->tmPacketCounter++; + } + return result; } -void CommandingServiceBase::sendTmPacket(uint8_t subservice, - SerializeIF* content, SerializeIF* header) { - TmPacketStored tmPacketStored(this->apid, this->service, subservice, - this->tmPacketCounter, content, header); - ReturnValue_t result = tmPacketStored.sendPacket( - requestQueue->getDefaultDestination(), requestQueue->getId()); - if (result == HasReturnvaluesIF::RETURN_OK) { - this->tmPacketCounter++; - } +ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice, + SerializeIF* content, SerializeIF* header) { + TmPacketStored tmPacketStored(this->apid, this->service, subservice, + this->tmPacketCounter, content, header); + ReturnValue_t result = tmPacketStored.sendPacket( + requestQueue->getDefaultDestination(), requestQueue->getId()); + if (result == HasReturnvaluesIF::RETURN_OK) { + this->tmPacketCounter++; + } + return result; } -void CommandingServiceBase::startExecution( - TcPacketStored *storedPacket, - typename FixedMap::Iterator *iter) { - ReturnValue_t result, sendResult = RETURN_OK; - CommandMessage message; - (*iter)->subservice = storedPacket->getSubService(); - result = prepareCommand(&message, (*iter)->subservice, - storedPacket->getApplicationData(), - storedPacket->getApplicationDataSize(), &(*iter)->state, - (*iter)->objectId); +void CommandingServiceBase::startExecution(TcPacketStored *storedPacket, + CommandMapIter iter) { + ReturnValue_t result = RETURN_OK; + CommandMessage command; + iter->subservice = storedPacket->getSubService(); + result = prepareCommand(&command, iter->subservice, + storedPacket->getApplicationData(), + storedPacket->getApplicationDataSize(), &iter->state, + iter->objectId); + ReturnValue_t sendResult = RETURN_OK; switch (result) { case RETURN_OK: - if (message.getCommand() != CommandMessage::CMD_NONE) { - sendResult = commandQueue->sendMessage((*iter).value->first, - &message); + if (command.getCommand() != CommandMessage::CMD_NONE) { + sendResult = commandQueue->sendMessage(iter.value->first, + &command); } if (sendResult == RETURN_OK) { - Clock::getUptime(&(*iter)->uptimeOfStart); - (*iter)->step = 0; -// (*iter)->state = 0; - (*iter)->subservice = storedPacket->getSubService(); - (*iter)->command = message.getCommand(); - (*iter)->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags(); - (*iter)->tcInfo.tcPacketId = storedPacket->getPacketId(); - (*iter)->tcInfo.tcSequenceControl = + Clock::getUptime(&iter->uptimeOfStart); + iter->step = 0; + iter->subservice = storedPacket->getSubService(); + iter->command = command.getCommand(); + iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags(); + iter->tcInfo.tcPacketId = storedPacket->getPacketId(); + iter->tcInfo.tcSequenceControl = storedPacket->getPacketSequenceControl(); acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket); } else { - message.clearCommandMessage(); + command.clearCommandMessage(); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); checkAndExecuteFifo(iter); } break; case EXECUTION_COMPLETE: - if (message.getCommand() != CommandMessage::CMD_NONE) { + if (command.getCommand() != CommandMessage::CMD_NONE) { //Fire-and-forget command. - sendResult = commandQueue->sendMessage((*iter).value->first, - &message); + sendResult = commandQueue->sendMessage(iter.value->first, + &command); } if (sendResult == RETURN_OK) { verificationReporter.sendSuccessReport(TC_VERIFY::START_SUCCESS, @@ -308,7 +357,7 @@ void CommandingServiceBase::startExecution( acceptPacket(TC_VERIFY::COMPLETION_SUCCESS, storedPacket); checkAndExecuteFifo(iter); } else { - message.clearCommandMessage(); + command.clearCommandMessage(); rejectPacket(TC_VERIFY::START_FAILURE, storedPacket, sendResult); checkAndExecuteFifo(iter); } @@ -335,12 +384,10 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId, } -void CommandingServiceBase::checkAndExecuteFifo( - typename FixedMap::Iterator *iter) { +void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) { store_address_t address; - if ((*iter)->fifo.retrieve(&address) != RETURN_OK) { - commandMap.erase(iter); + if (iter->fifo.retrieve(&address) != RETURN_OK) { + commandMap.erase(&iter); } else { TcPacketStored newPacket(address); startExecution(&newPacket, iter); @@ -348,8 +395,7 @@ void CommandingServiceBase::checkAndExecuteFifo( } -void CommandingServiceBase::handleUnrequestedReply( - CommandMessage* reply) { +void CommandingServiceBase::handleUnrequestedReply(CommandMessage* reply) { reply->clearCommandMessage(); } @@ -364,18 +410,18 @@ MessageQueueId_t CommandingServiceBase::getCommandQueue() { void CommandingServiceBase::checkTimeout() { uint32_t uptime; Clock::getUptime(&uptime); - typename FixedMap::Iterator iter; + CommandMapIter iter; for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) { - if ((iter->uptimeOfStart + (timeout_seconds * 1000)) < uptime) { + if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) { verificationReporter.sendFailureReport( TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl, TIMEOUT); - checkAndExecuteFifo(&iter); + checkAndExecuteFifo(iter); } } } - - +void CommandingServiceBase::setTaskIF(PeriodicTaskIF* task_) { + executingTask = task_; +} diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h index bf2e8242..1bd18571 100644 --- a/tmtcservices/CommandingServiceBase.h +++ b/tmtcservices/CommandingServiceBase.h @@ -1,40 +1,43 @@ -#ifndef COMMANDINGSERVICEBASE_H_ -#define COMMANDINGSERVICEBASE_H_ +#ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ +#define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ -#include -#include -#include -#include #include -#include #include #include -#include -#include -#include +#include #include -#include -#include + #include -#include -#include -#include +#include +#include +#include +#include + +class TcPacketStored; + +namespace Factory{ +void setStaticFrameworkObjectIds(); +} /** - * \brief This class is the basis for all PUS Services, which have to relay Telecommands to software bus. + * @brief This class is the basis for all PUS Services, which have to + * relay Telecommands to software bus. * - * It manages Telecommand reception and the generation of Verification Reports like PUSServiceBase. - * Every class that inherits from this abstract class has to implement four adaption points: + * It manages Telecommand reception and the generation of Verification Reports + * similar to PusServiceBase. This class is used if a telecommand can't be + * handled immediately and must be relayed to the internal software bus. * - isValidSubservice * - getMessageQueueAndObject * - prepareCommand * - handleReply - * \ingroup pus_services + * @author gaisser + * @ingroup pus_services */ class CommandingServiceBase: public SystemObject, public AcceptsTelecommandsIF, public ExecutableObjectIF, public HasReturnvaluesIF { + friend void (Factory::setStaticFrameworkObjectIds)(); public: static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE; static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1); @@ -59,10 +62,24 @@ public: */ CommandingServiceBase(object_id_t setObjectId, uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands, - uint16_t commandTimeout_seconds, object_id_t setPacketSource, - object_id_t setPacketDestination, size_t queueDepth = 20); + uint16_t commandTimeoutSeconds, size_t queueDepth = 20); virtual ~CommandingServiceBase(); + /** + * This setter can be used to set the packet source individually instead + * of using the default static framework ID set in the factory. + * This should be called at object initialization and not during run-time! + * @param packetSource + */ + void setPacketSource(object_id_t packetSource); + /** + * This setter can be used to set the packet destination individually + * instead of using the default static framework ID set in the factory. + * This should be called at object initialization and not during run-time! + * @param packetDestination + */ + void setPacketDestination(object_id_t packetDestination); + /*** * This is the periodically called function. * Handle request queue for external commands. @@ -91,82 +108,111 @@ public: */ virtual MessageQueueId_t getCommandQueue(); - virtual ReturnValue_t initialize(); + virtual ReturnValue_t initialize() override; /** * Implementation of ExecutableObjectIF function * * Used to setup the reference of the task, that executes this component - * @param task_ Pointer to the taskIF of this task + * @param task Pointer to the taskIF of this task */ - virtual void setTaskIF(PeriodicTaskIF* task_){ - executingTask = task_; - }; + virtual void setTaskIF(PeriodicTaskIF* task); protected: /** * Check the target subservice * @param subservice[in] - * @return -@c RETURN_OK on success - * -@c INVALID_SUBSERVICE if service is not known + * @return + * -@c RETURN_OK Subservice valid, continue message handling + * -@c INVALID_SUBSERVICE if service is not known, rejects packet. */ virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0; /** - * Once a TC Request is valid, the existence of the destination and its target interface is checked and retrieved. - * The target message queue ID can then be acquired by using the target interface. + * Once a TC Request is valid, the existence of the destination and its + * target interface is checked and retrieved. The target message queue ID + * can then be acquired by using the target interface. * @param subservice * @param tcData Application Data of TC Packet * @param tcDataLen * @param id MessageQueue ID is stored here * @param objectId Object ID is extracted and stored here - * @return - @c RETURN_OK on success - * - @c RETURN_FAILED - * - @c CSB or implementation specific return codes + * @return + * - @c RETURN_OK Cotinue message handling + * - @c RETURN_FAILED Reject the packet and generates a start failure + * verification */ virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice, - const uint8_t *tcData, uint32_t tcDataLen, MessageQueueId_t *id, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, object_id_t *objectId) = 0; /** - * After the Message Queue and Object ID are determined, - * the command is prepared by using an implementation specific CommandMessage type - * which is sent to the target object. - * It contains all necessary information for the device to execute telecommands. - * @param message[out] message to be sent to the object - * @param subservice[in] Subservice of the current communication - * @param tcData Additional data of the command - * @param tcDataLen Length of the additional data - * @param state[out] Setable state of the communication + * After the Message Queue and Object ID are determined, the command is + * prepared by using an implementation specific CommandMessage type + * which is sent to the target object. It contains all necessary information + * for the device to execute telecommands. + * @param message [out] message which can be set and is sent to the object + * @param subservice Subservice of the current communication + * @param tcData Application data of command + * @param tcDataLen Application data length + * @param state [out/in] Setable state of the communication. + * communication * @param objectId Target object ID - * @return - @c RETURN_OK on success - * - @c EXECUTION_COMPLETE if exectuin is finished - * - any other return code will be part of (1,4) start failure + * @return + * - @c RETURN_OK to generate a verification start message + * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion + * verification message. + * - @c Anything else rejects the packets and generates a start failure + * verification. */ - virtual ReturnValue_t prepareCommand(CommandMessage *message, - uint8_t subservice, const uint8_t *tcData, uint32_t tcDataLen, + virtual ReturnValue_t prepareCommand(CommandMessage* message, + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, uint32_t *state, object_id_t objectId) = 0; /** - * This function is responsible for the communication between the Command Service Base - * and the respective PUS Commanding Service once the execution has started. - * The PUS Commanding Service receives replies from the target device and forwards them by calling this function. - * There are different translations of these replies to specify how the Command Service proceeds. - * @param reply Command Message which contains information about the command - * @param previousCommand Command_t of last command - * @param state state of the communication - * @param optionalNextCommand[out] An optional next command which can be set in this function + * This function is implemented by child services to specify how replies + * to a command from another software component are handled. + * @param reply + * This is the reply which can be accessed via the command message + * interface. The internal message pointer can be passed to different + * command message implementations (see CommandMessageIF) + * @param previousCommand + * Command_t of related command + * @param state [out/in] + * Additional parameter which can be used to pass state information. + * State of the communication + * @param optionalNextCommand [out] + * An optional next command which can be set in this function * @param objectId Source object ID * @param isStep Flag value to mark steps of command execution - * @return - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to generate TC verification success - * - @c INVALID_REPLY can handle unrequested replies - * - Anything else triggers a TC verification failure + * @return + * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to + * generate TC verification success + * - @c INVALID_REPLY Calls handleUnrequestedReply + * - Anything else triggers a TC verification failure. If RETURN_FAILED + * is returned and the command ID is CommandMessage::REPLY_REJECTED, + * a failure verification message with the reason as the error parameter + * and the initial command as failure parameter 1. */ - virtual ReturnValue_t handleReply(const CommandMessage *reply, + virtual ReturnValue_t handleReply(const CommandMessage* reply, Command_t previousCommand, uint32_t *state, - CommandMessage *optionalNextCommand, object_id_t objectId, + CommandMessage* optionalNextCommand, object_id_t objectId, bool *isStep) = 0; + /** + * This function can be overidden to handle unrequested reply, + * when the reply sender ID is unknown or is not found is the command map. + * The default implementation will clear the command message and all + * its contents. + * @param reply + * Reply which is non-const so the default implementation can clear the + * message. + */ + virtual void handleUnrequestedReply(CommandMessage* reply); + + virtual void doPeriodicOperation(); + + struct CommandInfo { struct tcInfo { uint8_t ackFlags; @@ -182,84 +228,92 @@ protected: FIFO fifo; }; + using CommandMapIter = FixedMap::Iterator; + const uint16_t apid; const uint8_t service; - const uint16_t timeout_seconds; + const uint16_t timeoutSeconds; - uint8_t tmPacketCounter; + uint8_t tmPacketCounter = 0; - StorageManagerIF *IPCStore; + StorageManagerIF *IPCStore = nullptr; - StorageManagerIF *TCStore; + StorageManagerIF *TCStore = nullptr; - MessageQueueIF* commandQueue; + MessageQueueIF* commandQueue = nullptr; - MessageQueueIF* requestQueue; + MessageQueueIF* requestQueue = nullptr; VerificationReporter verificationReporter; FixedMap commandMap; - uint32_t failureParameter1; //!< May be set be children to return a more precise failure condition. - uint32_t failureParameter2; //!< May be set be children to return a more precise failure condition. + /* May be set be children to return a more precise failure condition. */ + uint32_t failureParameter1 = 0; + uint32_t failureParameter2 = 0; - object_id_t packetSource; - - object_id_t packetDestination; + static object_id_t defaultPacketSource; + object_id_t packetSource = objects::NO_OBJECT; + static object_id_t defaultPacketDestination; + object_id_t packetDestination = objects::NO_OBJECT; /** - * Pointer to the task which executes this component, is invalid before setTaskIF was called. + * Pointer to the task which executes this component, + * is invalid before setTaskIF was called. */ - PeriodicTaskIF* executingTask; + PeriodicTaskIF* executingTask = nullptr; /** - * Send TM data from pointer to data. If a header is supplied it is added before data + * @brief Send TM data from pointer to data. + * If a header is supplied it is added before data * @param subservice Number of subservice * @param data Pointer to the data in the Packet * @param dataLen Lenght of data in the Packet * @param headerData HeaderData will be placed before data * @param headerSize Size of HeaderData */ - void sendTmPacket(uint8_t subservice, const uint8_t *data, uint32_t dataLen, - const uint8_t* headerData = NULL, uint32_t headerSize = 0); + ReturnValue_t sendTmPacket(uint8_t subservice, const uint8_t *data, + size_t dataLen, const uint8_t* headerData = nullptr, + size_t headerSize = 0); /** - * To send TM packets of objects that still need to be serialized and consist of an object ID with appended data + * @brief To send TM packets of objects that still need to be serialized + * and consist of an object ID with appended data. * @param subservice Number of subservice * @param objectId ObjectId is placed before data * @param data Data to append to the packet * @param dataLen Length of Data */ - void sendTmPacket(uint8_t subservice, object_id_t objectId, - const uint8_t *data, uint32_t dataLen); + ReturnValue_t sendTmPacket(uint8_t subservice, object_id_t objectId, + const uint8_t *data, size_t dataLen); /** - * To send packets has data which is in form of a SerializeIF or Adapters implementing it + * @brief To send packets which are contained inside a class implementing + * SerializeIF. * @param subservice Number of subservice * @param content This is a pointer to the serialized packet * @param header Serialize IF header which will be placed before content */ - void sendTmPacket(uint8_t subservice, SerializeIF* content, - SerializeIF* header = NULL); + ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content, + SerializeIF* header = nullptr); - virtual void handleUnrequestedReply(CommandMessage *reply); - - virtual void doPeriodicOperation(); - - void checkAndExecuteFifo( - typename FixedMap::Iterator *iter); + void checkAndExecuteFifo(CommandMapIter iter); private: /** * This method handles internal execution of a command, - * once it has been started by @sa{startExecution()} in the Request Queue handler. - * It handles replies generated by the devices and relayed by the specific service implementation. - * This means that it determines further course of action depending on the return values specified - * in the service implementation. + * once it has been started by @sa{startExecution()} in the request + * queue handler. + * It handles replies generated by the devices and relayed by the specific + * service implementation. This means that it determines further course of + * action depending on the return values specified in the service + * implementation. * This includes the generation of TC verification messages. Note that - * the static framework object ID @c VerificationReporter::messageReceiver needs to be set. + * the static framework object ID @c VerificationReporter::messageReceiver + * needs to be set. * - TM[1,5] Step Successs * - TM[1,6] Step Failure * - TM[1,7] Completion Success @@ -268,10 +322,13 @@ private: void handleCommandQueue(); /** + * @brief Handler function for request queue + * @details * Sequence of request queue handling: * isValidSubservice -> getMessageQueueAndObject -> startExecution - * Generates Start Success Reports TM[1,3] in subfunction @sa{startExecution()} - * or Start Failure Report TM[1,4] by using the TC Verification Service + * Generates a Start Success Reports TM[1,3] in subfunction + * @sa{startExecution()} or a Start Failure Report TM[1,4] by using the + * TC Verification Service. */ void handleRequestQueue(); @@ -280,8 +337,11 @@ private: void acceptPacket(uint8_t reportId, TcPacketStored* packet); - void startExecution(TcPacketStored *storedPacket, - typename FixedMap::Iterator *iter); + void startExecution(TcPacketStored *storedPacket, CommandMapIter iter); + + void handleCommandMessage(CommandMessage* reply); + void handleReplyHandlerResult(ReturnValue_t result, CommandMapIter iter, + CommandMessage* nextCommand, CommandMessage* reply, bool& isStep); void checkTimeout(); }; From 21984067140f3baf3ecc30db4e1e5d196bae56e6 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Sat, 1 Aug 2020 16:53:17 +0200 Subject: [PATCH 05/12] csb update --- tmtcservices/CommandingServiceBase.cpp | 10 +++++----- tmtcservices/CommandingServiceBase.h | 15 ++++++--------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp index 98cbbe2c..330fd00f 100644 --- a/tmtcservices/CommandingServiceBase.cpp +++ b/tmtcservices/CommandingServiceBase.cpp @@ -126,11 +126,11 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) { &nextCommand, iter->objectId, &isStep); /* If the child implementation does not implement special handling for - * rejected replies (RETURN_FAILED is returned), a failure verification - * will be generated with the reason as the return code and the initial - * command as failure parameter 1 */ - if(reply->getCommand() == CommandMessage::REPLY_REJECTED and - result == RETURN_FAILED) { + * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a + * failure verification will be generated with the reason as the + * return code and the initial command as failure parameter 1 */ + if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and + (result == RETURN_FAILED or result == INVALID_REPLY)) { result = reply->getReplyRejectedReason(); failureParameter1 = iter->command; } diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h index 76eca6b7..9290bb7c 100644 --- a/tmtcservices/CommandingServiceBase.h +++ b/tmtcservices/CommandingServiceBase.h @@ -87,7 +87,7 @@ public: * @param opCode is unused here at the moment * @return RETURN_OK */ - virtual ReturnValue_t performOperation(uint8_t opCode); + virtual ReturnValue_t performOperation(uint8_t opCode) override; virtual uint16_t getIdentifier(); @@ -186,12 +186,11 @@ protected: * @return * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to * generate TC verification success - * - @c INVALID_REPLY calls handleUnrequestedReply - * - Anything else triggers a TC verification failure. If RETURN_FAILED or - * INVALID_REPLY is returned and the command ID is - * CommandMessage::REPLY_REJECTED, a failure verification message - * with the reason as the error parameter and the initial command as - * failure parameter 1 is generated. + * - @c INVALID_REPLY Calls handleUnrequestedReply + * - Anything else triggers a TC verification failure. If RETURN_FAILED is + * returned and the command ID is CommandMessage::REPLY_REJECTED, + * a failure verification message with the reason as the error parameter + * and the initial command as failure parameter 1 */ virtual ReturnValue_t handleReply(const CommandMessage* reply, Command_t previousCommand, uint32_t *state, @@ -254,7 +253,6 @@ protected: uint32_t failureParameter1 = 0; uint32_t failureParameter2 = 0; - object_id_t packetSource; static object_id_t defaultPacketSource; object_id_t packetSource = objects::NO_OBJECT; static object_id_t defaultPacketDestination; @@ -303,7 +301,6 @@ protected: void checkAndExecuteFifo(CommandMapIter iter); private: - /** * This method handles internal execution of a command, * once it has been started by @sa{startExecution()} in the request From d8bf1931ccbbca5d96598905599bdf594e914c7f Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Sat, 1 Aug 2020 16:55:20 +0200 Subject: [PATCH 06/12] doc correction --- tmtcservices/CommandingServiceBase.h | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h index 9290bb7c..b3a15985 100644 --- a/tmtcservices/CommandingServiceBase.h +++ b/tmtcservices/CommandingServiceBase.h @@ -187,10 +187,11 @@ protected: * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to * generate TC verification success * - @c INVALID_REPLY Calls handleUnrequestedReply - * - Anything else triggers a TC verification failure. If RETURN_FAILED is - * returned and the command ID is CommandMessage::REPLY_REJECTED, - * a failure verification message with the reason as the error parameter - * and the initial command as failure parameter 1 + * - Anything else triggers a TC verification failure. If RETURN_FAILED or + * INVALID_REPLY is returned and the command ID is + * CommandMessage::REPLY_REJECTED, a failure verification message with + * the reason as the error parameter and the initial command as + * failure parameter 1 is generated. */ virtual ReturnValue_t handleReply(const CommandMessage* reply, Command_t previousCommand, uint32_t *state, From d58fc5c6f71724221c10968bddad8a3d29e66fe5 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sun, 2 Aug 2020 15:55:56 +0200 Subject: [PATCH 07/12] removed includes in framework.mk --- framework.mk | 2 -- 1 file changed, 2 deletions(-) diff --git a/framework.mk b/framework.mk index 7f27c037..04fac47f 100644 --- a/framework.mk +++ b/framework.mk @@ -8,8 +8,6 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp) -CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoolglob/*.cpp) -CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp) From 6ac36cec1546ba637c822979243ab1fc4a51ba1e Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sun, 2 Aug 2020 15:56:38 +0200 Subject: [PATCH 08/12] removed other include in framework.mk --- framework.mk | 1 - 1 file changed, 1 deletion(-) diff --git a/framework.mk b/framework.mk index 04fac47f..c3917f20 100644 --- a/framework.mk +++ b/framework.mk @@ -8,7 +8,6 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp) -CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp) From ea9288d848d62352c78e81dd98cc6555bb6a12d5 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Tue, 4 Aug 2020 15:17:40 +0200 Subject: [PATCH 09/12] updated subsystem ID range --- events/fwSubsystemIdRanges.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/events/fwSubsystemIdRanges.h b/events/fwSubsystemIdRanges.h index 4c261e57..a05652c2 100644 --- a/events/fwSubsystemIdRanges.h +++ b/events/fwSubsystemIdRanges.h @@ -18,6 +18,8 @@ enum { SYSTEM_MANAGER = 74, SYSTEM_MANAGER_1 = 75, SYSTEM_1 = 79, + PUS_SERVICE_1 = 80, + FW_SUBSYSTEM_ID_RANGE }; } From 3d4daa51d537b0e957644103293b8dbadb773018 Mon Sep 17 00:00:00 2001 From: Steffen Gaisser Date: Tue, 11 Aug 2020 17:17:50 +0200 Subject: [PATCH 10/12] Corrected warning to fit name of setting --- framework.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/framework.mk b/framework.mk index ee0a7ba4..643eb74f 100644 --- a/framework.mk +++ b/framework.mk @@ -34,7 +34,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp) else ifeq ($(OS_FSFW),host) CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp) else -$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host) +$(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host) endif CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp) From d5dedce294d02e2afe44331f455cd65eee00197a Mon Sep 17 00:00:00 2001 From: Steffen Gaisser Date: Thu, 13 Aug 2020 20:53:35 +0200 Subject: [PATCH 11/12] Relative Paths --- action/ActionHelper.cpp | 6 +- action/ActionHelper.h | 6 +- action/ActionMessage.cpp | 6 +- action/ActionMessage.h | 6 +- action/CommandActionHelper.cpp | 10 +- action/CommandActionHelper.h | 12 +- action/CommandsActionsIF.h | 6 +- action/HasActionsIF.h | 10 +- action/SimpleActionHelper.cpp | 4 +- action/SimpleActionHelper.h | 2 +- container/ArrayList.h | 6 +- container/FIFO.h | 2 +- container/FixedArrayList.h | 2 +- container/FixedMap.h | 4 +- container/FixedOrderedMultimap.h | 2 +- container/HybridIterator.h | 4 +- container/IndexedRingMemoryArray.h | 10 +- container/PlacementFactory.h | 2 +- container/RingBufferBase.h | 2 +- container/SimpleRingBuffer.cpp | 2 +- container/SimpleRingBuffer.h | 2 +- controller/ControllerBase.cpp | 10 +- controller/ControllerBase.h | 14 +- coordinates/CoordinateTransformations.cpp | 8 +- coordinates/CoordinateTransformations.h | 2 +- coordinates/Jgm3Model.h | 8 +- coordinates/Sgp4Propagator.cpp | 12 +- coordinates/Sgp4Propagator.h | 2 +- datalinklayer/BCFrame.h | 2 +- datalinklayer/CCSDSReturnValuesIF.h | 2 +- datalinklayer/Clcw.cpp | 4 +- datalinklayer/Clcw.h | 2 +- datalinklayer/DataLinkLayer.cpp | 6 +- datalinklayer/DataLinkLayer.h | 10 +- datalinklayer/Farm1StateIF.h | 2 +- datalinklayer/Farm1StateLockout.cpp | 8 +- datalinklayer/Farm1StateLockout.h | 2 +- datalinklayer/Farm1StateOpen.cpp | 8 +- datalinklayer/Farm1StateOpen.h | 2 +- datalinklayer/Farm1StateWait.cpp | 8 +- datalinklayer/Farm1StateWait.h | 2 +- datalinklayer/MapPacketExtraction.cpp | 14 +- datalinklayer/MapPacketExtraction.h | 8 +- datalinklayer/MapPacketExtractionIF.h | 4 +- datalinklayer/TcTransferFrame.cpp | 4 +- datalinklayer/TcTransferFrameLocal.cpp | 6 +- datalinklayer/TcTransferFrameLocal.h | 2 +- datalinklayer/VirtualChannelReception.cpp | 6 +- datalinklayer/VirtualChannelReception.h | 16 +- datalinklayer/VirtualChannelReceptionIF.h | 6 +- datapool/ControllerSet.cpp | 2 +- datapool/ControllerSet.h | 2 +- datapool/DataPool.cpp | 6 +- datapool/DataPool.h | 6 +- datapool/DataPoolAdmin.cpp | 14 +- datapool/DataPoolAdmin.h | 18 +- datapool/DataPoolParameterWrapper.cpp | 6 +- datapool/DataPoolParameterWrapper.h | 4 +- datapool/DataSet.cpp | 4 +- datapool/DataSet.h | 14 +- datapool/HkSwitchHelper.cpp | 4 +- datapool/HkSwitchHelper.h | 6 +- datapool/PIDReader.h | 12 +- datapool/PIDReaderList.h | 4 +- datapool/PoolEntry.cpp | 6 +- datapool/PoolEntry.h | 2 +- datapool/PoolEntryIF.h | 2 +- datapool/PoolRawAccess.cpp | 10 +- datapool/PoolRawAccess.h | 4 +- datapool/PoolVarList.h | 4 +- datapool/PoolVariable.h | 10 +- datapool/PoolVariableIF.h | 4 +- datapool/PoolVector.h | 10 +- devicehandlers/AcceptsDeviceResponsesIF.h | 2 +- devicehandlers/AssemblyBase.cpp | 2 +- devicehandlers/AssemblyBase.h | 6 +- devicehandlers/ChildHandlerBase.cpp | 6 +- devicehandlers/ChildHandlerBase.h | 4 +- devicehandlers/ChildHandlerFDIR.cpp | 2 +- devicehandlers/ChildHandlerFDIR.h | 2 +- devicehandlers/DeviceCommunicationIF.h | 4 +- devicehandlers/DeviceHandlerBase.cpp | 24 +- devicehandlers/DeviceHandlerBase.h | 30 +- .../DeviceHandlerFailureIsolation.cpp | 12 +- .../DeviceHandlerFailureIsolation.h | 4 +- devicehandlers/DeviceHandlerIF.h | 10 +- devicehandlers/DeviceHandlerMessage.cpp | 6 +- devicehandlers/DeviceHandlerMessage.h | 8 +- devicehandlers/DeviceTmReportingWrapper.cpp | 6 +- devicehandlers/DeviceTmReportingWrapper.h | 6 +- devicehandlers/FixedSequenceSlot.cpp | 4 +- devicehandlers/FixedSequenceSlot.h | 4 +- devicehandlers/FixedSlotSequence.cpp | 4 +- devicehandlers/FixedSlotSequence.h | 4 +- devicehandlers/HealthDevice.cpp | 4 +- devicehandlers/HealthDevice.h | 10 +- events/Event.cpp | 2 +- events/Event.h | 2 +- events/EventManager.cpp | 10 +- events/EventManager.h | 14 +- events/EventManagerIF.h | 8 +- events/EventMessage.cpp | 2 +- events/EventMessage.h | 6 +- events/EventReportingProxyIF.h | 2 +- events/eventmatching/EventIdRangeMatcher.cpp | 2 +- events/eventmatching/EventIdRangeMatcher.h | 2 +- events/eventmatching/EventMatchTree.cpp | 8 +- events/eventmatching/EventMatchTree.h | 8 +- events/eventmatching/EventRangeMatcherBase.h | 6 +- events/eventmatching/ReporterRangeMatcher.cpp | 2 +- events/eventmatching/ReporterRangeMatcher.h | 2 +- events/eventmatching/SeverityRangeMatcher.cpp | 6 +- events/eventmatching/SeverityRangeMatcher.h | 2 +- events/eventmatching/eventmatching.h | 8 +- fdir/ConfirmsFailuresIF.h | 4 +- fdir/EventCorrelation.cpp | 2 +- fdir/EventCorrelation.h | 2 +- fdir/FailureIsolationBase.cpp | 12 +- fdir/FailureIsolationBase.h | 14 +- fdir/FaultCounter.cpp | 2 +- fdir/FaultCounter.h | 4 +- globalfunctions/AsciiConverter.cpp | 2 +- globalfunctions/AsciiConverter.h | 2 +- globalfunctions/CRC.cpp | 2 +- globalfunctions/DleEncoder.cpp | 2 +- globalfunctions/DleEncoder.h | 2 +- globalfunctions/Type.cpp | 6 +- globalfunctions/Type.h | 4 +- globalfunctions/arrayprinter.cpp | 4 +- globalfunctions/matching/BinaryMatcher.h | 2 +- globalfunctions/matching/DecimalMatcher.h | 2 +- globalfunctions/matching/MatchTree.h | 6 +- globalfunctions/matching/RangeMatcher.h | 4 +- .../matching/SerializeableMatcherIF.h | 4 +- globalfunctions/math/QuaternionOperations.cpp | 2 +- globalfunctions/timevalOperations.cpp | 2 +- health/HasHealthIF.h | 6 +- health/HealthHelper.cpp | 6 +- health/HealthHelper.h | 14 +- health/HealthMessage.cpp | 2 +- health/HealthMessage.h | 4 +- health/HealthTable.cpp | 6 +- health/HealthTable.h | 6 +- health/HealthTableIF.h | 6 +- health/ManagesHealthIF.h | 4 +- internalError/InternalErrorReporter.cpp | 8 +- internalError/InternalErrorReporter.h | 6 +- ipc/CommandMessage.cpp | 18 +- ipc/CommandMessage.h | 4 +- ipc/MessageQueueIF.h | 6 +- ipc/MessageQueueMessage.cpp | 4 +- ipc/MessageQueueMessage.h | 2 +- ipc/MessageQueueSenderIF.h | 2 +- ipc/MutexFactory.h | 2 +- ipc/MutexHelper.h | 4 +- ipc/MutexIF.h | 2 +- ipc/QueueFactory.h | 2 +- memory/AcceptsMemoryMessagesIF.h | 6 +- memory/HasMemoryIF.h | 2 +- memory/MemoryHelper.cpp | 12 +- memory/MemoryHelper.h | 10 +- memory/MemoryMessage.cpp | 4 +- memory/MemoryMessage.h | 4 +- memory/MemoryProxyIF.h | 2 +- modes/HasModesIF.h | 8 +- modes/ModeHelper.cpp | 6 +- modes/ModeHelper.h | 6 +- modes/ModeMessage.cpp | 2 +- modes/ModeMessage.h | 2 +- monitoring/AbsLimitMonitor.h | 2 +- monitoring/HasMonitorsIF.h | 6 +- monitoring/LimitMonitor.h | 2 +- monitoring/LimitViolationReporter.cpp | 10 +- monitoring/LimitViolationReporter.h | 8 +- monitoring/MonitorBase.h | 12 +- monitoring/MonitorReporter.h | 10 +- monitoring/MonitoringIF.h | 6 +- monitoring/MonitoringMessage.cpp | 4 +- monitoring/MonitoringMessage.h | 4 +- monitoring/MonitoringMessageContent.h | 18 +- monitoring/ReceivesMonitoringReportsIF.h | 2 +- monitoring/TriplexMonitor.h | 10 +- monitoring/TwoValueLimitMonitor.h | 2 +- objectmanager/ObjectManager.cpp | 4 +- objectmanager/ObjectManager.h | 4 +- objectmanager/ObjectManagerIF.h | 8 +- objectmanager/SystemObject.cpp | 6 +- objectmanager/SystemObject.h | 8 +- objectmanager/SystemObjectIF.h | 4 +- osal/FreeRTOS/Clock.cpp | 6 +- osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +- osal/FreeRTOS/FixedTimeslotTask.h | 6 +- osal/FreeRTOS/MessageQueue.cpp | 2 +- osal/FreeRTOS/MessageQueue.h | 6 +- osal/FreeRTOS/Mutex.cpp | 2 +- osal/FreeRTOS/Mutex.h | 2 +- osal/FreeRTOS/MutexFactory.cpp | 2 +- osal/FreeRTOS/PeriodicTask.cpp | 4 +- osal/FreeRTOS/PeriodicTask.h | 6 +- osal/FreeRTOS/QueueFactory.cpp | 4 +- osal/FreeRTOS/TaskFactory.cpp | 4 +- osal/FreeRTOS/Timekeeper.cpp | 2 +- osal/FreeRTOS/Timekeeper.h | 2 +- osal/InternalErrorCodes.h | 2 +- osal/linux/Clock.cpp | 4 +- osal/linux/FixedTimeslotTask.cpp | 4 +- osal/linux/FixedTimeslotTask.h | 6 +- osal/linux/InternalErrorCodes.cpp | 2 +- osal/linux/MessageQueue.cpp | 4 +- osal/linux/MessageQueue.h | 6 +- osal/linux/Mutex.cpp | 6 +- osal/linux/Mutex.h | 2 +- osal/linux/MutexFactory.cpp | 4 +- osal/linux/PeriodicPosixTask.cpp | 6 +- osal/linux/PeriodicPosixTask.h | 8 +- osal/linux/PosixThread.cpp | 4 +- osal/linux/PosixThread.h | 2 +- osal/linux/QueueFactory.cpp | 6 +- osal/linux/TaskFactory.cpp | 8 +- osal/linux/Timer.cpp | 4 +- osal/rtems/Clock.cpp | 2 +- osal/rtems/CpuUsage.cpp | 4 +- osal/rtems/CpuUsage.h | 4 +- osal/rtems/InternalErrorCodes.cpp | 2 +- osal/rtems/Interrupt.h | 2 +- osal/rtems/MessageQueue.cpp | 2 +- osal/rtems/MessageQueue.h | 6 +- osal/rtems/MultiObjectTask.cpp | 4 +- osal/rtems/MultiObjectTask.h | 4 +- osal/rtems/Mutex.cpp | 2 +- osal/rtems/Mutex.h | 2 +- osal/rtems/MutexFactory.cpp | 2 +- osal/rtems/PollingTask.cpp | 12 +- osal/rtems/PollingTask.h | 4 +- osal/rtems/QueueFactory.cpp | 2 +- osal/rtems/RtemsBasic.h | 2 +- osal/rtems/TaskBase.cpp | 2 +- osal/rtems/TaskBase.h | 2 +- osal/rtems/TaskFactory.cpp | 4 +- parameters/HasParametersIF.h | 4 +- parameters/ParameterHelper.cpp | 6 +- parameters/ParameterHelper.h | 4 +- parameters/ParameterMessage.cpp | 4 +- parameters/ParameterMessage.h | 6 +- parameters/ParameterWrapper.cpp | 2 +- parameters/ParameterWrapper.h | 8 +- parameters/ReceivesParameterMessagesIF.h | 4 +- power/Fuse.cpp | 12 +- power/Fuse.h | 16 +- power/PowerComponent.cpp | 2 +- power/PowerComponent.h | 4 +- power/PowerComponentIF.h | 4 +- power/PowerSensor.cpp | 4 +- power/PowerSensor.h | 16 +- power/PowerSwitchIF.h | 4 +- power/PowerSwitcher.cpp | 6 +- power/PowerSwitcher.h | 6 +- pus/CService200ModeCommanding.cpp | 238 +++++----- pus/CService200ModeCommanding.h | 170 +++---- pus/Service1TelecommandVerification.cpp | 16 +- pus/Service1TelecommandVerification.h | 12 +- pus/Service2DeviceAccess.cpp | 334 +++++++------- pus/Service2DeviceAccess.h | 184 ++++---- pus/Service5EventReporting.cpp | 12 +- pus/Service5EventReporting.h | 4 +- pus/Service8FunctionManagement.cpp | 284 ++++++------ pus/Service8FunctionManagement.h | 134 +++--- pus/servicepackets/Service1Packets.h | 4 +- pus/servicepackets/Service200Packets.h | 126 +++--- pus/servicepackets/Service2Packets.h | 152 +++---- pus/servicepackets/Service5Packets.h | 4 +- pus/servicepackets/Service8Packets.h | 242 +++++----- returnvalues/HasReturnvaluesIF.h | 2 +- rmap/RMAP.cpp | 8 +- rmap/RMAP.h | 4 +- rmap/RMAPChannelIF.h | 4 +- rmap/RMAPCookie.cpp | 4 +- rmap/RMAPCookie.h | 4 +- rmap/RmapDeviceCommunicationIF.cpp | 4 +- rmap/RmapDeviceCommunicationIF.h | 2 +- serialize/EndianConverter.h | 2 +- serialize/SerialArrayListAdapter.h | 4 +- serialize/SerialBufferAdapter.cpp | 2 +- serialize/SerialBufferAdapter.h | 4 +- serialize/SerialFixedArrayListAdapter.h | 4 +- serialize/SerialLinkedListAdapter.h | 8 +- serialize/SerializeAdapter.h | 8 +- serialize/SerializeElement.h | 4 +- serialize/SerializeIF.h | 2 +- serviceinterface/ServiceInterfaceBuffer.cpp | 6 +- serviceinterface/ServiceInterfaceBuffer.h | 2 +- serviceinterface/ServiceInterfaceStream.cpp | 2 +- serviceinterface/ServiceInterfaceStream.h | 2 +- storagemanager/LocalPool.h | 12 +- storagemanager/PoolManager.h | 4 +- storagemanager/StorageManagerIF.h | 4 +- subsystem/Subsystem.cpp | 14 +- subsystem/Subsystem.h | 14 +- subsystem/SubsystemBase.cpp | 8 +- subsystem/SubsystemBase.h | 18 +- subsystem/modes/HasModeSequenceIF.h | 6 +- subsystem/modes/ModeDefinitions.h | 8 +- subsystem/modes/ModeSequenceMessage.cpp | 10 +- subsystem/modes/ModeSequenceMessage.h | 6 +- subsystem/modes/ModeStore.cpp | 2 +- subsystem/modes/ModeStore.h | 8 +- subsystem/modes/ModeStoreIF.h | 8 +- tasks/ExecutableObjectIF.h | 2 +- tasks/FixedTimeslotTaskIF.h | 4 +- tasks/PeriodicTaskIF.h | 4 +- tasks/TaskFactory.h | 4 +- tcdistribution/CCSDSDistributor.cpp | 6 +- tcdistribution/CCSDSDistributor.h | 10 +- tcdistribution/CCSDSDistributorIF.h | 4 +- tcdistribution/PUSDistributor.cpp | 10 +- tcdistribution/PUSDistributor.h | 12 +- tcdistribution/PUSDistributorIF.h | 4 +- tcdistribution/TcDistributor.cpp | 10 +- tcdistribution/TcDistributor.h | 14 +- tcdistribution/TcPacketCheck.cpp | 10 +- tcdistribution/TcPacketCheck.h | 6 +- thermal/AbstractTemperatureSensor.cpp | 2 +- thermal/AbstractTemperatureSensor.h | 12 +- thermal/CoreComponent.h | 12 +- thermal/Heater.cpp | 6 +- thermal/Heater.h | 10 +- thermal/RedundantHeater.h | 2 +- thermal/TemperatureSensor.h | 4 +- thermal/ThermalComponentIF.h | 8 +- thermal/ThermalModule.cpp | 4 +- thermal/ThermalModule.h | 8 +- thermal/ThermalMonitor.cpp | 6 +- thermal/ThermalMonitor.h | 4 +- timemanager/CCSDSTime.cpp | 2 +- timemanager/CCSDSTime.h | 4 +- timemanager/Clock.h | 6 +- timemanager/Countdown.cpp | 2 +- timemanager/Countdown.h | 2 +- timemanager/Stopwatch.cpp | 114 ++--- timemanager/Stopwatch.h | 142 +++--- timemanager/TimeMessage.cpp | 2 +- timemanager/TimeMessage.h | 4 +- timemanager/TimeStamperIF.h | 2 +- tmstorage/TmStoreBackendIF.h | 10 +- tmstorage/TmStoreFrontendIF.h | 6 +- tmstorage/TmStoreMessage.cpp | 4 +- tmstorage/TmStoreMessage.h | 8 +- tmstorage/TmStorePackets.h | 16 +- tmtcpacket/SpacePacket.cpp | 6 +- tmtcpacket/SpacePacket.h | 2 +- tmtcpacket/SpacePacketBase.cpp | 4 +- tmtcpacket/SpacePacketBase.h | 2 +- tmtcpacket/packetmatcher/ApidMatcher.h | 6 +- tmtcpacket/packetmatcher/PacketMatchTree.cpp | 8 +- tmtcpacket/packetmatcher/PacketMatchTree.h | 8 +- tmtcpacket/packetmatcher/ServiceMatcher.h | 6 +- tmtcpacket/packetmatcher/SubserviceMatcher.h | 6 +- tmtcpacket/pus/PacketTimestampInterpreterIF.h | 2 +- tmtcpacket/pus/TcPacketBase.cpp | 6 +- tmtcpacket/pus/TcPacketBase.h | 2 +- tmtcpacket/pus/TcPacketStored.cpp | 6 +- tmtcpacket/pus/TcPacketStored.h | 4 +- tmtcpacket/pus/TmPacketBase.cpp | 10 +- tmtcpacket/pus/TmPacketBase.h | 8 +- tmtcpacket/pus/TmPacketMinimal.cpp | 4 +- tmtcpacket/pus/TmPacketMinimal.h | 4 +- tmtcpacket/pus/TmPacketStored.cpp | 8 +- tmtcpacket/pus/TmPacketStored.h | 10 +- tmtcservices/AcceptsTelecommandsIF.h | 2 +- tmtcservices/AcceptsTelemetryIF.h | 2 +- tmtcservices/AcceptsVerifyMessageIF.h | 2 +- tmtcservices/CommandingServiceBase.cpp | 16 +- tmtcservices/CommandingServiceBase.h | 20 +- tmtcservices/PusServiceBase.cpp | 14 +- tmtcservices/PusServiceBase.h | 18 +- tmtcservices/PusVerificationReport.cpp | 4 +- tmtcservices/PusVerificationReport.h | 6 +- tmtcservices/SourceSequenceCounter.h | 2 +- tmtcservices/TmTcBridge.cpp | 414 +++++++++--------- tmtcservices/TmTcBridge.h | 308 ++++++------- tmtcservices/TmTcMessage.cpp | 2 +- tmtcservices/TmTcMessage.h | 4 +- tmtcservices/VerificationReporter.cpp | 8 +- tmtcservices/VerificationReporter.h | 4 +- 384 files changed, 2477 insertions(+), 2477 deletions(-) diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp index dc6bd498..b43c676d 100644 --- a/action/ActionHelper.cpp +++ b/action/ActionHelper.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "ActionHelper.h" +#include "HasActionsIF.h" +#include "../objectmanager/ObjectManagerIF.h" ActionHelper::ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) : owner(setOwner), queueToUse(useThisQueue), ipcStore(nullptr) { diff --git a/action/ActionHelper.h b/action/ActionHelper.h index eb3bfa54..bbc6d114 100644 --- a/action/ActionHelper.h +++ b/action/ActionHelper.h @@ -1,9 +1,9 @@ #ifndef ACTIONHELPER_H_ #define ACTIONHELPER_H_ -#include -#include -#include +#include "ActionMessage.h" +#include "../serialize/SerializeIF.h" +#include "../ipc/MessageQueueIF.h" /** * \brief Action Helper is a helper class which handles action messages * diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp index 96ff59b6..b0bcabaa 100644 --- a/action/ActionMessage.cpp +++ b/action/ActionMessage.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "ActionMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../storagemanager/StorageManagerIF.h" ActionMessage::ActionMessage() { } diff --git a/action/ActionMessage.h b/action/ActionMessage.h index 5d8332cb..c564911c 100644 --- a/action/ActionMessage.h +++ b/action/ActionMessage.h @@ -1,9 +1,9 @@ #ifndef ACTIONMESSAGE_H_ #define ACTIONMESSAGE_H_ -#include -#include -#include +#include "../ipc/CommandMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../storagemanager/StorageManagerIF.h" typedef uint32_t ActionId_t; class ActionMessage { diff --git a/action/CommandActionHelper.cpp b/action/CommandActionHelper.cpp index 70ffbbde..4e88f3c3 100644 --- a/action/CommandActionHelper.cpp +++ b/action/CommandActionHelper.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "ActionMessage.h" +#include "CommandActionHelper.h" +#include "CommandsActionsIF.h" +#include "HasActionsIF.h" +#include "../objectmanager/ObjectManagerIF.h" CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) : owner(setOwner), queueToUse(NULL), ipcStore( diff --git a/action/CommandActionHelper.h b/action/CommandActionHelper.h index 24d0380c..cfed8c94 100644 --- a/action/CommandActionHelper.h +++ b/action/CommandActionHelper.h @@ -1,12 +1,12 @@ #ifndef COMMANDACTIONHELPER_H_ #define COMMANDACTIONHELPER_H_ -#include -#include -#include -#include -#include -#include +#include "ActionMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../ipc/MessageQueueIF.h" class CommandsActionsIF; diff --git a/action/CommandsActionsIF.h b/action/CommandsActionsIF.h index db76fb50..3d04015d 100644 --- a/action/CommandsActionsIF.h +++ b/action/CommandsActionsIF.h @@ -1,9 +1,9 @@ #ifndef COMMANDSACTIONSIF_H_ #define COMMANDSACTIONSIF_H_ -#include -#include -#include +#include "CommandActionHelper.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueIF.h" /** * Interface to separate commanding actions of other objects. diff --git a/action/HasActionsIF.h b/action/HasActionsIF.h index 008d9eaf..886d0837 100644 --- a/action/HasActionsIF.h +++ b/action/HasActionsIF.h @@ -1,11 +1,11 @@ #ifndef FRAMEWORK_ACTION_HASACTIONSIF_H_ #define FRAMEWORK_ACTION_HASACTIONSIF_H_ -#include -#include -#include -#include -#include +#include "ActionHelper.h" +#include "ActionMessage.h" +#include "SimpleActionHelper.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueIF.h" /** * @brief * Interface for component which uses actions diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp index 6861fc28..d79a3c97 100644 --- a/action/SimpleActionHelper.cpp +++ b/action/SimpleActionHelper.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "HasActionsIF.h" +#include "SimpleActionHelper.h" SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue) : ActionHelper(setOwner, useThisQueue), isExecuting(false), lastCommander( diff --git a/action/SimpleActionHelper.h b/action/SimpleActionHelper.h index 71e73c5a..1329b5fb 100644 --- a/action/SimpleActionHelper.h +++ b/action/SimpleActionHelper.h @@ -1,7 +1,7 @@ #ifndef SIMPLEACTIONHELPER_H_ #define SIMPLEACTIONHELPER_H_ -#include +#include "ActionHelper.h" class SimpleActionHelper: public ActionHelper { public: diff --git a/container/ArrayList.h b/container/ArrayList.h index 9c4c4ceb..018f9894 100644 --- a/container/ArrayList.h +++ b/container/ArrayList.h @@ -1,9 +1,9 @@ #ifndef ARRAYLIST_H_ #define ARRAYLIST_H_ -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serialize/SerializeIF.h" /** * A List that stores its values in an array. diff --git a/container/FIFO.h b/container/FIFO.h index f70c78b0..3172d9d1 100644 --- a/container/FIFO.h +++ b/container/FIFO.h @@ -1,7 +1,7 @@ #ifndef FIFO_H_ #define FIFO_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" /** * @brief Simple First-In-First-Out data structure diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h index eeffcc87..42b59177 100644 --- a/container/FixedArrayList.h +++ b/container/FixedArrayList.h @@ -1,7 +1,7 @@ #ifndef FIXEDARRAYLIST_H_ #define FIXEDARRAYLIST_H_ -#include +#include "ArrayList.h" /** * \ingroup container */ diff --git a/container/FixedMap.h b/container/FixedMap.h index ac170bd2..dc19ce53 100644 --- a/container/FixedMap.h +++ b/container/FixedMap.h @@ -1,8 +1,8 @@ #ifndef FIXEDMAP_H_ #define FIXEDMAP_H_ -#include -#include +#include "ArrayList.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include /** diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h index 21629664..6152d8d7 100644 --- a/container/FixedOrderedMultimap.h +++ b/container/FixedOrderedMultimap.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ #define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_H_ -#include +#include "ArrayList.h" #include #include /** diff --git a/container/HybridIterator.h b/container/HybridIterator.h index f2fd6b28..8d020cb9 100644 --- a/container/HybridIterator.h +++ b/container/HybridIterator.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ #define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ -#include -#include +#include "ArrayList.h" +#include "SinglyLinkedList.h" template class HybridIterator: public LinkedElement::Iterator, diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h index 6e7f330c..0d85b49b 100644 --- a/container/IndexedRingMemoryArray.h +++ b/container/IndexedRingMemoryArray.h @@ -1,11 +1,11 @@ #ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ #define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ -#include -#include -#include -#include -#include +#include "ArrayList.h" +#include "../globalfunctions/CRC.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerialArrayListAdapter.h" #include template diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h index daf4ee20..05538478 100644 --- a/container/PlacementFactory.h +++ b/container/PlacementFactory.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ #define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ -#include +#include "../storagemanager/StorageManagerIF.h" #include class PlacementFactory { diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h index 3ef782d8..e3a87d9d 100644 --- a/container/RingBufferBase.h +++ b/container/RingBufferBase.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ #define FRAMEWORK_CONTAINER_RINGBUFFERBASE_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" template class RingBufferBase { diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp index 63dc3514..ee087643 100644 --- a/container/SimpleRingBuffer.cpp +++ b/container/SimpleRingBuffer.cpp @@ -1,4 +1,4 @@ -#include +#include "SimpleRingBuffer.h" #include SimpleRingBuffer::SimpleRingBuffer(uint32_t size, bool overwriteOld) : diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h index 6d7d67e1..5d4fecab 100644 --- a/container/SimpleRingBuffer.h +++ b/container/SimpleRingBuffer.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ #define FRAMEWORK_CONTAINER_SIMPLERINGBUFFER_H_ -#include +#include "RingBufferBase.h" #include class SimpleRingBuffer: public RingBufferBase<> { diff --git a/controller/ControllerBase.cpp b/controller/ControllerBase.cpp index 7b11bdfa..69551731 100644 --- a/controller/ControllerBase.cpp +++ b/controller/ControllerBase.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../subsystem/SubsystemBase.h" +#include "ControllerBase.h" +#include "../subsystem/SubsystemBase.h" +#include "../ipc/QueueFactory.h" +#include "../action/HasActionsIF.h" ControllerBase::ControllerBase(uint32_t setObjectId, uint32_t parentId, size_t commandQueueDepth) : diff --git a/controller/ControllerBase.h b/controller/ControllerBase.h index 804bc7c2..f5182ceb 100644 --- a/controller/ControllerBase.h +++ b/controller/ControllerBase.h @@ -1,13 +1,13 @@ #ifndef CONTROLLERBASE_H_ #define CONTROLLERBASE_H_ -#include -#include -#include -#include -#include -#include -#include +#include "../health/HasHealthIF.h" +#include "../health/HealthHelper.h" +#include "../modes/HasModesIF.h" +#include "../modes/ModeHelper.h" +#include "../objectmanager/SystemObject.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../datapool/HkSwitchHelper.h" class ControllerBase: public HasModesIF, diff --git a/coordinates/CoordinateTransformations.cpp b/coordinates/CoordinateTransformations.cpp index b57519a3..4e2debbe 100644 --- a/coordinates/CoordinateTransformations.cpp +++ b/coordinates/CoordinateTransformations.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "CoordinateTransformations.h" +#include "../globalfunctions/constants.h" +#include "../globalfunctions/math/MatrixOperations.h" +#include "../globalfunctions/math/VectorOperations.h" #include #include diff --git a/coordinates/CoordinateTransformations.h b/coordinates/CoordinateTransformations.h index b072271f..09ea2c48 100644 --- a/coordinates/CoordinateTransformations.h +++ b/coordinates/CoordinateTransformations.h @@ -1,7 +1,7 @@ #ifndef COORDINATETRANSFORMATIONS_H_ #define COORDINATETRANSFORMATIONS_H_ -#include +#include "../timemanager/Clock.h" #include class CoordinateTransformations { diff --git a/coordinates/Jgm3Model.h b/coordinates/Jgm3Model.h index 8f0598f8..884ed141 100644 --- a/coordinates/Jgm3Model.h +++ b/coordinates/Jgm3Model.h @@ -2,10 +2,10 @@ #define FRAMEWORK_COORDINATES_JGM3MODEL_H_ #include -#include -#include -#include -#include +#include "CoordinateTransformations.h" +#include "../globalfunctions/math/VectorOperations.h" +#include "../globalfunctions/timevalOperations.h" +#include "../globalfunctions/constants.h" #include diff --git a/coordinates/Sgp4Propagator.cpp b/coordinates/Sgp4Propagator.cpp index 0eb20f08..5cb1497c 100644 --- a/coordinates/Sgp4Propagator.cpp +++ b/coordinates/Sgp4Propagator.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "CoordinateTransformations.h" +#include "Sgp4Propagator.h" +#include "../globalfunctions/constants.h" +#include "../globalfunctions/math/MatrixOperations.h" +#include "../globalfunctions/math/VectorOperations.h" +#include "../globalfunctions/timevalOperations.h" #include Sgp4Propagator::Sgp4Propagator() : initialized(false), epoch({0, 0}), whichconst(wgs84) { diff --git a/coordinates/Sgp4Propagator.h b/coordinates/Sgp4Propagator.h index 95739762..3949547e 100644 --- a/coordinates/Sgp4Propagator.h +++ b/coordinates/Sgp4Propagator.h @@ -3,7 +3,7 @@ #include #include "../contrib/sgp4/sgp4unit.h" -#include +#include "../returnvalues/HasReturnvaluesIF.h" class Sgp4Propagator { public: diff --git a/datalinklayer/BCFrame.h b/datalinklayer/BCFrame.h index bcdf5300..b7795556 100644 --- a/datalinklayer/BCFrame.h +++ b/datalinklayer/BCFrame.h @@ -8,7 +8,7 @@ #ifndef BCFRAME_H_ #define BCFRAME_H_ -#include +#include "CCSDSReturnValuesIF.h" /** * Small helper class to identify a BcFrame. diff --git a/datalinklayer/CCSDSReturnValuesIF.h b/datalinklayer/CCSDSReturnValuesIF.h index 4d4f4bde..805b6969 100644 --- a/datalinklayer/CCSDSReturnValuesIF.h +++ b/datalinklayer/CCSDSReturnValuesIF.h @@ -8,7 +8,7 @@ #ifndef CCSDSRETURNVALUESIF_H_ #define CCSDSRETURNVALUESIF_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" /** * This is a helper class to collect special return values that come up during CCSDS Handling. * @ingroup ccsds_handling diff --git a/datalinklayer/Clcw.cpp b/datalinklayer/Clcw.cpp index ee497e20..dc435a2b 100644 --- a/datalinklayer/Clcw.cpp +++ b/datalinklayer/Clcw.cpp @@ -7,8 +7,8 @@ -#include -#include +#include "Clcw.h" +#include "../serviceinterface/ServiceInterfaceStream.h" Clcw::Clcw() { content.raw = 0; diff --git a/datalinklayer/Clcw.h b/datalinklayer/Clcw.h index f19f37b6..8116d63b 100644 --- a/datalinklayer/Clcw.h +++ b/datalinklayer/Clcw.h @@ -8,7 +8,7 @@ #ifndef CLCW_H_ #define CLCW_H_ -#include +#include "ClcwIF.h" /** * Small helper method to handle the Clcw values. * It has a content struct that manages the register and can be set externally. diff --git a/datalinklayer/DataLinkLayer.cpp b/datalinklayer/DataLinkLayer.cpp index 4ca7f270..75f2edda 100644 --- a/datalinklayer/DataLinkLayer.cpp +++ b/datalinklayer/DataLinkLayer.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "DataLinkLayer.h" +#include "../globalfunctions/CRC.h" +#include "../serviceinterface/ServiceInterfaceStream.h" DataLinkLayer::DataLinkLayer(uint8_t* set_frame_buffer, ClcwIF* setClcw, uint8_t set_start_sequence_length, uint16_t set_scid) : diff --git a/datalinklayer/DataLinkLayer.h b/datalinklayer/DataLinkLayer.h index 8a3bb8e5..5a900099 100644 --- a/datalinklayer/DataLinkLayer.h +++ b/datalinklayer/DataLinkLayer.h @@ -1,11 +1,11 @@ #ifndef DATALINKLAYER_H_ #define DATALINKLAYER_H_ -#include -#include -#include -#include -#include +#include "CCSDSReturnValuesIF.h" +#include "ClcwIF.h" +#include "TcTransferFrame.h" +#include "VirtualChannelReceptionIF.h" +#include "../events/Event.h" #include diff --git a/datalinklayer/Farm1StateIF.h b/datalinklayer/Farm1StateIF.h index 25836e6a..71794d75 100644 --- a/datalinklayer/Farm1StateIF.h +++ b/datalinklayer/Farm1StateIF.h @@ -8,7 +8,7 @@ #ifndef FARM1STATEIF_H_ #define FARM1STATEIF_H_ -#include +#include "CCSDSReturnValuesIF.h" class VirtualChannelReception; class TcTransferFrame; class ClcwIF; diff --git a/datalinklayer/Farm1StateLockout.cpp b/datalinklayer/Farm1StateLockout.cpp index 45ae47f9..1b339a85 100644 --- a/datalinklayer/Farm1StateLockout.cpp +++ b/datalinklayer/Farm1StateLockout.cpp @@ -7,10 +7,10 @@ -#include -#include -#include -#include +#include "ClcwIF.h" +#include "Farm1StateLockout.h" +#include "TcTransferFrame.h" +#include "VirtualChannelReception.h" Farm1StateLockout::Farm1StateLockout(VirtualChannelReception* setMyVC) : myVC(setMyVC) { } diff --git a/datalinklayer/Farm1StateLockout.h b/datalinklayer/Farm1StateLockout.h index aac8ed74..63cdc4d2 100644 --- a/datalinklayer/Farm1StateLockout.h +++ b/datalinklayer/Farm1StateLockout.h @@ -8,7 +8,7 @@ #ifndef FARM1STATELOCKOUT_H_ #define FARM1STATELOCKOUT_H_ -#include +#include "Farm1StateIF.h" /** * This class represents the FARM-1 "Lockout" State. diff --git a/datalinklayer/Farm1StateOpen.cpp b/datalinklayer/Farm1StateOpen.cpp index b06cff48..61c0997f 100644 --- a/datalinklayer/Farm1StateOpen.cpp +++ b/datalinklayer/Farm1StateOpen.cpp @@ -8,10 +8,10 @@ -#include -#include -#include -#include +#include "ClcwIF.h" +#include "Farm1StateOpen.h" +#include "TcTransferFrame.h" +#include "VirtualChannelReception.h" Farm1StateOpen::Farm1StateOpen(VirtualChannelReception* setMyVC) : myVC(setMyVC) { } diff --git a/datalinklayer/Farm1StateOpen.h b/datalinklayer/Farm1StateOpen.h index 09caacbb..3b3a2604 100644 --- a/datalinklayer/Farm1StateOpen.h +++ b/datalinklayer/Farm1StateOpen.h @@ -8,7 +8,7 @@ #ifndef FARM1STATEOPEN_H_ #define FARM1STATEOPEN_H_ -#include +#include "Farm1StateIF.h" /** * This class represents the FARM-1 "Open" State. diff --git a/datalinklayer/Farm1StateWait.cpp b/datalinklayer/Farm1StateWait.cpp index 1c72e68f..9001e1f5 100644 --- a/datalinklayer/Farm1StateWait.cpp +++ b/datalinklayer/Farm1StateWait.cpp @@ -6,10 +6,10 @@ */ -#include -#include -#include -#include +#include "ClcwIF.h" +#include "Farm1StateWait.h" +#include "TcTransferFrame.h" +#include "VirtualChannelReception.h" Farm1StateWait::Farm1StateWait(VirtualChannelReception* setMyVC) : myVC(setMyVC) { } diff --git a/datalinklayer/Farm1StateWait.h b/datalinklayer/Farm1StateWait.h index f1201791..877c36c2 100644 --- a/datalinklayer/Farm1StateWait.h +++ b/datalinklayer/Farm1StateWait.h @@ -8,7 +8,7 @@ #ifndef FARM1STATEWAIT_H_ #define FARM1STATEWAIT_H_ -#include +#include "Farm1StateIF.h" /** * This class represents the FARM-1 "Wait" State. diff --git a/datalinklayer/MapPacketExtraction.cpp b/datalinklayer/MapPacketExtraction.cpp index 11b0792a..cb12b321 100644 --- a/datalinklayer/MapPacketExtraction.cpp +++ b/datalinklayer/MapPacketExtraction.cpp @@ -5,13 +5,13 @@ * @author baetz */ -#include -#include -#include -#include -#include -#include -#include +#include "MapPacketExtraction.h" +#include "../ipc/QueueFactory.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../tmtcpacket/SpacePacketBase.h" +#include "../tmtcservices/AcceptsTelecommandsIF.h" +#include "../tmtcservices/TmTcMessage.h" #include MapPacketExtraction::MapPacketExtraction(uint8_t setMapId, diff --git a/datalinklayer/MapPacketExtraction.h b/datalinklayer/MapPacketExtraction.h index 5a32366c..507f13db 100644 --- a/datalinklayer/MapPacketExtraction.h +++ b/datalinklayer/MapPacketExtraction.h @@ -8,10 +8,10 @@ #ifndef MAPPACKETEXTRACTION_H_ #define MAPPACKETEXTRACTION_H_ -#include -#include -#include -#include +#include "MapPacketExtractionIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueSenderIF.h" class StorageManagerIF; diff --git a/datalinklayer/MapPacketExtractionIF.h b/datalinklayer/MapPacketExtractionIF.h index 802a893d..e29ac666 100644 --- a/datalinklayer/MapPacketExtractionIF.h +++ b/datalinklayer/MapPacketExtractionIF.h @@ -8,8 +8,8 @@ #ifndef MAPPACKETEXTRACTIONIF_H_ #define MAPPACKETEXTRACTIONIF_H_ -#include -#include +#include "CCSDSReturnValuesIF.h" +#include "TcTransferFrame.h" /** * This is the interface for MAP Packet Extraction classes. diff --git a/datalinklayer/TcTransferFrame.cpp b/datalinklayer/TcTransferFrame.cpp index 30398e9b..f1a70bdc 100644 --- a/datalinklayer/TcTransferFrame.cpp +++ b/datalinklayer/TcTransferFrame.cpp @@ -7,8 +7,8 @@ -#include -#include +#include "TcTransferFrame.h" +#include "../serviceinterface/ServiceInterfaceStream.h" TcTransferFrame::TcTransferFrame() { frame = NULL; diff --git a/datalinklayer/TcTransferFrameLocal.cpp b/datalinklayer/TcTransferFrameLocal.cpp index 79e14167..e8785c92 100644 --- a/datalinklayer/TcTransferFrameLocal.cpp +++ b/datalinklayer/TcTransferFrameLocal.cpp @@ -5,9 +5,9 @@ * @author baetz */ -#include -#include -#include +#include "TcTransferFrameLocal.h" +#include "../globalfunctions/CRC.h" +#include "../serviceinterface/ServiceInterfaceStream.h" #include TcTransferFrameLocal::TcTransferFrameLocal(bool bypass, bool controlCommand, uint16_t scid, diff --git a/datalinklayer/TcTransferFrameLocal.h b/datalinklayer/TcTransferFrameLocal.h index f20f12ec..487d8940 100644 --- a/datalinklayer/TcTransferFrameLocal.h +++ b/datalinklayer/TcTransferFrameLocal.h @@ -8,7 +8,7 @@ #ifndef TCTRANSFERFRAMELOCAL_H_ #define TCTRANSFERFRAMELOCAL_H_ -#include +#include "TcTransferFrame.h" /** * This is a helper class to locally create TC Transfer Frames. diff --git a/datalinklayer/VirtualChannelReception.cpp b/datalinklayer/VirtualChannelReception.cpp index 373f6c62..cde28de3 100644 --- a/datalinklayer/VirtualChannelReception.cpp +++ b/datalinklayer/VirtualChannelReception.cpp @@ -5,9 +5,9 @@ * @author baetz */ -#include -#include -#include +#include "BCFrame.h" +#include "VirtualChannelReception.h" +#include "../serviceinterface/ServiceInterfaceStream.h" VirtualChannelReception::VirtualChannelReception(uint8_t setChannelId, uint8_t setSlidingWindowWidth) : diff --git a/datalinklayer/VirtualChannelReception.h b/datalinklayer/VirtualChannelReception.h index f364c6e5..9b4e2987 100644 --- a/datalinklayer/VirtualChannelReception.h +++ b/datalinklayer/VirtualChannelReception.h @@ -8,14 +8,14 @@ #ifndef VIRTUALCHANNELRECEPTION_H_ #define VIRTUALCHANNELRECEPTION_H_ -#include -#include -#include -#include -#include -#include -#include -#include +#include "CCSDSReturnValuesIF.h" +#include "Clcw.h" +#include "Farm1StateIF.h" +#include "Farm1StateLockout.h" +#include "Farm1StateOpen.h" +#include "Farm1StateWait.h" +#include "MapPacketExtractionIF.h" +#include "VirtualChannelReceptionIF.h" #include /** * Implementation of a TC Virtual Channel. diff --git a/datalinklayer/VirtualChannelReceptionIF.h b/datalinklayer/VirtualChannelReceptionIF.h index 98a9b72c..36f60e8c 100644 --- a/datalinklayer/VirtualChannelReceptionIF.h +++ b/datalinklayer/VirtualChannelReceptionIF.h @@ -8,9 +8,9 @@ #ifndef VIRTUALCHANNELRECEPTIONIF_H_ #define VIRTUALCHANNELRECEPTIONIF_H_ -#include -#include -#include +#include "ClcwIF.h" +#include "TcTransferFrame.h" +#include "../returnvalues/HasReturnvaluesIF.h" /** * This is the interface for Virtual Channel reception classes. diff --git a/datapool/ControllerSet.cpp b/datapool/ControllerSet.cpp index eb4f6d0f..6339034c 100644 --- a/datapool/ControllerSet.cpp +++ b/datapool/ControllerSet.cpp @@ -1,4 +1,4 @@ -#include +#include "ControllerSet.h" ControllerSet::ControllerSet() { diff --git a/datapool/ControllerSet.h b/datapool/ControllerSet.h index de06bf91..e27debff 100644 --- a/datapool/ControllerSet.h +++ b/datapool/ControllerSet.h @@ -1,7 +1,7 @@ #ifndef CONTROLLERSET_H_ #define CONTROLLERSET_H_ -#include +#include "DataSet.h" class ControllerSet :public DataSet { public: diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp index f44da64e..817089bf 100644 --- a/datapool/DataPool.cpp +++ b/datapool/DataPool.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "DataPool.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../ipc/MutexFactory.h" DataPool::DataPool( void ( *initFunction )( std::map* pool_map ) ) { mutex = MutexFactory::instance()->createMutex(); diff --git a/datapool/DataPool.h b/datapool/DataPool.h index 6e38dc1b..7abf2898 100644 --- a/datapool/DataPool.h +++ b/datapool/DataPool.h @@ -11,9 +11,9 @@ #ifndef DATAPOOL_H_ #define DATAPOOL_H_ -#include -#include -#include +#include "PoolEntry.h" +#include "../globalfunctions/Type.h" +#include "../ipc/MutexIF.h" #include /** diff --git a/datapool/DataPoolAdmin.cpp b/datapool/DataPoolAdmin.cpp index 3ea266ea..f298d530 100644 --- a/datapool/DataPoolAdmin.cpp +++ b/datapool/DataPoolAdmin.cpp @@ -1,10 +1,10 @@ -#include -#include -#include -#include -#include -#include -#include +#include "DataPool.h" +#include "DataPoolAdmin.h" +#include "DataSet.h" +#include "PoolRawAccess.h" +#include "../ipc/CommandMessage.h" +#include "../ipc/QueueFactory.h" +#include "../parameters/ParameterMessage.h" DataPoolAdmin::DataPoolAdmin(object_id_t objectId) : SystemObject(objectId), storage(NULL), commandQueue(NULL), memoryHelper( diff --git a/datapool/DataPoolAdmin.h b/datapool/DataPoolAdmin.h index 1be920b5..e2d1e9e1 100644 --- a/datapool/DataPoolAdmin.h +++ b/datapool/DataPoolAdmin.h @@ -1,15 +1,15 @@ #ifndef DATAPOOLADMIN_H_ #define DATAPOOLADMIN_H_ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "../memory/MemoryHelper.h" +#include "../action/HasActionsIF.h" +#include "../action/SimpleActionHelper.h" +#include "../objectmanager/SystemObject.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../parameters/ReceivesParameterMessagesIF.h" +#include "DataPoolParameterWrapper.h" +#include "../ipc/MessageQueueIF.h" class DataPoolAdmin: public HasActionsIF, public ExecutableObjectIF, diff --git a/datapool/DataPoolParameterWrapper.cpp b/datapool/DataPoolParameterWrapper.cpp index e08eba5b..79367405 100644 --- a/datapool/DataPoolParameterWrapper.cpp +++ b/datapool/DataPoolParameterWrapper.cpp @@ -1,10 +1,10 @@ #include "DataPoolParameterWrapper.h" //for returncodes -#include +#include "../parameters/HasParametersIF.h" -#include -#include +#include "DataSet.h" +#include "PoolRawAccess.h" DataPoolParameterWrapper::DataPoolParameterWrapper() : type(Type::UNKNOWN_TYPE), rows(0), columns(0), poolId( diff --git a/datapool/DataPoolParameterWrapper.h b/datapool/DataPoolParameterWrapper.h index a3dbdc04..b1e505a7 100644 --- a/datapool/DataPoolParameterWrapper.h +++ b/datapool/DataPoolParameterWrapper.h @@ -1,8 +1,8 @@ #ifndef DATAPOOLPARAMETERWRAPPER_H_ #define DATAPOOLPARAMETERWRAPPER_H_ -#include -#include +#include "../globalfunctions/Type.h" +#include "../parameters/ParameterWrapper.h" class DataPoolParameterWrapper: public SerializeIF { public: diff --git a/datapool/DataSet.cpp b/datapool/DataSet.cpp index f49f2ee5..e41489bd 100644 --- a/datapool/DataSet.cpp +++ b/datapool/DataSet.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "DataSet.h" +#include "../serviceinterface/ServiceInterfaceStream.h" DataSet::DataSet() : fill_count(0), state(DATA_SET_UNINITIALISED) { diff --git a/datapool/DataSet.h b/datapool/DataSet.h index 3d211537..04044bfe 100644 --- a/datapool/DataSet.h +++ b/datapool/DataSet.h @@ -12,13 +12,13 @@ #ifndef DATASET_H_ #define DATASET_H_ -#include -#include -#include -#include -#include -#include -#include +#include "DataPool.h" +#include "DataSetIF.h" +#include "PoolRawAccess.h" +#include "PoolVariable.h" +#include "PoolVarList.h" +#include "PoolVector.h" +#include "../serialize/SerializeAdapter.h" /** * \brief The DataSet class manages a set of locally checked out variables. * diff --git a/datapool/HkSwitchHelper.cpp b/datapool/HkSwitchHelper.cpp index caae2146..04096aca 100644 --- a/datapool/HkSwitchHelper.cpp +++ b/datapool/HkSwitchHelper.cpp @@ -1,6 +1,6 @@ -#include +#include "HkSwitchHelper.h" //#include -#include +#include "../ipc/QueueFactory.h" HkSwitchHelper::HkSwitchHelper(EventReportingProxyIF* eventProxy) : commandActionHelper(this), eventProxy(eventProxy) { diff --git a/datapool/HkSwitchHelper.h b/datapool/HkSwitchHelper.h index 1a3b6275..385b2047 100644 --- a/datapool/HkSwitchHelper.h +++ b/datapool/HkSwitchHelper.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ #define FRAMEWORK_DATAPOOL_HKSWITCHHELPER_H_ -#include -#include -#include +#include "../tasks/ExecutableObjectIF.h" +#include "../action/CommandsActionsIF.h" +#include "../events/EventReportingProxyIF.h" //TODO this class violations separation between mission and framework //but it is only a transitional solution until the Datapool is diff --git a/datapool/PIDReader.h b/datapool/PIDReader.h index 464b1549..3b38b51d 100644 --- a/datapool/PIDReader.h +++ b/datapool/PIDReader.h @@ -1,11 +1,11 @@ #ifndef PIDREADER_H_ #define PIDREADER_H_ -#include -#include -#include -#include -#include -#include +#include "DataPool.h" +#include "DataSetIF.h" +#include "PoolEntry.h" +#include "PoolVariableIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" template class PIDReaderList; diff --git a/datapool/PIDReaderList.h b/datapool/PIDReaderList.h index 07d1b8e6..1f6aa99c 100644 --- a/datapool/PIDReaderList.h +++ b/datapool/PIDReaderList.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ #define FRAMEWORK_DATAPOOL_PIDREADERLIST_H_ -#include -#include +#include "PIDReader.h" +#include "PoolVariableIF.h" template class PIDReaderList { private: diff --git a/datapool/PoolEntry.cpp b/datapool/PoolEntry.cpp index d535a72b..56e489a5 100644 --- a/datapool/PoolEntry.cpp +++ b/datapool/PoolEntry.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "PoolEntry.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../globalfunctions/arrayprinter.h" #include template diff --git a/datapool/PoolEntry.h b/datapool/PoolEntry.h index 1a22bb63..7b47c673 100644 --- a/datapool/PoolEntry.h +++ b/datapool/PoolEntry.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_DATAPOOL_POOLENTRY_H_ #define FRAMEWORK_DATAPOOL_POOLENTRY_H_ -#include +#include "PoolEntryIF.h" #include #include diff --git a/datapool/PoolEntryIF.h b/datapool/PoolEntryIF.h index a075436e..462de18b 100644 --- a/datapool/PoolEntryIF.h +++ b/datapool/PoolEntryIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_DATAPOOL_POOLENTRYIF_H_ #define FRAMEWORK_DATAPOOL_POOLENTRYIF_H_ -#include +#include "../globalfunctions/Type.h" #include /** diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp index eca354a9..f9264081 100644 --- a/datapool/PoolRawAccess.cpp +++ b/datapool/PoolRawAccess.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "DataPool.h" +#include "PoolEntryIF.h" +#include "PoolRawAccess.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../serialize/EndianConverter.h" #include diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h index 09d19afd..0c7a06bf 100644 --- a/datapool/PoolRawAccess.h +++ b/datapool/PoolRawAccess.h @@ -1,8 +1,8 @@ #ifndef POOLRAWACCESS_H_ #define POOLRAWACCESS_H_ -#include -#include +#include "DataSetIF.h" +#include "PoolVariableIF.h" /** * This class allows accessing Data Pool variables as raw bytes. diff --git a/datapool/PoolVarList.h b/datapool/PoolVarList.h index 90c9f178..035ff2ac 100644 --- a/datapool/PoolVarList.h +++ b/datapool/PoolVarList.h @@ -1,8 +1,8 @@ #ifndef POOLVARLIST_H_ #define POOLVARLIST_H_ -#include -#include +#include "PoolVariable.h" +#include "PoolVariableIF.h" template class PoolVarList { private: diff --git a/datapool/PoolVariable.h b/datapool/PoolVariable.h index a06935c3..a9d3407d 100644 --- a/datapool/PoolVariable.h +++ b/datapool/PoolVariable.h @@ -11,11 +11,11 @@ #ifndef POOLVARIABLE_H_ #define POOLVARIABLE_H_ -#include -#include -#include -#include -#include +#include "DataSetIF.h" +#include "PoolEntry.h" +#include "PoolVariableIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" template class PoolVarList; diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h index 7626c9c1..f47173df 100644 --- a/datapool/PoolVariableIF.h +++ b/datapool/PoolVariableIF.h @@ -11,8 +11,8 @@ #ifndef POOLVARIABLEIF_H_ #define POOLVARIABLEIF_H_ -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeIF.h" /** * \brief This interface is used to control local data pool variable representations. diff --git a/datapool/PoolVector.h b/datapool/PoolVector.h index 777ec723..d4ca0842 100644 --- a/datapool/PoolVector.h +++ b/datapool/PoolVector.h @@ -11,11 +11,11 @@ #ifndef POOLVECTOR_H_ #define POOLVECTOR_H_ -#include -#include -#include -#include -#include +#include "DataSetIF.h" +#include "PoolEntry.h" +#include "PoolVariableIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" /** * \brief This is the access class for array-type data pool entries. diff --git a/devicehandlers/AcceptsDeviceResponsesIF.h b/devicehandlers/AcceptsDeviceResponsesIF.h index 0eedae88..8dc69de4 100644 --- a/devicehandlers/AcceptsDeviceResponsesIF.h +++ b/devicehandlers/AcceptsDeviceResponsesIF.h @@ -8,7 +8,7 @@ #ifndef ACCEPTSDEVICERESPONSESIF_H_ #define ACCEPTSDEVICERESPONSESIF_H_ -#include +#include "../ipc/MessageQueueSenderIF.h" class AcceptsDeviceResponsesIF { public: diff --git a/devicehandlers/AssemblyBase.cpp b/devicehandlers/AssemblyBase.cpp index c250cf73..8b3f7f4d 100644 --- a/devicehandlers/AssemblyBase.cpp +++ b/devicehandlers/AssemblyBase.cpp @@ -1,4 +1,4 @@ -#include +#include "AssemblyBase.h" AssemblyBase::AssemblyBase(object_id_t objectId, object_id_t parentId, uint16_t commandQueueDepth) : diff --git a/devicehandlers/AssemblyBase.h b/devicehandlers/AssemblyBase.h index ee121032..bd2e8fad 100644 --- a/devicehandlers/AssemblyBase.h +++ b/devicehandlers/AssemblyBase.h @@ -1,9 +1,9 @@ #ifndef ASSEMBLYBASE_H_ #define ASSEMBLYBASE_H_ -#include -#include -#include +#include "../container/FixedArrayList.h" +#include "DeviceHandlerBase.h" +#include "../subsystem/SubsystemBase.h" class AssemblyBase: public SubsystemBase { public: diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp index 34e45b68..cee2a349 100644 --- a/devicehandlers/ChildHandlerBase.cpp +++ b/devicehandlers/ChildHandlerBase.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../subsystem/SubsystemBase.h" +#include "ChildHandlerBase.h" +#include "../subsystem/SubsystemBase.h" ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF * comCookie, diff --git a/devicehandlers/ChildHandlerBase.h b/devicehandlers/ChildHandlerBase.h index 59cf26b1..005e8065 100644 --- a/devicehandlers/ChildHandlerBase.h +++ b/devicehandlers/ChildHandlerBase.h @@ -1,8 +1,8 @@ #ifndef PAYLOADHANDLERBASE_H_ #define PAYLOADHANDLERBASE_H_ -#include -#include +#include "ChildHandlerFDIR.h" +#include "DeviceHandlerBase.h" class ChildHandlerBase: public DeviceHandlerBase { public: diff --git a/devicehandlers/ChildHandlerFDIR.cpp b/devicehandlers/ChildHandlerFDIR.cpp index 1bba47fe..14043a77 100644 --- a/devicehandlers/ChildHandlerFDIR.cpp +++ b/devicehandlers/ChildHandlerFDIR.cpp @@ -1,4 +1,4 @@ -#include +#include "ChildHandlerFDIR.h" ChildHandlerFDIR::ChildHandlerFDIR(object_id_t owner, object_id_t faultTreeParent, uint32_t recoveryCount) : DeviceHandlerFailureIsolation(owner, faultTreeParent) { diff --git a/devicehandlers/ChildHandlerFDIR.h b/devicehandlers/ChildHandlerFDIR.h index 7df9d238..ce844518 100644 --- a/devicehandlers/ChildHandlerFDIR.h +++ b/devicehandlers/ChildHandlerFDIR.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ #define FRAMEWORK_DEVICEHANDLERS_CHILDHANDLERFDIR_H_ -#include +#include "DeviceHandlerFailureIsolation.h" /** * Very simple extension to normal FDIR. diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h index 9ca31a9b..11960d8e 100644 --- a/devicehandlers/DeviceCommunicationIF.h +++ b/devicehandlers/DeviceCommunicationIF.h @@ -1,8 +1,8 @@ #ifndef DEVICECOMMUNICATIONIF_H_ #define DEVICECOMMUNICATIONIF_H_ -#include -#include +#include "CookieIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include /** * @defgroup interfaces Interfaces diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp index 79b504b5..a87b6de1 100644 --- a/devicehandlers/DeviceHandlerBase.cpp +++ b/devicehandlers/DeviceHandlerBase.cpp @@ -1,16 +1,16 @@ -#include -#include -#include -#include -#include +#include "DeviceHandlerBase.h" +#include "../objectmanager/ObjectManager.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../thermal/ThermalComponentIF.h" +#include "AcceptsDeviceResponsesIF.h" -#include -#include -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PoolVariable.h" +#include "DeviceTmReportingWrapper.h" +#include "../globalfunctions/CRC.h" +#include "../subsystem/SubsystemBase.h" +#include "../ipc/QueueFactory.h" +#include "../serviceinterface/ServiceInterfaceStream.h" #include diff --git a/devicehandlers/DeviceHandlerBase.h b/devicehandlers/DeviceHandlerBase.h index e79d5d5c..7c68ce06 100644 --- a/devicehandlers/DeviceHandlerBase.h +++ b/devicehandlers/DeviceHandlerBase.h @@ -1,22 +1,22 @@ #ifndef DEVICEHANDLERBASE_H_ #define DEVICEHANDLERBASE_H_ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "../objectmanager/SystemObject.h" +#include "../tasks/ExecutableObjectIF.h" +#include "DeviceHandlerIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../action/HasActionsIF.h" +#include "../datapool/PoolVariableIF.h" +#include "DeviceCommunicationIF.h" +#include "../modes/HasModesIF.h" +#include "../power/PowerSwitchIF.h" +#include "../ipc/MessageQueueIF.h" -#include -#include -#include -#include -#include +#include "../action/ActionHelper.h" +#include "../health/HealthHelper.h" +#include "../parameters/ParameterHelper.h" +#include "../datapool/HkSwitchHelper.h" +#include "DeviceHandlerFailureIsolation.h" #include diff --git a/devicehandlers/DeviceHandlerFailureIsolation.cpp b/devicehandlers/DeviceHandlerFailureIsolation.cpp index 65c40219..497d6469 100644 --- a/devicehandlers/DeviceHandlerFailureIsolation.cpp +++ b/devicehandlers/DeviceHandlerFailureIsolation.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "DeviceHandlerBase.h" +#include "DeviceHandlerFailureIsolation.h" +#include "../health/HealthTableIF.h" +#include "../power/Fuse.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../thermal/ThermalComponentIF.h" object_id_t DeviceHandlerFailureIsolation::powerConfirmationId = 0; diff --git a/devicehandlers/DeviceHandlerFailureIsolation.h b/devicehandlers/DeviceHandlerFailureIsolation.h index 91f6ef64..aa43b762 100644 --- a/devicehandlers/DeviceHandlerFailureIsolation.h +++ b/devicehandlers/DeviceHandlerFailureIsolation.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ #define FRAMEWORK_DEVICEHANDLERS_DEVICEHANDLERFAILUREISOLATION_H_ -#include -#include +#include "../fdir/FaultCounter.h" +#include "../fdir/FailureIsolationBase.h" namespace Factory{ void setStaticFrameworkObjectIds(); } diff --git a/devicehandlers/DeviceHandlerIF.h b/devicehandlers/DeviceHandlerIF.h index 666d9efc..52a3be4d 100644 --- a/devicehandlers/DeviceHandlerIF.h +++ b/devicehandlers/DeviceHandlerIF.h @@ -1,11 +1,11 @@ #ifndef DEVICEHANDLERIF_H_ #define DEVICEHANDLERIF_H_ -#include -#include -#include -#include -#include +#include "../action/HasActionsIF.h" +#include "DeviceHandlerMessage.h" +#include "../events/Event.h" +#include "../modes/HasModesIF.h" +#include "../ipc/MessageQueueSenderIF.h" /** * @brief This is the Interface used to communicate with a device handler. diff --git a/devicehandlers/DeviceHandlerMessage.cpp b/devicehandlers/DeviceHandlerMessage.cpp index 58a6d312..564fae21 100644 --- a/devicehandlers/DeviceHandlerMessage.cpp +++ b/devicehandlers/DeviceHandlerMessage.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "DeviceHandlerMessage.h" +#include "../objectmanager/ObjectManagerIF.h" DeviceHandlerMessage::DeviceHandlerMessage() { } diff --git a/devicehandlers/DeviceHandlerMessage.h b/devicehandlers/DeviceHandlerMessage.h index fad0f1b1..f33fdad8 100644 --- a/devicehandlers/DeviceHandlerMessage.h +++ b/devicehandlers/DeviceHandlerMessage.h @@ -1,10 +1,10 @@ #ifndef DEVICEHANDLERMESSAGE_H_ #define DEVICEHANDLERMESSAGE_H_ -#include -#include -#include -#include +#include "../action/ActionMessage.h" +#include "../ipc/CommandMessage.h" +#include "../objectmanager/SystemObjectIF.h" +#include "../storagemanager/StorageManagerIF.h" //SHOULDDO: rework the static constructors to name the type of command they are building, maybe even hide setting the commandID. /** diff --git a/devicehandlers/DeviceTmReportingWrapper.cpp b/devicehandlers/DeviceTmReportingWrapper.cpp index ce5eb109..84f926f0 100644 --- a/devicehandlers/DeviceTmReportingWrapper.cpp +++ b/devicehandlers/DeviceTmReportingWrapper.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../serialize/SerializeAdapter.h" +#include "DeviceTmReportingWrapper.h" +#include "../serialize/SerializeAdapter.h" DeviceTmReportingWrapper::DeviceTmReportingWrapper(object_id_t objectId, ActionId_t actionId, SerializeIF* data) : diff --git a/devicehandlers/DeviceTmReportingWrapper.h b/devicehandlers/DeviceTmReportingWrapper.h index 4432b7f1..a14c4261 100644 --- a/devicehandlers/DeviceTmReportingWrapper.h +++ b/devicehandlers/DeviceTmReportingWrapper.h @@ -1,9 +1,9 @@ #ifndef DEVICETMREPORTINGWRAPPER_H_ #define DEVICETMREPORTINGWRAPPER_H_ -#include -#include -#include +#include "../action/HasActionsIF.h" +#include "../objectmanager/SystemObjectIF.h" +#include "../serialize/SerializeIF.h" class DeviceTmReportingWrapper: public SerializeIF { public: diff --git a/devicehandlers/FixedSequenceSlot.cpp b/devicehandlers/FixedSequenceSlot.cpp index bb97a8e5..667aba1d 100644 --- a/devicehandlers/FixedSequenceSlot.cpp +++ b/devicehandlers/FixedSequenceSlot.cpp @@ -5,8 +5,8 @@ * @author baetz */ -#include -#include +#include "FixedSequenceSlot.h" +#include "../objectmanager/SystemObjectIF.h" #include FixedSequenceSlot::FixedSequenceSlot(object_id_t handlerId, uint32_t setTime, diff --git a/devicehandlers/FixedSequenceSlot.h b/devicehandlers/FixedSequenceSlot.h index 7868cce3..73504955 100644 --- a/devicehandlers/FixedSequenceSlot.h +++ b/devicehandlers/FixedSequenceSlot.h @@ -8,8 +8,8 @@ #ifndef FIXEDSEQUENCESLOT_H_ #define FIXEDSEQUENCESLOT_H_ -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "../tasks/ExecutableObjectIF.h" class PeriodicTaskIF; /** diff --git a/devicehandlers/FixedSlotSequence.cpp b/devicehandlers/FixedSlotSequence.cpp index 9a0dc372..38d4dcea 100644 --- a/devicehandlers/FixedSlotSequence.cpp +++ b/devicehandlers/FixedSlotSequence.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "FixedSlotSequence.h" +#include "../serviceinterface/ServiceInterfaceStream.h" FixedSlotSequence::FixedSlotSequence(uint32_t setLengthMs) : lengthMs(setLengthMs) { diff --git a/devicehandlers/FixedSlotSequence.h b/devicehandlers/FixedSlotSequence.h index 32b61f56..be6dc2d1 100644 --- a/devicehandlers/FixedSlotSequence.h +++ b/devicehandlers/FixedSlotSequence.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_ #define FRAMEWORK_DEVICEHANDLERS_FIXEDSLOTSEQUENCE_H_ -#include -#include +#include "FixedSequenceSlot.h" +#include "../objectmanager/SystemObject.h" #include /** diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp index 61a82421..411731dc 100644 --- a/devicehandlers/HealthDevice.cpp +++ b/devicehandlers/HealthDevice.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "HealthDevice.h" +#include "../ipc/QueueFactory.h" HealthDevice::HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue) : diff --git a/devicehandlers/HealthDevice.h b/devicehandlers/HealthDevice.h index ffb9e5bd..53b0ab09 100644 --- a/devicehandlers/HealthDevice.h +++ b/devicehandlers/HealthDevice.h @@ -1,11 +1,11 @@ #ifndef HEALTHDEVICE_H_ #define HEALTHDEVICE_H_ -#include -#include -#include -#include -#include +#include "../health/HasHealthIF.h" +#include "../health/HealthHelper.h" +#include "../objectmanager/SystemObject.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../ipc/MessageQueueIF.h" class HealthDevice: public SystemObject, public ExecutableObjectIF, diff --git a/events/Event.cpp b/events/Event.cpp index 9ea9f552..ea3d46fe 100644 --- a/events/Event.cpp +++ b/events/Event.cpp @@ -1,4 +1,4 @@ -#include +#include "Event.h" namespace EVENT { EventId_t getEventId(Event event) { return (event & 0xFFFF); diff --git a/events/Event.h b/events/Event.h index 96800f34..e22c9db1 100644 --- a/events/Event.h +++ b/events/Event.h @@ -2,7 +2,7 @@ #define EVENTOBJECT_EVENT_H_ #include -#include +#include "fwSubsystemIdRanges.h" //could be move to more suitable location #include diff --git a/events/EventManager.cpp b/events/EventManager.cpp index 0f1511e4..fb4499b2 100644 --- a/events/EventManager.cpp +++ b/events/EventManager.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "EventManager.h" +#include "EventMessage.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../ipc/QueueFactory.h" +#include "../ipc/MutexFactory.h" const uint16_t EventManager::POOL_SIZES[N_POOLS] = { diff --git a/events/EventManager.h b/events/EventManager.h index 76dde9f8..7badc3bf 100644 --- a/events/EventManager.h +++ b/events/EventManager.h @@ -1,13 +1,13 @@ #ifndef EVENTMANAGER_H_ #define EVENTMANAGER_H_ -#include -#include -#include -#include -#include -#include -#include +#include "eventmatching/EventMatchTree.h" +#include "EventManagerIF.h" +#include "../objectmanager/SystemObject.h" +#include "../storagemanager/LocalPool.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../ipc/MessageQueueIF.h" +#include "../ipc/MutexIF.h" #include class EventManager: public EventManagerIF, diff --git a/events/EventManagerIF.h b/events/EventManagerIF.h index bc0de432..f9ac420b 100644 --- a/events/EventManagerIF.h +++ b/events/EventManagerIF.h @@ -1,10 +1,10 @@ #ifndef EVENTMANAGERIF_H_ #define EVENTMANAGERIF_H_ -#include -#include -#include -#include +#include "eventmatching/eventmatching.h" +#include "EventMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../ipc/MessageQueueSenderIF.h" class EventManagerIF { public: diff --git a/events/EventMessage.cpp b/events/EventMessage.cpp index f06f68c3..b911abab 100644 --- a/events/EventMessage.cpp +++ b/events/EventMessage.cpp @@ -1,4 +1,4 @@ -#include +#include "EventMessage.h" #include EventMessage::EventMessage() { diff --git a/events/EventMessage.h b/events/EventMessage.h index 9cbe3336..4d003bd7 100644 --- a/events/EventMessage.h +++ b/events/EventMessage.h @@ -1,9 +1,9 @@ #ifndef EVENTMESSAGE_H_ #define EVENTMESSAGE_H_ -#include -#include -#include +#include "Event.h" +#include "../ipc/MessageQueueMessage.h" +#include "../objectmanager/ObjectManagerIF.h" /** * Passing on events through IPC. diff --git a/events/EventReportingProxyIF.h b/events/EventReportingProxyIF.h index 8aca4e26..7a96e3d1 100644 --- a/events/EventReportingProxyIF.h +++ b/events/EventReportingProxyIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ #define FRAMEWORK_EVENTS_EVENTREPORTINGPROXYIF_H_ -#include +#include "Event.h" class EventReportingProxyIF { diff --git a/events/eventmatching/EventIdRangeMatcher.cpp b/events/eventmatching/EventIdRangeMatcher.cpp index ac9156fd..974567d4 100644 --- a/events/eventmatching/EventIdRangeMatcher.cpp +++ b/events/eventmatching/EventIdRangeMatcher.cpp @@ -1,4 +1,4 @@ -#include +#include "EventIdRangeMatcher.h" EventIdRangeMatcher::EventIdRangeMatcher(EventId_t lower, EventId_t upper, bool inverted) : EventRangeMatcherBase(lower, upper, inverted) { diff --git a/events/eventmatching/EventIdRangeMatcher.h b/events/eventmatching/EventIdRangeMatcher.h index 57b77cb1..540d372f 100644 --- a/events/eventmatching/EventIdRangeMatcher.h +++ b/events/eventmatching/EventIdRangeMatcher.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ #define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTIDRANGEMATCHER_H_ -#include +#include "EventRangeMatcherBase.h" class EventIdRangeMatcher: public EventRangeMatcherBase { public: diff --git a/events/eventmatching/EventMatchTree.cpp b/events/eventmatching/EventMatchTree.cpp index e1925b8f..55e4083f 100644 --- a/events/eventmatching/EventMatchTree.cpp +++ b/events/eventmatching/EventMatchTree.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "EventIdRangeMatcher.h" +#include "EventMatchTree.h" +#include "ReporterRangeMatcher.h" +#include "SeverityRangeMatcher.h" EventMatchTree::EventMatchTree(StorageManagerIF* storageBackend, bool invertedMatch) : diff --git a/events/eventmatching/EventMatchTree.h b/events/eventmatching/EventMatchTree.h index bd81e3be..82a6de81 100644 --- a/events/eventmatching/EventMatchTree.h +++ b/events/eventmatching/EventMatchTree.h @@ -1,10 +1,10 @@ #ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ #define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTMATCHTREE_H_ -#include -#include -#include -#include +#include "../../container/PlacementFactory.h" +#include "../../events/EventMessage.h" +#include "../../globalfunctions/matching/MatchTree.h" +#include "../../returnvalues/HasReturnvaluesIF.h" class StorageManagerIF; class EventMatchTree: public MatchTree, public HasReturnvaluesIF { diff --git a/events/eventmatching/EventRangeMatcherBase.h b/events/eventmatching/EventRangeMatcherBase.h index 587669ba..e9d57f1c 100644 --- a/events/eventmatching/EventRangeMatcherBase.h +++ b/events/eventmatching/EventRangeMatcherBase.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ #define FRAMEWORK_EVENTS_EVENTMATCHING_EVENTRANGEMATCHERBASE_H_ -#include -#include -#include +#include "../../events/EventMessage.h" +#include "../../globalfunctions/matching/RangeMatcher.h" +#include "../../globalfunctions/matching/SerializeableMatcherIF.h" template class EventRangeMatcherBase: public SerializeableMatcherIF { diff --git a/events/eventmatching/ReporterRangeMatcher.cpp b/events/eventmatching/ReporterRangeMatcher.cpp index 76b8e788..61179726 100644 --- a/events/eventmatching/ReporterRangeMatcher.cpp +++ b/events/eventmatching/ReporterRangeMatcher.cpp @@ -1,4 +1,4 @@ -#include +#include "ReporterRangeMatcher.h" ReporterRangeMatcher::ReporterRangeMatcher(object_id_t lower, object_id_t upper, bool inverted) : EventRangeMatcherBase(lower, upper, inverted) { diff --git a/events/eventmatching/ReporterRangeMatcher.h b/events/eventmatching/ReporterRangeMatcher.h index 65be2365..9a0a5fcf 100644 --- a/events/eventmatching/ReporterRangeMatcher.h +++ b/events/eventmatching/ReporterRangeMatcher.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ #define FRAMEWORK_EVENTS_EVENTMATCHING_REPORTERRANGEMATCHER_H_ -#include +#include "EventRangeMatcherBase.h" class ReporterRangeMatcher: public EventRangeMatcherBase { public: diff --git a/events/eventmatching/SeverityRangeMatcher.cpp b/events/eventmatching/SeverityRangeMatcher.cpp index 98f8d7e1..6fd38271 100644 --- a/events/eventmatching/SeverityRangeMatcher.cpp +++ b/events/eventmatching/SeverityRangeMatcher.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "SeverityRangeMatcher.h" +#include "../../events/EventMessage.h" +#include "../../serialize/SerializeAdapter.h" SeverityRangeMatcher::SeverityRangeMatcher(EventSeverity_t from, EventSeverity_t till, bool inverted) : EventRangeMatcherBase(from, till, inverted) { diff --git a/events/eventmatching/SeverityRangeMatcher.h b/events/eventmatching/SeverityRangeMatcher.h index ffacff81..3f7cc418 100644 --- a/events/eventmatching/SeverityRangeMatcher.h +++ b/events/eventmatching/SeverityRangeMatcher.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ #define FRAMEWORK_EVENTS_EVENTMATCHING_SEVERITYRANGEMATCHER_H_ -#include +#include "EventRangeMatcherBase.h" class SeverityRangeMatcher: public EventRangeMatcherBase { public: diff --git a/events/eventmatching/eventmatching.h b/events/eventmatching/eventmatching.h index 435c7457..7a87e177 100644 --- a/events/eventmatching/eventmatching.h +++ b/events/eventmatching/eventmatching.h @@ -1,10 +1,10 @@ #ifndef EVENTMATCHING_H_ #define EVENTMATCHING_H_ -#include -#include -#include -#include +#include "EventIdRangeMatcher.h" +#include "EventMatchTree.h" +#include "ReporterRangeMatcher.h" +#include "SeverityRangeMatcher.h" #endif /* EVENTMATCHING_H_ */ diff --git a/fdir/ConfirmsFailuresIF.h b/fdir/ConfirmsFailuresIF.h index 99cd212a..14411461 100644 --- a/fdir/ConfirmsFailuresIF.h +++ b/fdir/ConfirmsFailuresIF.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ #define FRAMEWORK_FDIR_CONFIRMSFAILURESIF_H_ -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueSenderIF.h" class ConfirmsFailuresIF { public: diff --git a/fdir/EventCorrelation.cpp b/fdir/EventCorrelation.cpp index 32aa3cd3..d60fc6ca 100644 --- a/fdir/EventCorrelation.cpp +++ b/fdir/EventCorrelation.cpp @@ -1,4 +1,4 @@ -#include +#include "EventCorrelation.h" EventCorrelation::EventCorrelation(uint32_t timeout) : eventPending(false) { diff --git a/fdir/EventCorrelation.h b/fdir/EventCorrelation.h index 0cad6265..b8793edf 100644 --- a/fdir/EventCorrelation.h +++ b/fdir/EventCorrelation.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_FDIR_EVENTCORRELATION_H_ #define FRAMEWORK_FDIR_EVENTCORRELATION_H_ -#include +#include "../timemanager/Countdown.h" class EventCorrelation { public: diff --git a/fdir/FailureIsolationBase.cpp b/fdir/FailureIsolationBase.cpp index 4b7caac5..eb7b1bfc 100644 --- a/fdir/FailureIsolationBase.cpp +++ b/fdir/FailureIsolationBase.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "../events/EventManagerIF.h" +#include "FailureIsolationBase.h" +#include "../health/HasHealthIF.h" +#include "../health/HealthMessage.h" +#include "../ipc/QueueFactory.h" +#include "../objectmanager/ObjectManagerIF.h" FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) : eventQueue(NULL), ownerId( diff --git a/fdir/FailureIsolationBase.h b/fdir/FailureIsolationBase.h index cd582e39..6f38bc9f 100644 --- a/fdir/FailureIsolationBase.h +++ b/fdir/FailureIsolationBase.h @@ -1,13 +1,13 @@ #ifndef FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ #define FRAMEWORK_FDIR_FAILUREISOLATIONBASE_H_ -#include -#include -#include -#include -#include -#include -#include +#include "../events/EventMessage.h" +#include "ConfirmsFailuresIF.h" +#include "FaultCounter.h" +#include "../health/HealthMessage.h" +#include "../parameters/HasParametersIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueIF.h" class FailureIsolationBase: public HasReturnvaluesIF, public ConfirmsFailuresIF, diff --git a/fdir/FaultCounter.cpp b/fdir/FaultCounter.cpp index 3dc899c2..443adb52 100644 --- a/fdir/FaultCounter.cpp +++ b/fdir/FaultCounter.cpp @@ -1,4 +1,4 @@ -#include +#include "FaultCounter.h" FaultCounter::FaultCounter(uint32_t failureThreshold, uint32_t decrementAfterMs, uint8_t setParameterDomain) : diff --git a/fdir/FaultCounter.h b/fdir/FaultCounter.h index ac23853c..dc929deb 100644 --- a/fdir/FaultCounter.h +++ b/fdir/FaultCounter.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_FDIR_FAULTCOUNTER_H_ #define FRAMEWORK_FDIR_FAULTCOUNTER_H_ -#include -#include +#include "../parameters/HasParametersIF.h" +#include "../timemanager/Countdown.h" class FaultCounter: public HasParametersIF { public: diff --git a/globalfunctions/AsciiConverter.cpp b/globalfunctions/AsciiConverter.cpp index 1459a241..9eb3698f 100644 --- a/globalfunctions/AsciiConverter.cpp +++ b/globalfunctions/AsciiConverter.cpp @@ -1,4 +1,4 @@ -#include +#include "AsciiConverter.h" #include #include diff --git a/globalfunctions/AsciiConverter.h b/globalfunctions/AsciiConverter.h index acd406da..7af3cb3d 100644 --- a/globalfunctions/AsciiConverter.h +++ b/globalfunctions/AsciiConverter.h @@ -1,7 +1,7 @@ #ifndef ASCIICONVERTER_H_ #define ASCIICONVERTER_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" class AsciiConverter: public HasReturnvaluesIF { public: diff --git a/globalfunctions/CRC.cpp b/globalfunctions/CRC.cpp index ecd0b675..7bb56806 100644 --- a/globalfunctions/CRC.cpp +++ b/globalfunctions/CRC.cpp @@ -1,4 +1,4 @@ -#include +#include "CRC.h" #include const uint16_t CRC::crc16ccitt_table[256] = { diff --git a/globalfunctions/DleEncoder.cpp b/globalfunctions/DleEncoder.cpp index a68f1524..088c9d80 100644 --- a/globalfunctions/DleEncoder.cpp +++ b/globalfunctions/DleEncoder.cpp @@ -1,4 +1,4 @@ -#include +#include "DleEncoder.h" DleEncoder::DleEncoder() { } diff --git a/globalfunctions/DleEncoder.h b/globalfunctions/DleEncoder.h index fc155600..ff3a2727 100644 --- a/globalfunctions/DleEncoder.h +++ b/globalfunctions/DleEncoder.h @@ -1,7 +1,7 @@ #ifndef DLEENCODER_H_ #define DLEENCODER_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" class DleEncoder: public HasReturnvaluesIF { private: diff --git a/globalfunctions/Type.cpp b/globalfunctions/Type.cpp index a481f768..ae595b81 100644 --- a/globalfunctions/Type.cpp +++ b/globalfunctions/Type.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../serialize/SerializeAdapter.h" +#include "Type.h" +#include "../serialize/SerializeAdapter.h" Type::Type() : actualType(UNKNOWN_TYPE) { diff --git a/globalfunctions/Type.h b/globalfunctions/Type.h index 3ec250b0..be499ffc 100644 --- a/globalfunctions/Type.h +++ b/globalfunctions/Type.h @@ -1,8 +1,8 @@ #ifndef TYPE_H_ #define TYPE_H_ -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeIF.h" class Type: public SerializeIF { public: diff --git a/globalfunctions/arrayprinter.cpp b/globalfunctions/arrayprinter.cpp index e8fce56c..b1e888c5 100644 --- a/globalfunctions/arrayprinter.cpp +++ b/globalfunctions/arrayprinter.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "arrayprinter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" #include void arrayprinter::print(const uint8_t *data, size_t size, OutputType type, diff --git a/globalfunctions/matching/BinaryMatcher.h b/globalfunctions/matching/BinaryMatcher.h index df7325cf..4f6db85d 100644 --- a/globalfunctions/matching/BinaryMatcher.h +++ b/globalfunctions/matching/BinaryMatcher.h @@ -1,7 +1,7 @@ #ifndef BINARYMATCHER_H_ #define BINARYMATCHER_H_ -#include +#include "MatcherIF.h" template class BinaryMatcher: public MatcherIF { diff --git a/globalfunctions/matching/DecimalMatcher.h b/globalfunctions/matching/DecimalMatcher.h index f4722e6b..53505020 100644 --- a/globalfunctions/matching/DecimalMatcher.h +++ b/globalfunctions/matching/DecimalMatcher.h @@ -1,7 +1,7 @@ #ifndef DECIMALMATCHER_H_ #define DECIMALMATCHER_H_ -#include +#include "MatcherIF.h" template class DecimalMatcher: public MatcherIF { diff --git a/globalfunctions/matching/MatchTree.h b/globalfunctions/matching/MatchTree.h index b54f5492..755687b2 100644 --- a/globalfunctions/matching/MatchTree.h +++ b/globalfunctions/matching/MatchTree.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_MATCHTREE_H_ -#include -#include -#include +#include "../../container/BinaryTree.h" +#include "SerializeableMatcherIF.h" +#include "../../serialize/SerializeAdapter.h" template class MatchTree: public SerializeableMatcherIF, public BinaryTree< diff --git a/globalfunctions/matching/RangeMatcher.h b/globalfunctions/matching/RangeMatcher.h index 6fee1f52..b64b9e30 100644 --- a/globalfunctions/matching/RangeMatcher.h +++ b/globalfunctions/matching/RangeMatcher.h @@ -1,8 +1,8 @@ #ifndef RANGEMATCHER_H_ #define RANGEMATCHER_H_ -#include -#include +#include "SerializeableMatcherIF.h" +#include "../../serialize/SerializeAdapter.h" template class RangeMatcher: public SerializeableMatcherIF { diff --git a/globalfunctions/matching/SerializeableMatcherIF.h b/globalfunctions/matching/SerializeableMatcherIF.h index 7b00a1b3..067b0251 100644 --- a/globalfunctions/matching/SerializeableMatcherIF.h +++ b/globalfunctions/matching/SerializeableMatcherIF.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ #define FRAMEWORK_GLOBALFUNCTIONS_MATCHING_SERIALIZEABLEMATCHERIF_H_ -#include -#include +#include "MatcherIF.h" +#include "../../serialize/SerializeIF.h" template class SerializeableMatcherIF : public MatcherIF, public SerializeIF { diff --git a/globalfunctions/math/QuaternionOperations.cpp b/globalfunctions/math/QuaternionOperations.cpp index f8c75149..c09426da 100644 --- a/globalfunctions/math/QuaternionOperations.cpp +++ b/globalfunctions/math/QuaternionOperations.cpp @@ -1,5 +1,5 @@ #include "QuaternionOperations.h" -#include +#include "VectorOperations.h" #include #include diff --git a/globalfunctions/timevalOperations.cpp b/globalfunctions/timevalOperations.cpp index 253b6eb7..6efe75ba 100644 --- a/globalfunctions/timevalOperations.cpp +++ b/globalfunctions/timevalOperations.cpp @@ -1,4 +1,4 @@ -#include +#include "timevalOperations.h" timeval& operator+=(timeval& lhs, const timeval& rhs) { int64_t sum = lhs.tv_sec * 1000000. + lhs.tv_usec; diff --git a/health/HasHealthIF.h b/health/HasHealthIF.h index dd27fe39..ac404300 100644 --- a/health/HasHealthIF.h +++ b/health/HasHealthIF.h @@ -1,9 +1,9 @@ #ifndef HASHEALTHIF_H_ #define HASHEALTHIF_H_ -#include -#include -#include +#include "../events/Event.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MessageQueueSenderIF.h" class HasHealthIF { public: diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp index 7b8b3a53..1cc7d858 100644 --- a/health/HealthHelper.cpp +++ b/health/HealthHelper.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "HealthHelper.h" +#include "../ipc/MessageQueueSenderIF.h" +#include "../serviceinterface/ServiceInterfaceStream.h" HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) : healthTable(NULL), eventSender(NULL), objectId(objectId), parentQueue( 0), owner(owner) { diff --git a/health/HealthHelper.h b/health/HealthHelper.h index 471bc7e9..90155ad4 100644 --- a/health/HealthHelper.h +++ b/health/HealthHelper.h @@ -1,13 +1,13 @@ #ifndef HEALTHHELPER_H_ #define HEALTHHELPER_H_ -#include -#include -#include -#include -#include -#include -#include +#include "../events/EventManagerIF.h" +#include "../events/EventReportingProxyIF.h" +#include "HasHealthIF.h" +#include "HealthMessage.h" +#include "HealthTableIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" /** * Helper class for Objects that implement HasHealthIF diff --git a/health/HealthMessage.cpp b/health/HealthMessage.cpp index 768dea46..1bb29526 100644 --- a/health/HealthMessage.cpp +++ b/health/HealthMessage.cpp @@ -1,4 +1,4 @@ -#include +#include "HealthMessage.h" void HealthMessage::setHealthMessage(CommandMessage* message, Command_t command, HasHealthIF::HealthState health, HasHealthIF::HealthState oldHealth) { diff --git a/health/HealthMessage.h b/health/HealthMessage.h index 7fd00904..95bd9d45 100644 --- a/health/HealthMessage.h +++ b/health/HealthMessage.h @@ -1,8 +1,8 @@ #ifndef HEALTHMESSAGE_H_ #define HEALTHMESSAGE_H_ -#include -#include +#include "HasHealthIF.h" +#include "../ipc/CommandMessage.h" class HealthMessage { public: diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp index bd6606db..846152f6 100644 --- a/health/HealthTable.cpp +++ b/health/HealthTable.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "HealthTable.h" +#include "../serialize/SerializeAdapter.h" +#include "../ipc/MutexFactory.h" HealthTable::HealthTable(object_id_t objectid) : SystemObject(objectid) { diff --git a/health/HealthTable.h b/health/HealthTable.h index 2c74bda4..6f5dd18d 100644 --- a/health/HealthTable.h +++ b/health/HealthTable.h @@ -1,9 +1,9 @@ #ifndef HEALTHTABLE_H_ #define HEALTHTABLE_H_ -#include -#include -#include +#include "HealthTableIF.h" +#include "../objectmanager/SystemObject.h" +#include "../ipc/MutexIF.h" #include typedef std::map HealthMap; diff --git a/health/HealthTableIF.h b/health/HealthTableIF.h index a850a804..404c03e4 100644 --- a/health/HealthTableIF.h +++ b/health/HealthTableIF.h @@ -1,9 +1,9 @@ #ifndef HEALTHTABLEIF_H_ #define HEALTHTABLEIF_H_ -#include -#include -#include +#include "ManagesHealthIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include diff --git a/health/ManagesHealthIF.h b/health/ManagesHealthIF.h index ff0c5386..42d4c4f0 100644 --- a/health/ManagesHealthIF.h +++ b/health/ManagesHealthIF.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ #define FRAMEWORK_HEALTH_MANAGESHEALTHIF_H_ -#include -#include +#include "HasHealthIF.h" +#include "../objectmanager/ObjectManagerIF.h" class ManagesHealthIF { public: virtual ~ManagesHealthIF() { diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp index 9a8ede00..b468ca5e 100644 --- a/internalError/InternalErrorReporter.cpp +++ b/internalError/InternalErrorReporter.cpp @@ -1,10 +1,10 @@ #include "InternalErrorReporter.h" -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PoolVariable.h" +#include "../ipc/MutexFactory.h" -#include +#include "../serviceinterface/ServiceInterfaceStream.h" InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t queuePoolId, uint32_t tmPoolId, uint32_t storePoolId) : diff --git a/internalError/InternalErrorReporter.h b/internalError/InternalErrorReporter.h index 7c1df6a7..9aa24a0f 100644 --- a/internalError/InternalErrorReporter.h +++ b/internalError/InternalErrorReporter.h @@ -3,9 +3,9 @@ #include "InternalErrorReporterIF.h" -#include -#include -#include +#include "../tasks/ExecutableObjectIF.h" +#include "../objectmanager/SystemObject.h" +#include "../ipc/MutexIF.h" class InternalErrorReporter: public SystemObject, public ExecutableObjectIF, diff --git a/ipc/CommandMessage.cpp b/ipc/CommandMessage.cpp index 05896cbc..8c5e15b8 100644 --- a/ipc/CommandMessage.cpp +++ b/ipc/CommandMessage.cpp @@ -5,15 +5,15 @@ * @author baetz */ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "../devicehandlers/DeviceHandlerMessage.h" +#include "../health/HealthMessage.h" +#include "CommandMessage.h" +#include "../memory/MemoryMessage.h" +#include "../modes/ModeMessage.h" +#include "../monitoring/MonitoringMessage.h" +#include "../subsystem/modes/ModeSequenceMessage.h" +#include "../tmstorage/TmStoreMessage.h" +#include "../parameters/ParameterMessage.h" namespace MESSAGE_TYPE { void clearMissionMessage(CommandMessage* message); diff --git a/ipc/CommandMessage.h b/ipc/CommandMessage.h index 897632fe..87244c11 100644 --- a/ipc/CommandMessage.h +++ b/ipc/CommandMessage.h @@ -9,10 +9,10 @@ #define COMMANDMESSAGE_H_ -#include +#include "FwMessageTypes.h" #include -#include +#include "MessageQueueMessage.h" #define MAKE_COMMAND_ID( number ) ((MESSAGE_ID << 8) + (number)) typedef ReturnValue_t Command_t; diff --git a/ipc/MessageQueueIF.h b/ipc/MessageQueueIF.h index 18e2d99a..9fff5287 100644 --- a/ipc/MessageQueueIF.h +++ b/ipc/MessageQueueIF.h @@ -3,9 +3,9 @@ // COULDDO: We could support blocking calls -#include -#include -#include +#include "MessageQueueMessage.h" +#include "MessageQueueSenderIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" class MessageQueueIF { public: diff --git a/ipc/MessageQueueMessage.cpp b/ipc/MessageQueueMessage.cpp index 30e0325c..05dde1f5 100644 --- a/ipc/MessageQueueMessage.cpp +++ b/ipc/MessageQueueMessage.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "MessageQueueMessage.h" +#include "../serviceinterface/ServiceInterfaceStream.h" #include diff --git a/ipc/MessageQueueMessage.h b/ipc/MessageQueueMessage.h index 8c4ec947..aa3559d6 100644 --- a/ipc/MessageQueueMessage.h +++ b/ipc/MessageQueueMessage.h @@ -1,7 +1,7 @@ #ifndef MESSAGEQUEUEMESSAGE_H_ #define MESSAGEQUEUEMESSAGE_H_ -#include +#include "MessageQueueSenderIF.h" #include /** diff --git a/ipc/MessageQueueSenderIF.h b/ipc/MessageQueueSenderIF.h index 9e7e11c0..d9692f54 100644 --- a/ipc/MessageQueueSenderIF.h +++ b/ipc/MessageQueueSenderIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ #define FRAMEWORK_IPC_MESSAGEQUEUESENDERIF_H_ -#include +#include "../objectmanager/ObjectManagerIF.h" class MessageQueueMessage; diff --git a/ipc/MutexFactory.h b/ipc/MutexFactory.h index b2e58b6e..f8133d81 100644 --- a/ipc/MutexFactory.h +++ b/ipc/MutexFactory.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_IPC_MUTEXFACTORY_H_ #define FRAMEWORK_IPC_MUTEXFACTORY_H_ -#include +#include "MutexIF.h" /** * Creates Mutex. * This class is a "singleton" interface, i.e. it provides an diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h index f76ccec4..dffcd54e 100644 --- a/ipc/MutexHelper.h +++ b/ipc/MutexHelper.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_IPC_MUTEXHELPER_H_ #define FRAMEWORK_IPC_MUTEXHELPER_H_ -#include -#include +#include "MutexFactory.h" +#include "../serviceinterface/ServiceInterfaceStream.h" class MutexHelper { public: diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h index 35786d6a..851d50a1 100644 --- a/ipc/MutexIF.h +++ b/ipc/MutexIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_IPC_MUTEXIF_H_ #define FRAMEWORK_IPC_MUTEXIF_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" class MutexIF { public: diff --git a/ipc/QueueFactory.h b/ipc/QueueFactory.h index 6e7c4a26..4f4d72c7 100644 --- a/ipc/QueueFactory.h +++ b/ipc/QueueFactory.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_IPC_QUEUEFACTORY_H_ #define FRAMEWORK_IPC_QUEUEFACTORY_H_ -#include +#include "MessageQueueIF.h" #include /** * Creates message queues. diff --git a/memory/AcceptsMemoryMessagesIF.h b/memory/AcceptsMemoryMessagesIF.h index 2b37f1af..a1cbddf8 100644 --- a/memory/AcceptsMemoryMessagesIF.h +++ b/memory/AcceptsMemoryMessagesIF.h @@ -8,9 +8,9 @@ #ifndef ACCEPTSMEMORYMESSAGESIF_H_ #define ACCEPTSMEMORYMESSAGESIF_H_ -#include -#include -#include +#include "HasMemoryIF.h" +#include "MemoryMessage.h" +#include "../ipc/MessageQueueSenderIF.h" class AcceptsMemoryMessagesIF : public HasMemoryIF { public: diff --git a/memory/HasMemoryIF.h b/memory/HasMemoryIF.h index cd6e6665..4096d1b7 100644 --- a/memory/HasMemoryIF.h +++ b/memory/HasMemoryIF.h @@ -1,7 +1,7 @@ #ifndef HASMEMORYIF_H_ #define HASMEMORYIF_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" class HasMemoryIF { public: diff --git a/memory/MemoryHelper.cpp b/memory/MemoryHelper.cpp index af56f2b8..48a605be 100644 --- a/memory/MemoryHelper.cpp +++ b/memory/MemoryHelper.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "../globalfunctions/CRC.h" +#include "MemoryHelper.h" +#include "MemoryMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../serialize/EndianConverter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis, MessageQueueIF* useThisQueue) : workOnThis(workOnThis), queueToUse(useThisQueue), ipcStore(NULL), ipcAddress(), lastCommand( diff --git a/memory/MemoryHelper.h b/memory/MemoryHelper.h index 2ff82eb3..5e1a99b6 100644 --- a/memory/MemoryHelper.h +++ b/memory/MemoryHelper.h @@ -1,10 +1,10 @@ #ifndef MEMORYHELPER_H_ #define MEMORYHELPER_H_ -#include -#include -#include -#include -#include +#include "../ipc/CommandMessage.h" +#include "AcceptsMemoryMessagesIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../ipc/MessageQueueIF.h" class MemoryHelper : public HasReturnvaluesIF { public: diff --git a/memory/MemoryMessage.cpp b/memory/MemoryMessage.cpp index c1116e08..741565fc 100644 --- a/memory/MemoryMessage.cpp +++ b/memory/MemoryMessage.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "MemoryMessage.h" +#include "../objectmanager/ObjectManagerIF.h" MemoryMessage::MemoryMessage() { } diff --git a/memory/MemoryMessage.h b/memory/MemoryMessage.h index 124fad08..f723bbb6 100644 --- a/memory/MemoryMessage.h +++ b/memory/MemoryMessage.h @@ -1,8 +1,8 @@ #ifndef MEMORYMESSAGE_H_ #define MEMORYMESSAGE_H_ -#include -#include +#include "../ipc/CommandMessage.h" +#include "../storagemanager/StorageManagerIF.h" class MemoryMessage { diff --git a/memory/MemoryProxyIF.h b/memory/MemoryProxyIF.h index d325ba4e..1494d523 100644 --- a/memory/MemoryProxyIF.h +++ b/memory/MemoryProxyIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ #define FRAMEWORK_MEMORY_MEMORYPROXYIF_H_ -#include +#include "AcceptsMemoryMessagesIF.h" /** * This was a nice idea to transparently forward incoming messages to another object. diff --git a/modes/HasModesIF.h b/modes/HasModesIF.h index 263b0a87..4381046c 100644 --- a/modes/HasModesIF.h +++ b/modes/HasModesIF.h @@ -8,10 +8,10 @@ #ifndef HASMODESIF_H_ #define HASMODESIF_H_ -#include -#include -#include -#include +#include "../events/Event.h" +#include "ModeHelper.h" +#include "ModeMessage.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include diff --git a/modes/ModeHelper.cpp b/modes/ModeHelper.cpp index 7b98bdc6..cb62c468 100644 --- a/modes/ModeHelper.cpp +++ b/modes/ModeHelper.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "HasModesIF.h" +#include "ModeHelper.h" +#include "../ipc/MessageQueueSenderIF.h" ModeHelper::ModeHelper(HasModesIF *owner) : theOneWhoCommandedAMode(0), commandedMode(HasModesIF::MODE_OFF), commandedSubmode( diff --git a/modes/ModeHelper.h b/modes/ModeHelper.h index 87f6d411..542fe780 100644 --- a/modes/ModeHelper.h +++ b/modes/ModeHelper.h @@ -1,9 +1,9 @@ #ifndef MODEHELPER_H_ #define MODEHELPER_H_ -#include -#include -#include +#include "ModeMessage.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../timemanager/Countdown.h" class HasModesIF; diff --git a/modes/ModeMessage.cpp b/modes/ModeMessage.cpp index 1d3baad5..14dbbb31 100644 --- a/modes/ModeMessage.cpp +++ b/modes/ModeMessage.cpp @@ -1,4 +1,4 @@ -#include +#include "ModeMessage.h" Mode_t ModeMessage::getMode(const CommandMessage* message) { return message->getParameter(); diff --git a/modes/ModeMessage.h b/modes/ModeMessage.h index f72fdeec..5fd82512 100644 --- a/modes/ModeMessage.h +++ b/modes/ModeMessage.h @@ -8,7 +8,7 @@ #ifndef MODEMESSAGE_H_ #define MODEMESSAGE_H_ -#include +#include "../ipc/CommandMessage.h" typedef uint32_t Mode_t; typedef uint8_t Submode_t; diff --git a/monitoring/AbsLimitMonitor.h b/monitoring/AbsLimitMonitor.h index 3525ba2c..2e60f6f8 100644 --- a/monitoring/AbsLimitMonitor.h +++ b/monitoring/AbsLimitMonitor.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ #define FRAMEWORK_MONITORING_ABSLIMITMONITOR_H_ -#include +#include "MonitorBase.h" #include template diff --git a/monitoring/HasMonitorsIF.h b/monitoring/HasMonitorsIF.h index 6f1dc1b3..85d92b6b 100644 --- a/monitoring/HasMonitorsIF.h +++ b/monitoring/HasMonitorsIF.h @@ -7,9 +7,9 @@ #ifndef HASMONITORSIF_H_ #define HASMONITORSIF_H_ -#include -#include -#include +#include "../events/EventReportingProxyIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../ipc/MessageQueueSenderIF.h" class HasMonitorsIF { public: diff --git a/monitoring/LimitMonitor.h b/monitoring/LimitMonitor.h index 45abe48b..66e6725e 100644 --- a/monitoring/LimitMonitor.h +++ b/monitoring/LimitMonitor.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_MONITORING_LIMITMONITOR_H_ #define FRAMEWORK_MONITORING_LIMITMONITOR_H_ -#include +#include "MonitorBase.h" /** * Variant of a limit checking class. diff --git a/monitoring/LimitViolationReporter.cpp b/monitoring/LimitViolationReporter.cpp index 489a8f9e..c531a6e6 100644 --- a/monitoring/LimitViolationReporter.cpp +++ b/monitoring/LimitViolationReporter.cpp @@ -4,11 +4,11 @@ * @date 17.07.2014 * @author baetz */ -#include -#include -#include -#include -#include +#include "LimitViolationReporter.h" +#include "MonitoringIF.h" +#include "ReceivesMonitoringReportsIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../serialize/SerializeAdapter.h" ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) { ReturnValue_t result = checkClassLoaded(); diff --git a/monitoring/LimitViolationReporter.h b/monitoring/LimitViolationReporter.h index 3a9d04dd..a71b972f 100644 --- a/monitoring/LimitViolationReporter.h +++ b/monitoring/LimitViolationReporter.h @@ -7,10 +7,10 @@ #ifndef LIMITVIOLATIONREPORTER_H_ #define LIMITVIOLATIONREPORTER_H_ -#include -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../ipc/MessageQueueSenderIF.h" namespace Factory{ void setStaticFrameworkObjectIds(); diff --git a/monitoring/MonitorBase.h b/monitoring/MonitorBase.h index 79622645..b2d0e6cb 100644 --- a/monitoring/MonitorBase.h +++ b/monitoring/MonitorBase.h @@ -1,12 +1,12 @@ #ifndef MONITORBASE_H_ #define MONITORBASE_H_ -#include -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PIDReader.h" +#include "LimitViolationReporter.h" +#include "MonitoringIF.h" +#include "MonitoringMessageContent.h" +#include "MonitorReporter.h" /** * Base class for monitoring of parameters. diff --git a/monitoring/MonitorReporter.h b/monitoring/MonitorReporter.h index 6274313f..ca2b534b 100644 --- a/monitoring/MonitorReporter.h +++ b/monitoring/MonitorReporter.h @@ -1,11 +1,11 @@ #ifndef FRAMEWORK_MONITORING_MONITORREPORTER_H_ #define FRAMEWORK_MONITORING_MONITORREPORTER_H_ -#include -#include -#include -#include -#include +#include "../events/EventManagerIF.h" +#include "LimitViolationReporter.h" +#include "MonitoringIF.h" +#include "MonitoringMessageContent.h" +#include "../parameters/HasParametersIF.h" template class MonitorReporter: public HasParametersIF { diff --git a/monitoring/MonitoringIF.h b/monitoring/MonitoringIF.h index d2d62f35..44218c36 100644 --- a/monitoring/MonitoringIF.h +++ b/monitoring/MonitoringIF.h @@ -1,9 +1,9 @@ #ifndef MONITORINGIF_H_ #define MONITORINGIF_H_ -#include -#include -#include +#include "../memory/HasMemoryIF.h" +#include "MonitoringMessage.h" +#include "../serialize/SerializeIF.h" class MonitoringIF : public SerializeIF { public: diff --git a/monitoring/MonitoringMessage.cpp b/monitoring/MonitoringMessage.cpp index 77919bfe..8caa27ae 100644 --- a/monitoring/MonitoringMessage.cpp +++ b/monitoring/MonitoringMessage.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "MonitoringMessage.h" +#include "../objectmanager/ObjectManagerIF.h" MonitoringMessage::~MonitoringMessage() { } diff --git a/monitoring/MonitoringMessage.h b/monitoring/MonitoringMessage.h index d2ff9b4d..248cd6ff 100644 --- a/monitoring/MonitoringMessage.h +++ b/monitoring/MonitoringMessage.h @@ -1,8 +1,8 @@ #ifndef MONITORINGMESSAGE_H_ #define MONITORINGMESSAGE_H_ -#include -#include +#include "../ipc/CommandMessage.h" +#include "../storagemanager/StorageManagerIF.h" class MonitoringMessage: public CommandMessage { public: diff --git a/monitoring/MonitoringMessageContent.h b/monitoring/MonitoringMessageContent.h index 7e1aca62..c82506f3 100644 --- a/monitoring/MonitoringMessageContent.h +++ b/monitoring/MonitoringMessageContent.h @@ -1,15 +1,15 @@ #ifndef MONITORINGMESSAGECONTENT_H_ #define MONITORINGMESSAGECONTENT_H_ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "HasMonitorsIF.h" +#include "MonitoringIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../serialize/SerialBufferAdapter.h" +#include "../serialize/SerialFixedArrayListAdapter.h" +#include "../serialize/SerializeElement.h" +#include "../serialize/SerialLinkedListAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../timemanager/TimeStamperIF.h" namespace Factory{ void setStaticFrameworkObjectIds(); diff --git a/monitoring/ReceivesMonitoringReportsIF.h b/monitoring/ReceivesMonitoringReportsIF.h index 42c365c1..fb37c16c 100644 --- a/monitoring/ReceivesMonitoringReportsIF.h +++ b/monitoring/ReceivesMonitoringReportsIF.h @@ -1,7 +1,7 @@ #ifndef RECEIVESMONITORINGREPORTSIF_H_ #define RECEIVESMONITORINGREPORTSIF_H_ -#include +#include "../ipc/MessageQueueSenderIF.h" class ReceivesMonitoringReportsIF { public: diff --git a/monitoring/TriplexMonitor.h b/monitoring/TriplexMonitor.h index 9a2e69c3..9b60aeb6 100644 --- a/monitoring/TriplexMonitor.h +++ b/monitoring/TriplexMonitor.h @@ -1,11 +1,11 @@ #ifndef FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ #define FRAMEWORK_MONITORING_TRIPLEXMONITOR_H_ -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PIDReaderList.h" +#include "../health/HealthTableIF.h" +#include "../parameters/HasParametersIF.h" +#include "../objectmanager/ObjectManagerIF.h" //SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering. diff --git a/monitoring/TwoValueLimitMonitor.h b/monitoring/TwoValueLimitMonitor.h index c17ad433..e690cdae 100644 --- a/monitoring/TwoValueLimitMonitor.h +++ b/monitoring/TwoValueLimitMonitor.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ #define FRAMEWORK_MONITORING_TWOVALUELIMITMONITOR_H_ -#include +#include "LimitMonitor.h" template class TwoValueLimitMonitor: public LimitMonitor { diff --git a/objectmanager/ObjectManager.cpp b/objectmanager/ObjectManager.cpp index 1c54355a..dd0ae188 100644 --- a/objectmanager/ObjectManager.cpp +++ b/objectmanager/ObjectManager.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "ObjectManager.h" +#include "../serviceinterface/ServiceInterfaceStream.h" #include #include diff --git a/objectmanager/ObjectManager.h b/objectmanager/ObjectManager.h index 63451071..0d2b3c4a 100644 --- a/objectmanager/ObjectManager.h +++ b/objectmanager/ObjectManager.h @@ -8,8 +8,8 @@ #ifndef OBJECTMANAGER_H_ #define OBJECTMANAGER_H_ -#include -#include +#include "ObjectManagerIF.h" +#include "SystemObjectIF.h" #include /** diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h index dcef81cd..e0162af9 100644 --- a/objectmanager/ObjectManagerIF.h +++ b/objectmanager/ObjectManagerIF.h @@ -1,10 +1,10 @@ #ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_ #define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_ -#include -#include -#include -#include +#include "frameworkObjects.h" +#include "SystemObjectIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serviceinterface/ServiceInterfaceStream.h" /** * @brief This class provides an interface to the global object manager. diff --git a/objectmanager/SystemObject.cpp b/objectmanager/SystemObject.cpp index 85daaa35..53aac599 100644 --- a/objectmanager/SystemObject.cpp +++ b/objectmanager/SystemObject.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../events/EventManagerIF.h" +#include "ObjectManager.h" +#include "SystemObject.h" SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) : objectId(setObjectId), registered(doRegister) { diff --git a/objectmanager/SystemObject.h b/objectmanager/SystemObject.h index 6a1b35b6..8e9f20d5 100644 --- a/objectmanager/SystemObject.h +++ b/objectmanager/SystemObject.h @@ -8,10 +8,10 @@ #ifndef SYSTEMOBJECT_H_ #define SYSTEMOBJECT_H_ -#include -#include -#include -#include +#include "../events/Event.h" +#include "../events/EventReportingProxyIF.h" +#include "SystemObjectIF.h" +#include "../timemanager/Clock.h" /** * @brief This class automates insertion into the ObjectManager and diff --git a/objectmanager/SystemObjectIF.h b/objectmanager/SystemObjectIF.h index 7540f80f..c5a92196 100644 --- a/objectmanager/SystemObjectIF.h +++ b/objectmanager/SystemObjectIF.h @@ -8,8 +8,8 @@ #ifndef SYSTEMOBJECTIF_H_ #define SYSTEMOBJECTIF_H_ -#include -#include +#include "../events/EventReportingProxyIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include /** * \defgroup system_objects Software System Object Management diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp index dce20265..9733c405 100644 --- a/osal/FreeRTOS/Clock.cpp +++ b/osal/FreeRTOS/Clock.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../../timemanager/Clock.h" +#include "../../globalfunctions/timevalOperations.h" +#include "Timekeeper.h" #include #include diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp index 17804d90..902502f9 100644 --- a/osal/FreeRTOS/FixedTimeslotTask.cpp +++ b/osal/FreeRTOS/FixedTimeslotTask.cpp @@ -1,6 +1,6 @@ #include "FixedTimeslotTask.h" -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" uint32_t FixedTimeslotTask::deadlineMissedCount = 0; const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE; diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h index 66af0311..d65f1fe4 100644 --- a/osal/FreeRTOS/FixedTimeslotTask.h +++ b/osal/FreeRTOS/FixedTimeslotTask.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ -#include -#include -#include +#include "../../devicehandlers/FixedSlotSequence.h" +#include "../../tasks/FixedTimeslotTaskIF.h" +#include "../../tasks/Typedef.h" #include #include diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp index 18e7aa3d..3bbd4d9d 100644 --- a/osal/FreeRTOS/MessageQueue.cpp +++ b/osal/FreeRTOS/MessageQueue.cpp @@ -1,6 +1,6 @@ #include "MessageQueue.h" -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" // TODO I guess we should have a way of checking if we are in an ISR and then use the "fromISR" versions of all calls diff --git a/osal/FreeRTOS/MessageQueue.h b/osal/FreeRTOS/MessageQueue.h index 32f41b44..aa3d54c1 100644 --- a/osal/FreeRTOS/MessageQueue.h +++ b/osal/FreeRTOS/MessageQueue.h @@ -1,9 +1,9 @@ #ifndef MESSAGEQUEUE_H_ #define MESSAGEQUEUE_H_ -#include -#include -#include +#include "../../internalError/InternalErrorReporterIF.h" +#include "../../ipc/MessageQueueIF.h" +#include "../../ipc/MessageQueueMessage.h" #include #include diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp index 7c511091..6da58783 100644 --- a/osal/FreeRTOS/Mutex.cpp +++ b/osal/FreeRTOS/Mutex.cpp @@ -1,6 +1,6 @@ #include "Mutex.h" -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" const uint32_t MutexIF::NO_TIMEOUT = 0; diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h index 91f29585..d376b7bc 100644 --- a/osal/FreeRTOS/Mutex.h +++ b/osal/FreeRTOS/Mutex.h @@ -1,7 +1,7 @@ #ifndef OS_RTEMS_MUTEX_H_ #define OS_RTEMS_MUTEX_H_ -#include +#include "../../ipc/MutexIF.h" #include diff --git a/osal/FreeRTOS/MutexFactory.cpp b/osal/FreeRTOS/MutexFactory.cpp index cadb54fb..75b63d07 100644 --- a/osal/FreeRTOS/MutexFactory.cpp +++ b/osal/FreeRTOS/MutexFactory.cpp @@ -1,4 +1,4 @@ -#include +#include "../../ipc/MutexFactory.h" #include "../FreeRTOS/Mutex.h" diff --git a/osal/FreeRTOS/PeriodicTask.cpp b/osal/FreeRTOS/PeriodicTask.cpp index 91135375..a95333b4 100644 --- a/osal/FreeRTOS/PeriodicTask.cpp +++ b/osal/FreeRTOS/PeriodicTask.cpp @@ -1,7 +1,7 @@ #include "PeriodicTask.h" -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "../../tasks/ExecutableObjectIF.h" PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority, TaskStackSize setStack, TaskPeriod setPeriod, diff --git a/osal/FreeRTOS/PeriodicTask.h b/osal/FreeRTOS/PeriodicTask.h index 09aa6bc7..3eb8f57e 100644 --- a/osal/FreeRTOS/PeriodicTask.h +++ b/osal/FreeRTOS/PeriodicTask.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_ #define FRAMEWORK_OSAL_FREERTOS_PERIODICTASK_H_ -#include -#include -#include +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../tasks/PeriodicTaskIF.h" +#include "../../tasks/Typedef.h" #include #include diff --git a/osal/FreeRTOS/QueueFactory.cpp b/osal/FreeRTOS/QueueFactory.cpp index a0128918..e639179a 100644 --- a/osal/FreeRTOS/QueueFactory.cpp +++ b/osal/FreeRTOS/QueueFactory.cpp @@ -1,6 +1,6 @@ -#include +#include "../../ipc/QueueFactory.h" -#include +#include "MessageQueue.h" QueueFactory* QueueFactory::factoryInstance = NULL; diff --git a/osal/FreeRTOS/TaskFactory.cpp b/osal/FreeRTOS/TaskFactory.cpp index 753da60f..80df38b2 100644 --- a/osal/FreeRTOS/TaskFactory.cpp +++ b/osal/FreeRTOS/TaskFactory.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../tasks/TaskFactory.h" +#include "../../returnvalues/HasReturnvaluesIF.h" #include "PeriodicTask.h" #include "FixedTimeslotTask.h" diff --git a/osal/FreeRTOS/Timekeeper.cpp b/osal/FreeRTOS/Timekeeper.cpp index 643b2747..1031f0c4 100644 --- a/osal/FreeRTOS/Timekeeper.cpp +++ b/osal/FreeRTOS/Timekeeper.cpp @@ -1,4 +1,4 @@ -#include +#include "Timekeeper.h" #include "FreeRTOSConfig.h" diff --git a/osal/FreeRTOS/Timekeeper.h b/osal/FreeRTOS/Timekeeper.h index 7d3ca22b..7d583f7d 100644 --- a/osal/FreeRTOS/Timekeeper.h +++ b/osal/FreeRTOS/Timekeeper.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ #define FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ -#include +#include "../../timemanager/Clock.h" #include #include diff --git a/osal/InternalErrorCodes.h b/osal/InternalErrorCodes.h index 5419fd94..1da116fa 100644 --- a/osal/InternalErrorCodes.h +++ b/osal/InternalErrorCodes.h @@ -1,7 +1,7 @@ #ifndef INTERNALERRORCODES_H_ #define INTERNALERRORCODES_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" class InternalErrorCodes { public: diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp index 630b2cf4..48e325ef 100644 --- a/osal/linux/Clock.cpp +++ b/osal/linux/Clock.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "../../timemanager/Clock.h" #include #include diff --git a/osal/linux/FixedTimeslotTask.cpp b/osal/linux/FixedTimeslotTask.cpp index e5c68f9d..858a39a7 100644 --- a/osal/linux/FixedTimeslotTask.cpp +++ b/osal/linux/FixedTimeslotTask.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "FixedTimeslotTask.h" #include diff --git a/osal/linux/FixedTimeslotTask.h b/osal/linux/FixedTimeslotTask.h index 916e6d6c..42802b1d 100644 --- a/osal/linux/FixedTimeslotTask.h +++ b/osal/linux/FixedTimeslotTask.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ #define FRAMEWORK_OSAL_LINUX_FIXEDTIMESLOTTASK_H_ -#include -#include -#include +#include "../../tasks/FixedTimeslotTaskIF.h" +#include "../../devicehandlers/FixedSlotSequence.h" +#include "PosixThread.h" #include class FixedTimeslotTask: public FixedTimeslotTaskIF, public PosixThread { diff --git a/osal/linux/InternalErrorCodes.cpp b/osal/linux/InternalErrorCodes.cpp index 7f83663b..a01cc72a 100644 --- a/osal/linux/InternalErrorCodes.cpp +++ b/osal/linux/InternalErrorCodes.cpp @@ -1,4 +1,4 @@ -#include +#include "../../osal/InternalErrorCodes.h" ReturnValue_t InternalErrorCodes::translate(uint8_t code) { //TODO This class can be removed diff --git a/osal/linux/MessageQueue.cpp b/osal/linux/MessageQueue.cpp index a0749ded..e5c61cae 100644 --- a/osal/linux/MessageQueue.cpp +++ b/osal/linux/MessageQueue.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "MessageQueue.h" #include diff --git a/osal/linux/MessageQueue.h b/osal/linux/MessageQueue.h index 2808d36e..31cdca11 100644 --- a/osal/linux/MessageQueue.h +++ b/osal/linux/MessageQueue.h @@ -1,9 +1,9 @@ #ifndef MESSAGEQUEUE_H_ #define MESSAGEQUEUE_H_ -#include -#include -#include +#include "../../internalError/InternalErrorReporterIF.h" +#include "../../ipc/MessageQueueIF.h" +#include "../../ipc/MessageQueueMessage.h" #include /** diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp index 36bb3ce4..dd8d3c5b 100644 --- a/osal/linux/Mutex.cpp +++ b/osal/linux/Mutex.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "Mutex.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "../../timemanager/Clock.h" const uint32_t MutexIF::NO_TIMEOUT = 0; uint8_t Mutex::count = 0; diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h index d02d008f..9f9bf521 100644 --- a/osal/linux/Mutex.h +++ b/osal/linux/Mutex.h @@ -1,7 +1,7 @@ #ifndef OS_RTEMS_MUTEX_H_ #define OS_RTEMS_MUTEX_H_ -#include +#include "../../ipc/MutexIF.h" #include class Mutex : public MutexIF { diff --git a/osal/linux/MutexFactory.cpp b/osal/linux/MutexFactory.cpp index d769cc33..8c2faf88 100644 --- a/osal/linux/MutexFactory.cpp +++ b/osal/linux/MutexFactory.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../ipc/MutexFactory.h" +#include "Mutex.h" //TODO: Different variant than the lazy loading in QueueFactory. What's better and why? MutexFactory* MutexFactory::factoryInstance = new MutexFactory(); diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp index 6149c84b..c08bb472 100644 --- a/osal/linux/PeriodicPosixTask.cpp +++ b/osal/linux/PeriodicPosixTask.cpp @@ -1,7 +1,7 @@ -#include -#include +#include "../../tasks/ExecutableObjectIF.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" #include -#include +#include "PeriodicPosixTask.h" PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_, size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()): diff --git a/osal/linux/PeriodicPosixTask.h b/osal/linux/PeriodicPosixTask.h index bf1a995b..6737cee6 100644 --- a/osal/linux/PeriodicPosixTask.h +++ b/osal/linux/PeriodicPosixTask.h @@ -1,10 +1,10 @@ #ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ #define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_ -#include -#include -#include -#include +#include "../../tasks/PeriodicTaskIF.h" +#include "../../objectmanager/ObjectManagerIF.h" +#include "PosixThread.h" +#include "../../tasks/ExecutableObjectIF.h" #include class PeriodicPosixTask: public PosixThread, public PeriodicTaskIF { diff --git a/osal/linux/PosixThread.cpp b/osal/linux/PosixThread.cpp index bc3e62ed..ddb1f74f 100644 --- a/osal/linux/PosixThread.cpp +++ b/osal/linux/PosixThread.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "PosixThread.h" #include #include diff --git a/osal/linux/PosixThread.h b/osal/linux/PosixThread.h index e9d31728..7d8d349a 100644 --- a/osal/linux/PosixThread.h +++ b/osal/linux/PosixThread.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ #define FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ -#include +#include "../../returnvalues/HasReturnvaluesIF.h" #include #include #include diff --git a/osal/linux/QueueFactory.cpp b/osal/linux/QueueFactory.cpp index 268d0b99..afeca547 100644 --- a/osal/linux/QueueFactory.cpp +++ b/osal/linux/QueueFactory.cpp @@ -1,8 +1,8 @@ -#include +#include "../../ipc/QueueFactory.h" #include #include -#include -#include +#include "MessageQueue.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" #include QueueFactory* QueueFactory::factoryInstance = nullptr; diff --git a/osal/linux/TaskFactory.cpp b/osal/linux/TaskFactory.cpp index 219630a7..f507c767 100644 --- a/osal/linux/TaskFactory.cpp +++ b/osal/linux/TaskFactory.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "FixedTimeslotTask.h" +#include "PeriodicPosixTask.h" +#include "../../tasks/TaskFactory.h" +#include "../../returnvalues/HasReturnvaluesIF.h" //TODO: Different variant than the lazy loading in QueueFactory. What's better and why? TaskFactory* TaskFactory::factoryInstance = new TaskFactory(); diff --git a/osal/linux/Timer.cpp b/osal/linux/Timer.cpp index 5e27c328..ee964baa 100644 --- a/osal/linux/Timer.cpp +++ b/osal/linux/Timer.cpp @@ -1,6 +1,6 @@ -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" #include -#include +#include "Timer.h" Timer::Timer() { sigevent sigEvent; diff --git a/osal/rtems/Clock.cpp b/osal/rtems/Clock.cpp index 98198dd3..eeffd7f3 100644 --- a/osal/rtems/Clock.cpp +++ b/osal/rtems/Clock.cpp @@ -1,4 +1,4 @@ -#include +#include "../../timemanager/Clock.h" #include "RtemsBasic.h" #include diff --git a/osal/rtems/CpuUsage.cpp b/osal/rtems/CpuUsage.cpp index 61b66c3d..d49de4ad 100644 --- a/osal/rtems/CpuUsage.cpp +++ b/osal/rtems/CpuUsage.cpp @@ -1,6 +1,6 @@ #include "CpuUsage.h" -#include -#include +#include "../../serialize/SerialArrayListAdapter.h" +#include "../../serialize/SerializeAdapter.h" #include extern "C" { diff --git a/osal/rtems/CpuUsage.h b/osal/rtems/CpuUsage.h index eb03c5e3..f487e191 100644 --- a/osal/rtems/CpuUsage.h +++ b/osal/rtems/CpuUsage.h @@ -1,8 +1,8 @@ #ifndef CPUUSAGE_H_ #define CPUUSAGE_H_ -#include -#include +#include "../../container/FixedArrayList.h" +#include "../../serialize/SerializeIF.h" #include class CpuUsage : public SerializeIF { diff --git a/osal/rtems/InternalErrorCodes.cpp b/osal/rtems/InternalErrorCodes.cpp index dbe3172e..9346cf15 100644 --- a/osal/rtems/InternalErrorCodes.cpp +++ b/osal/rtems/InternalErrorCodes.cpp @@ -1,4 +1,4 @@ -#include +#include "../../osal/InternalErrorCodes.h" #include ReturnValue_t InternalErrorCodes::translate(uint8_t code) { diff --git a/osal/rtems/Interrupt.h b/osal/rtems/Interrupt.h index c4c21911..2152e2f0 100644 --- a/osal/rtems/Interrupt.h +++ b/osal/rtems/Interrupt.h @@ -1,7 +1,7 @@ #ifndef OS_RTEMS_INTERRUPT_H_ #define OS_RTEMS_INTERRUPT_H_ -#include +#include "../../returnvalues/HasReturnvaluesIF.h" #include #include diff --git a/osal/rtems/MessageQueue.cpp b/osal/rtems/MessageQueue.cpp index de148fdc..700db444 100644 --- a/osal/rtems/MessageQueue.cpp +++ b/osal/rtems/MessageQueue.cpp @@ -1,4 +1,4 @@ -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" #include "MessageQueue.h" #include "RtemsBasic.h" #include diff --git a/osal/rtems/MessageQueue.h b/osal/rtems/MessageQueue.h index 9bdce7ca..c6fc62d5 100644 --- a/osal/rtems/MessageQueue.h +++ b/osal/rtems/MessageQueue.h @@ -10,9 +10,9 @@ #ifndef MESSAGEQUEUE_H_ #define MESSAGEQUEUE_H_ -#include -#include -#include +#include "../../internalError/InternalErrorReporterIF.h" +#include "../../ipc/MessageQueueIF.h" +#include "../../ipc/MessageQueueMessage.h" #include "RtemsBasic.h" /** diff --git a/osal/rtems/MultiObjectTask.cpp b/osal/rtems/MultiObjectTask.cpp index bb8c2c81..3c4886a5 100644 --- a/osal/rtems/MultiObjectTask.cpp +++ b/osal/rtems/MultiObjectTask.cpp @@ -5,8 +5,8 @@ * @author baetz */ -#include -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "../../tasks/ExecutableObjectIF.h" #include "MultiObjectTask.h" MultiObjectTask::MultiObjectTask(const char *name, rtems_task_priority setPriority, diff --git a/osal/rtems/MultiObjectTask.h b/osal/rtems/MultiObjectTask.h index 64b09c52..28d05fb1 100644 --- a/osal/rtems/MultiObjectTask.h +++ b/osal/rtems/MultiObjectTask.h @@ -7,8 +7,8 @@ #ifndef MULTIOBJECTTASK_H_ #define MULTIOBJECTTASK_H_ -#include -#include +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../tasks/PeriodicTaskIF.h" #include "TaskBase.h" #include diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp index d094e1dc..d8babcde 100644 --- a/osal/rtems/Mutex.cpp +++ b/osal/rtems/Mutex.cpp @@ -1,5 +1,5 @@ #include "Mutex.h" -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT; uint8_t Mutex::count = 0; diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h index 19b34e7f..340bb16b 100644 --- a/osal/rtems/Mutex.h +++ b/osal/rtems/Mutex.h @@ -1,7 +1,7 @@ #ifndef OS_RTEMS_MUTEX_H_ #define OS_RTEMS_MUTEX_H_ -#include +#include "../../ipc/MutexIF.h" #include "RtemsBasic.h" class Mutex : public MutexIF { diff --git a/osal/rtems/MutexFactory.cpp b/osal/rtems/MutexFactory.cpp index d7bd16bc..ea594789 100644 --- a/osal/rtems/MutexFactory.cpp +++ b/osal/rtems/MutexFactory.cpp @@ -1,4 +1,4 @@ -#include +#include "../../ipc/MutexFactory.h" #include "Mutex.h" #include "RtemsBasic.h" diff --git a/osal/rtems/PollingTask.cpp b/osal/rtems/PollingTask.cpp index 03ba0951..04191515 100644 --- a/osal/rtems/PollingTask.cpp +++ b/osal/rtems/PollingTask.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "../../devicehandlers/FixedSequenceSlot.h" +#include "../../objectmanager/SystemObjectIF.h" +#include "PollingTask.h" +#include "RtemsBasic.h" +#include "../../returnvalues/HasReturnvaluesIF.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" #include #include #include diff --git a/osal/rtems/PollingTask.h b/osal/rtems/PollingTask.h index 82ec65a2..199c34e7 100644 --- a/osal/rtems/PollingTask.h +++ b/osal/rtems/PollingTask.h @@ -1,8 +1,8 @@ #ifndef POLLINGTASK_H_ #define POLLINGTASK_H_ -#include -#include +#include "../../devicehandlers/FixedSlotSequence.h" +#include "../../tasks/FixedTimeslotTaskIF.h" #include "TaskBase.h" class PollingTask: public TaskBase, public FixedTimeslotTaskIF { diff --git a/osal/rtems/QueueFactory.cpp b/osal/rtems/QueueFactory.cpp index 8cc9905c..fce55a0e 100644 --- a/osal/rtems/QueueFactory.cpp +++ b/osal/rtems/QueueFactory.cpp @@ -1,4 +1,4 @@ -#include +#include "../../ipc/QueueFactory.h" #include "MessageQueue.h" #include "RtemsBasic.h" diff --git a/osal/rtems/RtemsBasic.h b/osal/rtems/RtemsBasic.h index f7ab8614..78e0d46e 100644 --- a/osal/rtems/RtemsBasic.h +++ b/osal/rtems/RtemsBasic.h @@ -1,7 +1,7 @@ #ifndef OS_RTEMS_RTEMSBASIC_H_ #define OS_RTEMS_RTEMSBASIC_H_ -#include +#include "../../returnvalues/HasReturnvaluesIF.h" #include #include #include diff --git a/osal/rtems/TaskBase.cpp b/osal/rtems/TaskBase.cpp index ad795645..adf6ee70 100644 --- a/osal/rtems/TaskBase.cpp +++ b/osal/rtems/TaskBase.cpp @@ -1,4 +1,4 @@ -#include +#include "../../serviceinterface/ServiceInterfaceStream.h" #include "TaskBase.h" const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE=RTEMS_MINIMUM_STACK_SIZE; diff --git a/osal/rtems/TaskBase.h b/osal/rtems/TaskBase.h index b9c1192a..410d9110 100644 --- a/osal/rtems/TaskBase.h +++ b/osal/rtems/TaskBase.h @@ -2,7 +2,7 @@ #define TASKBASE_H_ #include "RtemsBasic.h" -#include +#include "../../tasks/PeriodicTaskIF.h" /** * @brief This is the basic task handling class for rtems. diff --git a/osal/rtems/TaskFactory.cpp b/osal/rtems/TaskFactory.cpp index 2bee19c7..bab48a44 100644 --- a/osal/rtems/TaskFactory.cpp +++ b/osal/rtems/TaskFactory.cpp @@ -1,9 +1,9 @@ -#include +#include "../../tasks/TaskFactory.h" #include "MultiObjectTask.h" #include "PollingTask.h" #include "InitTask.h" #include "RtemsBasic.h" -#include +#include "../../returnvalues/HasReturnvaluesIF.h" //TODO: Different variant than the lazy loading in QueueFactory. What's better and why? TaskFactory* TaskFactory::factoryInstance = new TaskFactory(); diff --git a/parameters/HasParametersIF.h b/parameters/HasParametersIF.h index fbb69445..71212b57 100644 --- a/parameters/HasParametersIF.h +++ b/parameters/HasParametersIF.h @@ -1,8 +1,8 @@ #ifndef HASPARAMETERSIF_H_ #define HASPARAMETERSIF_H_ -#include -#include +#include "ParameterWrapper.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include typedef uint32_t ParameterId_t; diff --git a/parameters/ParameterHelper.cpp b/parameters/ParameterHelper.cpp index f896f00f..8543515f 100644 --- a/parameters/ParameterHelper.cpp +++ b/parameters/ParameterHelper.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "ParameterHelper.h" +#include "ParameterMessage.h" ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) : owner(owner), storage(NULL) { diff --git a/parameters/ParameterHelper.h b/parameters/ParameterHelper.h index e2fefdba..d887bf1d 100644 --- a/parameters/ParameterHelper.h +++ b/parameters/ParameterHelper.h @@ -1,8 +1,8 @@ #ifndef PARAMETERHELPER_H_ #define PARAMETERHELPER_H_ -#include -#include +#include "ParameterMessage.h" +#include "ReceivesParameterMessagesIF.h" class ParameterHelper { public: diff --git a/parameters/ParameterMessage.cpp b/parameters/ParameterMessage.cpp index 1c7d6911..7e0ed114 100644 --- a/parameters/ParameterMessage.cpp +++ b/parameters/ParameterMessage.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "ParameterMessage.h" +#include "../objectmanager/ObjectManagerIF.h" ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) { return message->getParameter(); diff --git a/parameters/ParameterMessage.h b/parameters/ParameterMessage.h index 0f286675..7cb02d96 100644 --- a/parameters/ParameterMessage.h +++ b/parameters/ParameterMessage.h @@ -1,9 +1,9 @@ #ifndef PARAMETERMESSAGE_H_ #define PARAMETERMESSAGE_H_ -#include -#include -#include +#include "../ipc/CommandMessage.h" +#include "HasParametersIF.h" +#include "../storagemanager/StorageManagerIF.h" class ParameterMessage { private: diff --git a/parameters/ParameterWrapper.cpp b/parameters/ParameterWrapper.cpp index bbf1e8a3..56f56426 100644 --- a/parameters/ParameterWrapper.cpp +++ b/parameters/ParameterWrapper.cpp @@ -1,4 +1,4 @@ -#include +#include "ParameterWrapper.h" ParameterWrapper::ParameterWrapper() : pointsToStream(false), type(Type::UNKNOWN_TYPE), rows(0), columns(0), data( diff --git a/parameters/ParameterWrapper.h b/parameters/ParameterWrapper.h index a00c997c..b18fe2b9 100644 --- a/parameters/ParameterWrapper.h +++ b/parameters/ParameterWrapper.h @@ -1,11 +1,11 @@ #ifndef PARAMETERWRAPPER_H_ #define PARAMETERWRAPPER_H_ -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serialize/SerializeIF.h" #include -#include +#include "../globalfunctions/Type.h" class ParameterWrapper: public SerializeIF { friend class DataPoolParameterWrapper; diff --git a/parameters/ReceivesParameterMessagesIF.h b/parameters/ReceivesParameterMessagesIF.h index 9bcd226d..1fcbd4b3 100644 --- a/parameters/ReceivesParameterMessagesIF.h +++ b/parameters/ReceivesParameterMessagesIF.h @@ -2,8 +2,8 @@ #define RECEIVESPARAMETERMESSAGESIF_H_ -#include -#include +#include "HasParametersIF.h" +#include "../ipc/MessageQueueSenderIF.h" class ReceivesParameterMessagesIF : public HasParametersIF { public: diff --git a/power/Fuse.cpp b/power/Fuse.cpp index db24100b..9986ab6b 100644 --- a/power/Fuse.cpp +++ b/power/Fuse.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include "../monitoring/LimitViolationReporter.h" +#include "../monitoring/MonitoringMessageContent.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "Fuse.h" +#include "../serialize/SerialFixedArrayListAdapter.h" +#include "../ipc/QueueFactory.h" object_id_t Fuse::powerSwitchId = 0; diff --git a/power/Fuse.h b/power/Fuse.h index 4e22e3ed..279642be 100644 --- a/power/Fuse.h +++ b/power/Fuse.h @@ -1,14 +1,14 @@ #ifndef FUSE_H_ #define FUSE_H_ -#include -#include -#include -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PIDReader.h" +#include "../devicehandlers/HealthDevice.h" +#include "../monitoring/AbsLimitMonitor.h" +#include "PowerComponentIF.h" +#include "PowerSwitchIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../parameters/ParameterHelper.h" #include namespace Factory { diff --git a/power/PowerComponent.cpp b/power/PowerComponent.cpp index cd116a86..6012ad4c 100644 --- a/power/PowerComponent.cpp +++ b/power/PowerComponent.cpp @@ -5,7 +5,7 @@ * @author baetz */ -#include +#include "PowerComponent.h" PowerComponent::PowerComponent() : deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches( diff --git a/power/PowerComponent.h b/power/PowerComponent.h index 61ab3674..6d1c9c06 100644 --- a/power/PowerComponent.h +++ b/power/PowerComponent.h @@ -1,8 +1,8 @@ #ifndef POWERCOMPONENT_H_ #define POWERCOMPONENT_H_ -#include -#include +#include "../objectmanager/SystemObjectIF.h" +#include "PowerComponentIF.h" class PowerComponent: public PowerComponentIF { public: diff --git a/power/PowerComponentIF.h b/power/PowerComponentIF.h index f2aa70ae..c2e3a6a5 100644 --- a/power/PowerComponentIF.h +++ b/power/PowerComponentIF.h @@ -1,8 +1,8 @@ #ifndef POWERCOMPONENTIF_H_ #define POWERCOMPONENTIF_H_ -#include -#include +#include "../serialize/SerializeIF.h" +#include "../parameters/HasParametersIF.h" class PowerComponentIF : public SerializeIF, public HasParametersIF { public: diff --git a/power/PowerSensor.cpp b/power/PowerSensor.cpp index 5433acc9..50cb6acd 100644 --- a/power/PowerSensor.cpp +++ b/power/PowerSensor.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "PowerSensor.h" +#include "../ipc/QueueFactory.h" PowerSensor::PowerSensor(object_id_t setId, VariableIds ids, DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) : diff --git a/power/PowerSensor.h b/power/PowerSensor.h index 922560d0..0f973e45 100644 --- a/power/PowerSensor.h +++ b/power/PowerSensor.h @@ -1,14 +1,14 @@ #ifndef POWERSENSOR_H_ #define POWERSENSOR_H_ -#include -#include -#include -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PIDReader.h" +#include "../datapool/PoolVariable.h" +#include "../devicehandlers/HealthDevice.h" +#include "../monitoring/LimitMonitor.h" +#include "../parameters/ParameterHelper.h" +#include "../objectmanager/SystemObject.h" +#include "../ipc/MessageQueueIF.h" class PowerController; diff --git a/power/PowerSwitchIF.h b/power/PowerSwitchIF.h index 1c4c06f7..40220fb6 100644 --- a/power/PowerSwitchIF.h +++ b/power/PowerSwitchIF.h @@ -8,8 +8,8 @@ #ifndef POWERSWITCHIF_H_ #define POWERSWITCHIF_H_ -#include -#include +#include "../events/Event.h" +#include "../returnvalues/HasReturnvaluesIF.h" /** * This interface defines a connection to a device that is capable of turning on and off * switches of devices identified by a switch ID. diff --git a/power/PowerSwitcher.cpp b/power/PowerSwitcher.cpp index 6b06bf73..6296a04c 100644 --- a/power/PowerSwitcher.cpp +++ b/power/PowerSwitcher.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "PowerSwitcher.h" +#include "../serviceinterface/ServiceInterfaceStream.h" PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2, PowerSwitcher::State_t setStartState) : diff --git a/power/PowerSwitcher.h b/power/PowerSwitcher.h index 5b2789e9..0f1c02de 100644 --- a/power/PowerSwitcher.h +++ b/power/PowerSwitcher.h @@ -1,8 +1,8 @@ #ifndef POWERSWITCHER_H_ #define POWERSWITCHER_H_ -#include -#include -#include +#include "PowerSwitchIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../timemanager/Countdown.h" class PowerSwitcher : public HasReturnvaluesIF { public: diff --git a/pus/CService200ModeCommanding.cpp b/pus/CService200ModeCommanding.cpp index fd6da67e..32f7e5a7 100644 --- a/pus/CService200ModeCommanding.cpp +++ b/pus/CService200ModeCommanding.cpp @@ -1,119 +1,119 @@ -#include -#include - -#include -#include -#include -#include - -CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId, - uint16_t apid, uint8_t serviceId): - CommandingServiceBase(objectId, apid, serviceId, - NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {} - -CService200ModeCommanding::~CService200ModeCommanding() {} - -ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) { - switch(subservice) { - case(Subservice::COMMAND_MODE_COMMAND): - case(Subservice::COMMAND_MODE_READ): - case(Subservice::COMMAND_MODE_ANNCOUNCE): - return RETURN_OK; - default: - return AcceptsTelecommandsIF::INVALID_SUBSERVICE; - } -} - - -ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject( - uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, - MessageQueueId_t *id, object_id_t *objectId) { - if(tcDataLen < sizeof(object_id_t)) { - return CommandingServiceBase::INVALID_TC; - } - SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, - SerializeIF::Endianness::BIG); - - return checkInterfaceAndAcquireMessageQueue(id,objectId); -} - -ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { - HasModesIF * destination = objectManager->get(*objectId); - if(destination == nullptr) { - return CommandingServiceBase::INVALID_OBJECT; - - } - - *messageQueueToSet = destination->getCommandQueue(); - return HasReturnvaluesIF::RETURN_OK; -} - - -ReturnValue_t CService200ModeCommanding::prepareCommand( - CommandMessage* message,uint8_t subservice, const uint8_t *tcData, - size_t tcDataLen, uint32_t *state, object_id_t objectId) { - ModePacket modeCommandPacket; - ReturnValue_t result = modeCommandPacket.deSerialize(&tcData, - &tcDataLen, SerializeIF::Endianness::BIG); - if (result != RETURN_OK) { - return result; - } - - ModeMessage::setModeMessage(dynamic_cast(message), - ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(), - modeCommandPacket.getSubmode()); - return result; -} - - -ReturnValue_t CService200ModeCommanding::handleReply( - const CommandMessage* reply, Command_t previousCommand, - uint32_t *state, CommandMessage* optionalNextCommand, - object_id_t objectId, bool *isStep) { - Command_t replyId = reply->getCommand(); - ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; - switch(replyId) { - case(ModeMessage::REPLY_MODE_REPLY): { - result = prepareModeReply(reply, objectId); - break; - } - case(ModeMessage::REPLY_WRONG_MODE_REPLY): { - result = prepareWrongModeReply(reply, objectId); - break; - } - case(ModeMessage::REPLY_CANT_REACH_MODE): { - result = prepareCantReachModeReply(reply, objectId); - break; - } - case(ModeMessage::REPLY_MODE_INFO): - result = INVALID_REPLY; - break; - default: - result = RETURN_FAILED; - } - return result; -} - -ReturnValue_t CService200ModeCommanding::prepareModeReply( - const CommandMessage *reply, object_id_t objectId) { - ModePacket modeReplyPacket(objectId, - ModeMessage::getMode(reply), - ModeMessage::getSubmode(reply)); - return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket); -} - -ReturnValue_t CService200ModeCommanding::prepareWrongModeReply( - const CommandMessage *reply, object_id_t objectId) { - ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), - ModeMessage::getSubmode(reply)); - return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply); -} - -ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply( - const CommandMessage *reply, object_id_t objectId) { - CantReachModePacket cantReachModePacket(objectId, - ModeMessage::getCantReachModeReason(reply)); - return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, - &cantReachModePacket); -} +#include "CService200ModeCommanding.h" +#include "servicepackets/Service200Packets.h" + +#include "../modes/HasModesIF.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../serialize/SerialLinkedListAdapter.h" +#include "../modes/ModeMessage.h" + +CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId, + uint16_t apid, uint8_t serviceId): + CommandingServiceBase(objectId, apid, serviceId, + NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {} + +CService200ModeCommanding::~CService200ModeCommanding() {} + +ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) { + switch(subservice) { + case(Subservice::COMMAND_MODE_COMMAND): + case(Subservice::COMMAND_MODE_READ): + case(Subservice::COMMAND_MODE_ANNCOUNCE): + return RETURN_OK; + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + + +ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject( + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + MessageQueueId_t *id, object_id_t *objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, + SerializeIF::Endianness::BIG); + + return checkInterfaceAndAcquireMessageQueue(id,objectId); +} + +ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { + HasModesIF * destination = objectManager->get(*objectId); + if(destination == nullptr) { + return CommandingServiceBase::INVALID_OBJECT; + + } + + *messageQueueToSet = destination->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t CService200ModeCommanding::prepareCommand( + CommandMessage* message,uint8_t subservice, const uint8_t *tcData, + size_t tcDataLen, uint32_t *state, object_id_t objectId) { + ModePacket modeCommandPacket; + ReturnValue_t result = modeCommandPacket.deSerialize(&tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + return result; + } + + ModeMessage::setModeMessage(dynamic_cast(message), + ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(), + modeCommandPacket.getSubmode()); + return result; +} + + +ReturnValue_t CService200ModeCommanding::handleReply( + const CommandMessage* reply, Command_t previousCommand, + uint32_t *state, CommandMessage* optionalNextCommand, + object_id_t objectId, bool *isStep) { + Command_t replyId = reply->getCommand(); + ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; + switch(replyId) { + case(ModeMessage::REPLY_MODE_REPLY): { + result = prepareModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_WRONG_MODE_REPLY): { + result = prepareWrongModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_CANT_REACH_MODE): { + result = prepareCantReachModeReply(reply, objectId); + break; + } + case(ModeMessage::REPLY_MODE_INFO): + result = INVALID_REPLY; + break; + default: + result = RETURN_FAILED; + } + return result; +} + +ReturnValue_t CService200ModeCommanding::prepareModeReply( + const CommandMessage *reply, object_id_t objectId) { + ModePacket modeReplyPacket(objectId, + ModeMessage::getMode(reply), + ModeMessage::getSubmode(reply)); + return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket); +} + +ReturnValue_t CService200ModeCommanding::prepareWrongModeReply( + const CommandMessage *reply, object_id_t objectId) { + ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), + ModeMessage::getSubmode(reply)); + return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply); +} + +ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply( + const CommandMessage *reply, object_id_t objectId) { + CantReachModePacket cantReachModePacket(objectId, + ModeMessage::getCantReachModeReason(reply)); + return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, + &cantReachModePacket); +} diff --git a/pus/CService200ModeCommanding.h b/pus/CService200ModeCommanding.h index ede61a84..89347dbd 100644 --- a/pus/CService200ModeCommanding.h +++ b/pus/CService200ModeCommanding.h @@ -1,85 +1,85 @@ -#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ -#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ - -#include - -/** - * @brief Custom PUS service to set mode of all objects implementing HasModesIF - * - * Examples: Device Handlers, Assemblies or Subsystems. - * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A - * Dissertation Baetz p. 115, 116, 165-167. - * - * This is a gateway service. It relays device commands using the software bus. - * @ingroup pus_services - */ -class CService200ModeCommanding: public CommandingServiceBase { -public: - static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4; - static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60; - - CService200ModeCommanding(object_id_t objectId, - uint16_t apid, uint8_t serviceId); - virtual~ CService200ModeCommanding(); - -protected: - //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. - ReturnValue_t isValidSubservice(uint8_t subservice) override; - ReturnValue_t getMessageQueueAndObject(uint8_t subservice, - const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, - object_id_t *objectId) override; - ReturnValue_t prepareCommand(CommandMessage* message, - uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, - uint32_t *state, object_id_t objectId) override; - ReturnValue_t handleReply(const CommandMessage* reply, - Command_t previousCommand, uint32_t *state, - CommandMessage* optionalNextCommand, object_id_t objectId, - bool *isStep) override; - -private: - ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet, - const uint8_t* tcData, uint32_t tcDataLen); - ReturnValue_t checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* MessageQueueToSet, object_id_t* objectId); - - ReturnValue_t prepareModeReply(const CommandMessage *reply, - object_id_t objectId); - ReturnValue_t prepareWrongModeReply(const CommandMessage *reply, - object_id_t objectId); - ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply, - object_id_t objectId); - - enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices - //!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode - COMMAND_MODE_COMMAND = 1, - //!< [EXPORT] : [COMMAND] Command to set the specified Mode, - //! regardless of external control flag - COMMAND_MODE_COMMAND_FORCED = 2, - //!< [EXPORT] : [COMMAND] Read the current mode and - //! reply with a REPLY_MODE_REPLY - COMMAND_MODE_READ = 3, - //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event. - //! This command does NOT have a reply - COMMAND_MODE_ANNCOUNCE = 4, - //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this - //! command to every child. This command does NOT have a reply. - COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5, - //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ - REPLY_MODE_REPLY = 6, - //!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed. - REPLY_CANT_REACH_MODE = 7, - //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a - //! mode was commanded and a transition started but was aborted, - //! the parameters contain the mode that was reached - REPLY_WRONG_MODE_REPLY = 8 - }; - - enum modeParameters { - MODE_OFF = 0, - MODE_ON = 1, - MODE_NORMAL = 2, - MODE_RAW = 3 - }; -}; - -#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */ +#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ +#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ + +#include "../tmtcservices/CommandingServiceBase.h" + +/** + * @brief Custom PUS service to set mode of all objects implementing HasModesIF + * + * Examples: Device Handlers, Assemblies or Subsystems. + * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A + * Dissertation Baetz p. 115, 116, 165-167. + * + * This is a gateway service. It relays device commands using the software bus. + * @ingroup pus_services + */ +class CService200ModeCommanding: public CommandingServiceBase { +public: + static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4; + static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60; + + CService200ModeCommanding(object_id_t objectId, + uint16_t apid, uint8_t serviceId); + virtual~ CService200ModeCommanding(); + +protected: + //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + uint32_t *state, object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + +private: + ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet, + const uint8_t* tcData, uint32_t tcDataLen); + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* MessageQueueToSet, object_id_t* objectId); + + ReturnValue_t prepareModeReply(const CommandMessage *reply, + object_id_t objectId); + ReturnValue_t prepareWrongModeReply(const CommandMessage *reply, + object_id_t objectId); + ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply, + object_id_t objectId); + + enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices + //!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode + COMMAND_MODE_COMMAND = 1, + //!< [EXPORT] : [COMMAND] Command to set the specified Mode, + //! regardless of external control flag + COMMAND_MODE_COMMAND_FORCED = 2, + //!< [EXPORT] : [COMMAND] Read the current mode and + //! reply with a REPLY_MODE_REPLY + COMMAND_MODE_READ = 3, + //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event. + //! This command does NOT have a reply + COMMAND_MODE_ANNCOUNCE = 4, + //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this + //! command to every child. This command does NOT have a reply. + COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5, + //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ + REPLY_MODE_REPLY = 6, + //!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed. + REPLY_CANT_REACH_MODE = 7, + //!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a + //! mode was commanded and a transition started but was aborted, + //! the parameters contain the mode that was reached + REPLY_WRONG_MODE_REPLY = 8 + }; + + enum modeParameters { + MODE_OFF = 0, + MODE_ON = 1, + MODE_NORMAL = 2, + MODE_RAW = 3 + }; +}; + +#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */ diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp index 4ce2ce54..570005c5 100644 --- a/pus/Service1TelecommandVerification.cpp +++ b/pus/Service1TelecommandVerification.cpp @@ -1,12 +1,12 @@ -#include -#include +#include "Service1TelecommandVerification.h" +#include "servicepackets/Service1Packets.h" -#include -#include -#include -#include -#include -#include +#include "../ipc/QueueFactory.h" +#include "../tmtcservices/PusVerificationReport.h" +#include "/tmtcpacketTmPacketStored.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../tmtcservices/AcceptsTelemetryIF.h" +#include "../serviceinterface/ServiceInterfaceStream.h" Service1TelecommandVerification::Service1TelecommandVerification( diff --git a/pus/Service1TelecommandVerification.h b/pus/Service1TelecommandVerification.h index 1d4b6719..37562d1c 100644 --- a/pus/Service1TelecommandVerification.h +++ b/pus/Service1TelecommandVerification.h @@ -1,12 +1,12 @@ #ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ #define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ -#include -#include -#include -#include -#include -#include +#include "../objectmanager/SystemObject.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../tmtcservices/AcceptsVerifyMessageIF.h" +#include "../tmtcservices/PusVerificationReport.h" +#include "../ipc/MessageQueueIF.h" /** * @brief Verify TC acceptance, start, progress and execution. diff --git a/pus/Service2DeviceAccess.cpp b/pus/Service2DeviceAccess.cpp index 1d5f21eb..2093a617 100644 --- a/pus/Service2DeviceAccess.cpp +++ b/pus/Service2DeviceAccess.cpp @@ -1,167 +1,167 @@ -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId, - uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands, - uint16_t commandTimeoutSeconds): - CommandingServiceBase(objectId, apid, serviceId, - numberOfParallelCommands, commandTimeoutSeconds) {} - -Service2DeviceAccess::~Service2DeviceAccess() {} - - -ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) { - switch(static_cast(subservice)){ - case Subservice::RAW_COMMANDING: - case Subservice::TOGGLE_WIRETAPPING: - return HasReturnvaluesIF::RETURN_OK; - default: - sif::error << "Invalid Subservice" << std::endl; - return AcceptsTelecommandsIF::INVALID_SUBSERVICE; - } -} - -ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject( - uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, - MessageQueueId_t* id, object_id_t* objectId) { - if(tcDataLen < sizeof(object_id_t)) { - return CommandingServiceBase::INVALID_TC; - } - SerializeAdapter::deSerialize(objectId, &tcData, - &tcDataLen, SerializeIF::Endianness::BIG); - - ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId); - return result; -} - -ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t * messageQueueToSet, object_id_t *objectId) { - DeviceHandlerIF* possibleTarget = - objectManager->get(*objectId); - if(possibleTarget == nullptr) { - return CommandingServiceBase::INVALID_OBJECT; - } - *messageQueueToSet = possibleTarget->getCommandQueue(); - return HasReturnvaluesIF::RETURN_OK; -} - - -ReturnValue_t Service2DeviceAccess::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::RAW_COMMANDING: { - return prepareRawCommand(dynamic_cast(message), - tcData, tcDataLen); - } - break; - case Subservice::TOGGLE_WIRETAPPING: { - return prepareWiretappingCommand(dynamic_cast(message), - tcData, tcDataLen); - } - break; - default: - return HasReturnvaluesIF::RETURN_FAILED; - } -} - -ReturnValue_t Service2DeviceAccess::prepareRawCommand( - CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) { - RawCommand RawCommand(tcData,tcDataLen); - // store command into the Inter Process Communication Store - store_address_t storeAddress; - ReturnValue_t result = IPCStore->addData(&storeAddress, - RawCommand.getCommand(), RawCommand.getCommandSize()); - DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, - storeAddress); - return result; -} - -ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand( - CommandMessage *messageToSet, const uint8_t *tcData, - size_t tcDataLen) { - if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) { - return CommandingServiceBase::INVALID_TC; - } - WiretappingToggle command; - ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen, - SerializeIF::Endianness::BIG); - DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet, - command.getWiretappingMode()); - return result; -} - - -ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply, - Command_t previousCommand, uint32_t* state, - CommandMessage* optionalNextCommand, object_id_t objectId, - bool* isStep) { - switch(reply->getCommand()) { - case CommandMessage::REPLY_COMMAND_OK: - return HasReturnvaluesIF::RETURN_OK; - case CommandMessage::REPLY_REJECTED: - return reply->getReplyRejectedReason(); - default: - return CommandingServiceBase::INVALID_REPLY; - } -} - -// All device handlers set service 2 as default raw receiver for wiretapping -// so we have to handle those unrequested messages. -void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) { - switch(reply->getCommand()) { - case DeviceHandlerMessage::REPLY_RAW_COMMAND: - sendWiretappingTm(reply, - static_cast(Subservice::WIRETAPPING_RAW_TC)); - break; - case DeviceHandlerMessage::REPLY_RAW_REPLY: - sendWiretappingTm(reply, - static_cast(Subservice::RAW_REPLY)); - break; - default: - sif::error << "Unknown message in Service2DeviceAccess::" - "handleUnrequestedReply with command ID " << - reply->getCommand() << std::endl; - break; - } - //Must be reached by all cases to clear message - reply->clear(); -} - -void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply, - uint8_t subservice) { - // Raw Wiretapping - // Get Address of Data from Message - store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply); - const uint8_t* data = nullptr; - size_t size = 0; - ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size); - if(result != HasReturnvaluesIF::RETURN_OK){ - sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in " - "handleUnrequestedReply with failure ID "<< result - << std::endl; - return; - } - - // Init our dummy packet and correct endianness of object ID before - // sending it back. - WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), - data); - TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId); - sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast( - &TmPacket.objectId), sizeof(TmPacket.objectId)); -} - -MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { - return commandQueue->getId(); -} - +#include "Service2DeviceAccess.h" +#include "servicepackets/Service2Packets.h" + +#include "../devicehandlers/DeviceHandlerIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../devicehandlers/DeviceHandlerMessage.h" +#include "../serialize/EndianConverter.h" +#include "../action/ActionMessage.h" +#include "../serialize/SerializeAdapter.h" +#include "../serialize/SerialLinkedListAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" + +Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId, + uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands, + uint16_t commandTimeoutSeconds): + CommandingServiceBase(objectId, apid, serviceId, + numberOfParallelCommands, commandTimeoutSeconds) {} + +Service2DeviceAccess::~Service2DeviceAccess() {} + + +ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) { + switch(static_cast(subservice)){ + case Subservice::RAW_COMMANDING: + case Subservice::TOGGLE_WIRETAPPING: + return HasReturnvaluesIF::RETURN_OK; + default: + sif::error << "Invalid Subservice" << std::endl; + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + +ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject( + uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, + MessageQueueId_t* id, object_id_t* objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + + ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId); + return result; +} + +ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t * messageQueueToSet, object_id_t *objectId) { + DeviceHandlerIF* possibleTarget = + objectManager->get(*objectId); + if(possibleTarget == nullptr) { + return CommandingServiceBase::INVALID_OBJECT; + } + *messageQueueToSet = possibleTarget->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t Service2DeviceAccess::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::RAW_COMMANDING: { + return prepareRawCommand(dynamic_cast(message), + tcData, tcDataLen); + } + break; + case Subservice::TOGGLE_WIRETAPPING: { + return prepareWiretappingCommand(dynamic_cast(message), + tcData, tcDataLen); + } + break; + default: + return HasReturnvaluesIF::RETURN_FAILED; + } +} + +ReturnValue_t Service2DeviceAccess::prepareRawCommand( + CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) { + RawCommand RawCommand(tcData,tcDataLen); + // store command into the Inter Process Communication Store + store_address_t storeAddress; + ReturnValue_t result = IPCStore->addData(&storeAddress, + RawCommand.getCommand(), RawCommand.getCommandSize()); + DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, + storeAddress); + return result; +} + +ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand( + CommandMessage *messageToSet, const uint8_t *tcData, + size_t tcDataLen) { + if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) { + return CommandingServiceBase::INVALID_TC; + } + WiretappingToggle command; + ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen, + SerializeIF::Endianness::BIG); + DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet, + command.getWiretappingMode()); + return result; +} + + +ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t* state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool* isStep) { + switch(reply->getCommand()) { + case CommandMessage::REPLY_COMMAND_OK: + return HasReturnvaluesIF::RETURN_OK; + case CommandMessage::REPLY_REJECTED: + return reply->getReplyRejectedReason(); + default: + return CommandingServiceBase::INVALID_REPLY; + } +} + +// All device handlers set service 2 as default raw receiver for wiretapping +// so we have to handle those unrequested messages. +void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) { + switch(reply->getCommand()) { + case DeviceHandlerMessage::REPLY_RAW_COMMAND: + sendWiretappingTm(reply, + static_cast(Subservice::WIRETAPPING_RAW_TC)); + break; + case DeviceHandlerMessage::REPLY_RAW_REPLY: + sendWiretappingTm(reply, + static_cast(Subservice::RAW_REPLY)); + break; + default: + sif::error << "Unknown message in Service2DeviceAccess::" + "handleUnrequestedReply with command ID " << + reply->getCommand() << std::endl; + break; + } + //Must be reached by all cases to clear message + reply->clear(); +} + +void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply, + uint8_t subservice) { + // Raw Wiretapping + // Get Address of Data from Message + store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply); + const uint8_t* data = nullptr; + size_t size = 0; + ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size); + if(result != HasReturnvaluesIF::RETURN_OK){ + sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in " + "handleUnrequestedReply with failure ID "<< result + << std::endl; + return; + } + + // Init our dummy packet and correct endianness of object ID before + // sending it back. + WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), + data); + TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId); + sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast( + &TmPacket.objectId), sizeof(TmPacket.objectId)); +} + +MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { + return commandQueue->getId(); +} + diff --git a/pus/Service2DeviceAccess.h b/pus/Service2DeviceAccess.h index 1a0bede0..f6aa8b52 100644 --- a/pus/Service2DeviceAccess.h +++ b/pus/Service2DeviceAccess.h @@ -1,92 +1,92 @@ -#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ -#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ - -#include -#include -#include - -/** - * @brief Raw Commanding and Wiretapping of devices. - * @details - * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A - * Dissertation Baetz p. 115, 116, 165-167. - * - * This service provides the capability to communicate with devices in their - * native protocols with raw commands through the DeviceHandlerIF. - * - * This is a gateway service. It relays device commands to the software bus. - * This service is very closely tied to the CommandingServiceBase - * template class. - * - * There are 4 adaption points for component implementation through the - * CommandingServiceBase. - * - * This service employs custom subservices exclusively. This includes a - * wiretapping subservice to monitor all traffic between target devices and - * this service. - * - * - TC[2,128]: Raw Commanding - * - TC[2,129]: Toggle Wiretapping - * - TM[2,130]: Wiretapping Packet TM - * - TM[2,131]: Wiretapping Packet TC - * @ingroup pus_services - */ -class Service2DeviceAccess : public CommandingServiceBase, - public AcceptsDeviceResponsesIF -{ -public: - Service2DeviceAccess(object_id_t objectId, uint16_t apid, - uint8_t serviceId, uint8_t numberOfParallelCommands = 4, - uint16_t commandTimeoutSeconds = 60); - virtual ~Service2DeviceAccess(); - -protected: - //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. - ReturnValue_t isValidSubservice(uint8_t subservice) override; - ReturnValue_t getMessageQueueAndObject(uint8_t subservice, - const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, - object_id_t *objectId) override; - ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice, - const uint8_t *tcData, size_t tcDataLen, uint32_t *state, - object_id_t objectId) override; - ReturnValue_t handleReply(const CommandMessage* reply, - Command_t previousCommand, uint32_t *state, - CommandMessage* optionalNextCommand, object_id_t objectId, - bool *isStep) override; - - /** - * @brief Generates TM packets containing either the TC wiretapping - * packets or the TM wiretapping packets. - * Note that for service 2, all telemetry will be treated as an - * unrequested reply regardless of wiretapping mode. - * @param reply - */ - void handleUnrequestedReply(CommandMessage* reply) override; - - MessageQueueId_t getDeviceQueue() override; -private: - /** - * Generates TM packets for Wiretapping Service - * @param reply - * @param subservice - */ - void sendWiretappingTm(CommandMessage* reply,uint8_t subservice); - - ReturnValue_t checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* messageQueueToSet, object_id_t* objectId); - - ReturnValue_t prepareRawCommand(CommandMessage* messageToSet, - const uint8_t* tcData, size_t tcDataLen); - ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet, - const uint8_t* tcData, size_t tcDataLen); - - enum class Subservice { - RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol - TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication - RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device - WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler - }; -}; - - -#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */ +#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ +#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_ + +#include "../objectmanager/SystemObjectIF.h" +#include "../devicehandlers/AcceptsDeviceResponsesIF.h" +#include "../tmtcservices/CommandingServiceBase.h" + +/** + * @brief Raw Commanding and Wiretapping of devices. + * @details + * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A + * Dissertation Baetz p. 115, 116, 165-167. + * + * This service provides the capability to communicate with devices in their + * native protocols with raw commands through the DeviceHandlerIF. + * + * This is a gateway service. It relays device commands to the software bus. + * This service is very closely tied to the CommandingServiceBase + * template class. + * + * There are 4 adaption points for component implementation through the + * CommandingServiceBase. + * + * This service employs custom subservices exclusively. This includes a + * wiretapping subservice to monitor all traffic between target devices and + * this service. + * + * - TC[2,128]: Raw Commanding + * - TC[2,129]: Toggle Wiretapping + * - TM[2,130]: Wiretapping Packet TM + * - TM[2,131]: Wiretapping Packet TC + * @ingroup pus_services + */ +class Service2DeviceAccess : public CommandingServiceBase, + public AcceptsDeviceResponsesIF +{ +public: + Service2DeviceAccess(object_id_t objectId, uint16_t apid, + uint8_t serviceId, uint8_t numberOfParallelCommands = 4, + uint16_t commandTimeoutSeconds = 60); + virtual ~Service2DeviceAccess(); + +protected: + //! CommandingServiceBase (CSB) abstract functions. See CSB documentation. + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, uint32_t *state, + object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + + /** + * @brief Generates TM packets containing either the TC wiretapping + * packets or the TM wiretapping packets. + * Note that for service 2, all telemetry will be treated as an + * unrequested reply regardless of wiretapping mode. + * @param reply + */ + void handleUnrequestedReply(CommandMessage* reply) override; + + MessageQueueId_t getDeviceQueue() override; +private: + /** + * Generates TM packets for Wiretapping Service + * @param reply + * @param subservice + */ + void sendWiretappingTm(CommandMessage* reply,uint8_t subservice); + + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId); + + ReturnValue_t prepareRawCommand(CommandMessage* messageToSet, + const uint8_t* tcData, size_t tcDataLen); + ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet, + const uint8_t* tcData, size_t tcDataLen); + + enum class Subservice { + RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol + TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication + RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device + WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler + }; +}; + + +#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */ diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp index 1dfbe229..831f92c1 100644 --- a/pus/Service5EventReporting.cpp +++ b/pus/Service5EventReporting.cpp @@ -1,10 +1,10 @@ -#include -#include +#include "Service5EventReporting.h" +#include "servicepackets/Service5Packets.h" -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../events/EventManagerIF.h" +#include "../ipc/QueueFactory.h" +#include "/tmtcpacketTmPacketStored.h" Service5EventReporting::Service5EventReporting(object_id_t objectId, diff --git a/pus/Service5EventReporting.h b/pus/Service5EventReporting.h index 79b7c5e7..0b6ee9a8 100644 --- a/pus/Service5EventReporting.h +++ b/pus/Service5EventReporting.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_ #define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_ -#include -#include +#include "../tmtcservices/PusServiceBase.h" +#include "../events/EventMessage.h" /** * @brief Report on-board events like information or errors diff --git a/pus/Service8FunctionManagement.cpp b/pus/Service8FunctionManagement.cpp index 50102b04..2c2e590b 100644 --- a/pus/Service8FunctionManagement.cpp +++ b/pus/Service8FunctionManagement.cpp @@ -1,142 +1,142 @@ -#include -#include - -#include -#include -#include -#include -#include - -Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id, - uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands, - uint16_t commandTimeoutSeconds): - CommandingServiceBase(object_id, apid, serviceId, numParallelCommands, - commandTimeoutSeconds) {} - -Service8FunctionManagement::~Service8FunctionManagement() {} - - -ReturnValue_t Service8FunctionManagement::isValidSubservice( - uint8_t subservice) { - switch(static_cast(subservice)) { - case Subservice::DIRECT_COMMANDING: - return HasReturnvaluesIF::RETURN_OK; - default: - return AcceptsTelecommandsIF::INVALID_SUBSERVICE; - } -} - -ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject( - uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, - MessageQueueId_t* id, object_id_t* objectId) { - if(tcDataLen < sizeof(object_id_t)) { - return CommandingServiceBase::INVALID_TC; - } - SerializeAdapter::deSerialize(objectId, &tcData, - &tcDataLen, SerializeIF::Endianness::BIG); - - return checkInterfaceAndAcquireMessageQueue(id,objectId); -} - -ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { - // check HasActionIF property of target - HasActionsIF* possibleTarget = objectManager->get(*objectId); - if(possibleTarget == nullptr){ - return CommandingServiceBase::INVALID_OBJECT; - } - *messageQueueToSet = possibleTarget->getCommandQueue(); - return HasReturnvaluesIF::RETURN_OK; -} - - -ReturnValue_t Service8FunctionManagement::prepareCommand( - CommandMessage* message, uint8_t subservice, const uint8_t* tcData, - size_t tcDataLen, uint32_t* state, object_id_t objectId) { - return prepareDirectCommand(dynamic_cast(message), - tcData, tcDataLen); -} - -ReturnValue_t Service8FunctionManagement::prepareDirectCommand( - CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) { - if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) { - sif::debug << "Service8FunctionManagement::prepareDirectCommand:" - << " TC size smaller thant minimum size of direct command." - << std::endl; - return CommandingServiceBase::INVALID_TC; - } - - // Create direct command instance by extracting data from Telecommand - DirectCommand command(tcData, tcDataLen); - - // store additional parameters into the IPC Store - store_address_t parameterAddress; - ReturnValue_t result = IPCStore->addData(¶meterAddress, - command.getParameters(),command.getParametersSize()); - - // setCommand expects a Command Message, an Action ID and a store adress - // pointing to additional parameters - ActionMessage::setCommand(message,command.getActionId(),parameterAddress); - return result; -} - - -ReturnValue_t Service8FunctionManagement::handleReply( - const CommandMessage* reply, Command_t previousCommand, - uint32_t* state, CommandMessage* optionalNextCommand, - object_id_t objectId, bool* isStep) { - Command_t replyId = reply->getCommand(); - ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; - ActionId_t actionId = ActionMessage::getActionId(reply); - ReturnValue_t returnCode = ActionMessage::getReturnCode(reply); - - switch(replyId) { - case ActionMessage::COMPLETION_SUCCESS: { - DirectReply completionReply(objectId, actionId,returnCode); - result = CommandingServiceBase::EXECUTION_COMPLETE; - break; - } - case ActionMessage::STEP_SUCCESS: { - *isStep = true; - result = HasReturnvaluesIF::RETURN_OK; - break; - } - case ActionMessage::DATA_REPLY: { - result = handleDataReply(reply, objectId, actionId); - break; - } - case ActionMessage::STEP_FAILED: - *isStep = true; - /*No break, falls through*/ - case ActionMessage::COMPLETION_FAILED: - result = ActionMessage::getReturnCode(reply); - break; - default: - result = INVALID_REPLY; - } - return result; -} - -ReturnValue_t Service8FunctionManagement::handleDataReply( - const CommandMessage* reply, object_id_t objectId, - ActionId_t actionId) { - store_address_t storeId = ActionMessage::getStoreId(reply); - size_t size = 0; - const uint8_t * buffer = nullptr; - ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size); - if(result != RETURN_OK) { - sif::error << "Service 8: Could not retrieve data for data reply" - << std::endl; - return result; - } - DataReply dataReply(objectId, actionId, buffer, size); - result = sendTmPacket(static_cast( - Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply); - - auto deletionResult = IPCStore->deleteData(storeId); - if(deletionResult != HasReturnvaluesIF::RETURN_OK) { - sif::warning << "Service8FunctionManagement::handleReply: Deletion" - << " of data in pool failed." << std::endl; - } - return result; -} +#include "Service8FunctionManagement.h" +#include "servicepackets/Service8Packets.h" + +#include "../objectmanager/SystemObjectIF.h" +#include "../action/HasActionsIF.h" +#include "../devicehandlers/DeviceHandlerIF.h" +#include "../serialize/SerializeAdapter.h" +#include "../serviceinterface/ServiceInterfaceStream.h" + +Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id, + uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands, + uint16_t commandTimeoutSeconds): + CommandingServiceBase(object_id, apid, serviceId, numParallelCommands, + commandTimeoutSeconds) {} + +Service8FunctionManagement::~Service8FunctionManagement() {} + + +ReturnValue_t Service8FunctionManagement::isValidSubservice( + uint8_t subservice) { + switch(static_cast(subservice)) { + case Subservice::DIRECT_COMMANDING: + return HasReturnvaluesIF::RETURN_OK; + default: + return AcceptsTelecommandsIF::INVALID_SUBSERVICE; + } +} + +ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject( + uint8_t subservice, const uint8_t* tcData, size_t tcDataLen, + MessageQueueId_t* id, object_id_t* objectId) { + if(tcDataLen < sizeof(object_id_t)) { + return CommandingServiceBase::INVALID_TC; + } + SerializeAdapter::deSerialize(objectId, &tcData, + &tcDataLen, SerializeIF::Endianness::BIG); + + return checkInterfaceAndAcquireMessageQueue(id,objectId); +} + +ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId) { + // check HasActionIF property of target + HasActionsIF* possibleTarget = objectManager->get(*objectId); + if(possibleTarget == nullptr){ + return CommandingServiceBase::INVALID_OBJECT; + } + *messageQueueToSet = possibleTarget->getCommandQueue(); + return HasReturnvaluesIF::RETURN_OK; +} + + +ReturnValue_t Service8FunctionManagement::prepareCommand( + CommandMessage* message, uint8_t subservice, const uint8_t* tcData, + size_t tcDataLen, uint32_t* state, object_id_t objectId) { + return prepareDirectCommand(dynamic_cast(message), + tcData, tcDataLen); +} + +ReturnValue_t Service8FunctionManagement::prepareDirectCommand( + CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) { + if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) { + sif::debug << "Service8FunctionManagement::prepareDirectCommand:" + << " TC size smaller thant minimum size of direct command." + << std::endl; + return CommandingServiceBase::INVALID_TC; + } + + // Create direct command instance by extracting data from Telecommand + DirectCommand command(tcData, tcDataLen); + + // store additional parameters into the IPC Store + store_address_t parameterAddress; + ReturnValue_t result = IPCStore->addData(¶meterAddress, + command.getParameters(),command.getParametersSize()); + + // setCommand expects a Command Message, an Action ID and a store adress + // pointing to additional parameters + ActionMessage::setCommand(message,command.getActionId(),parameterAddress); + return result; +} + + +ReturnValue_t Service8FunctionManagement::handleReply( + const CommandMessage* reply, Command_t previousCommand, + uint32_t* state, CommandMessage* optionalNextCommand, + object_id_t objectId, bool* isStep) { + Command_t replyId = reply->getCommand(); + ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED; + ActionId_t actionId = ActionMessage::getActionId(reply); + ReturnValue_t returnCode = ActionMessage::getReturnCode(reply); + + switch(replyId) { + case ActionMessage::COMPLETION_SUCCESS: { + DirectReply completionReply(objectId, actionId,returnCode); + result = CommandingServiceBase::EXECUTION_COMPLETE; + break; + } + case ActionMessage::STEP_SUCCESS: { + *isStep = true; + result = HasReturnvaluesIF::RETURN_OK; + break; + } + case ActionMessage::DATA_REPLY: { + result = handleDataReply(reply, objectId, actionId); + break; + } + case ActionMessage::STEP_FAILED: + *isStep = true; + /*No break, falls through*/ + case ActionMessage::COMPLETION_FAILED: + result = ActionMessage::getReturnCode(reply); + break; + default: + result = INVALID_REPLY; + } + return result; +} + +ReturnValue_t Service8FunctionManagement::handleDataReply( + const CommandMessage* reply, object_id_t objectId, + ActionId_t actionId) { + store_address_t storeId = ActionMessage::getStoreId(reply); + size_t size = 0; + const uint8_t * buffer = nullptr; + ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size); + if(result != RETURN_OK) { + sif::error << "Service 8: Could not retrieve data for data reply" + << std::endl; + return result; + } + DataReply dataReply(objectId, actionId, buffer, size); + result = sendTmPacket(static_cast( + Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply); + + auto deletionResult = IPCStore->deleteData(storeId); + if(deletionResult != HasReturnvaluesIF::RETURN_OK) { + sif::warning << "Service8FunctionManagement::handleReply: Deletion" + << " of data in pool failed." << std::endl; + } + return result; +} diff --git a/pus/Service8FunctionManagement.h b/pus/Service8FunctionManagement.h index e2c7a84f..b5ebcda8 100644 --- a/pus/Service8FunctionManagement.h +++ b/pus/Service8FunctionManagement.h @@ -1,67 +1,67 @@ -#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ -#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ - -#include -#include - -/** - * @brief Functional commanding. - * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451 - * Dissertation Baetz p. 115, 116, 165-167 - * - * This service provides the capability to perform functions of an - * application process and provides high-level commanding as opposed to the - * Raw Access provided by Service 2. Examples for these functions can include - * control and operation of payload or the AOCS subsystem. - * This service will be the primary means to control the spacecraft as it is - * considered safer than the Raw Access provided - * by Service 2 and is generally sufficient for most tasks. - * - * This is a gateway service. It relays device commands using the software bus. - * This service is very closely tied to the Commanding Service Base template - * class. There is constant interaction between this Service Base und a - * subclass like this service. - * - * Service Capability: - * - TC[8,128]: Direct Commanding - * - TM[8,130]: Direct Commanding Data Reply - * - * @ingroup pus_services - */ -class Service8FunctionManagement : public CommandingServiceBase -{ -public: - Service8FunctionManagement(object_id_t objectId, uint16_t apid, - uint8_t serviceId, uint8_t numParallelCommands = 4, - uint16_t commandTimeoutSeconds = 60); - virtual ~Service8FunctionManagement(); - -protected: - /* CSB abstract functions implementation . See CSB documentation. */ - ReturnValue_t isValidSubservice(uint8_t subservice) override; - ReturnValue_t getMessageQueueAndObject(uint8_t subservice, - const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, - object_id_t *objectId) override; - ReturnValue_t prepareCommand(CommandMessage* message, - uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, - uint32_t *state, object_id_t objectId) override; - ReturnValue_t handleReply(const CommandMessage* reply, - Command_t previousCommand, uint32_t *state, - CommandMessage* optionalNextCommand, object_id_t objectId, - bool *isStep) override; - -private: - enum class Subservice { - DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding - DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply - }; - - ReturnValue_t checkInterfaceAndAcquireMessageQueue( - MessageQueueId_t* messageQueueToSet, object_id_t* objectId); - ReturnValue_t prepareDirectCommand(CommandMessage* message, - const uint8_t* tcData, size_t tcDataLen); - ReturnValue_t handleDataReply(const CommandMessage* reply, - object_id_t objectId, ActionId_t actionId); -}; - -#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */ +#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ +#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ + +#include "../action/ActionMessage.h" +#include "../tmtcservices/CommandingServiceBase.h" + +/** + * @brief Functional commanding. + * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451 + * Dissertation Baetz p. 115, 116, 165-167 + * + * This service provides the capability to perform functions of an + * application process and provides high-level commanding as opposed to the + * Raw Access provided by Service 2. Examples for these functions can include + * control and operation of payload or the AOCS subsystem. + * This service will be the primary means to control the spacecraft as it is + * considered safer than the Raw Access provided + * by Service 2 and is generally sufficient for most tasks. + * + * This is a gateway service. It relays device commands using the software bus. + * This service is very closely tied to the Commanding Service Base template + * class. There is constant interaction between this Service Base und a + * subclass like this service. + * + * Service Capability: + * - TC[8,128]: Direct Commanding + * - TM[8,130]: Direct Commanding Data Reply + * + * @ingroup pus_services + */ +class Service8FunctionManagement : public CommandingServiceBase +{ +public: + Service8FunctionManagement(object_id_t objectId, uint16_t apid, + uint8_t serviceId, uint8_t numParallelCommands = 4, + uint16_t commandTimeoutSeconds = 60); + virtual ~Service8FunctionManagement(); + +protected: + /* CSB abstract functions implementation . See CSB documentation. */ + ReturnValue_t isValidSubservice(uint8_t subservice) override; + ReturnValue_t getMessageQueueAndObject(uint8_t subservice, + const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id, + object_id_t *objectId) override; + ReturnValue_t prepareCommand(CommandMessage* message, + uint8_t subservice, const uint8_t *tcData, size_t tcDataLen, + uint32_t *state, object_id_t objectId) override; + ReturnValue_t handleReply(const CommandMessage* reply, + Command_t previousCommand, uint32_t *state, + CommandMessage* optionalNextCommand, object_id_t objectId, + bool *isStep) override; + +private: + enum class Subservice { + DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding + DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply + }; + + ReturnValue_t checkInterfaceAndAcquireMessageQueue( + MessageQueueId_t* messageQueueToSet, object_id_t* objectId); + ReturnValue_t prepareDirectCommand(CommandMessage* message, + const uint8_t* tcData, size_t tcDataLen); + ReturnValue_t handleDataReply(const CommandMessage* reply, + object_id_t objectId, ActionId_t actionId); +}; + +#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */ diff --git a/pus/servicepackets/Service1Packets.h b/pus/servicepackets/Service1Packets.h index b01942c6..dbd31028 100644 --- a/pus/servicepackets/Service1Packets.h +++ b/pus/servicepackets/Service1Packets.h @@ -8,8 +8,8 @@ #ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ #define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ -#include -#include +#include "../../serialize/SerializeAdapter.h" +#include "../../tmtcservices/VerificationCodes.h" /** * @brief FailureReport class to serialize a failure report diff --git a/pus/servicepackets/Service200Packets.h b/pus/servicepackets/Service200Packets.h index 1b5bf236..efcf65fc 100644 --- a/pus/servicepackets/Service200Packets.h +++ b/pus/servicepackets/Service200Packets.h @@ -1,63 +1,63 @@ -#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ -#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ - -#include -#include -#include - -/** - * @brief Subservice 1, 2, 3, 4, 5 - * @ingroup spacepackets - */ -class ModePacket : public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6 -public: - - ModePacket() { - setLinks(); - } - - ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) : - objectId(objectId), mode(mode), submode(submode) { - setLinks(); - } - - Mode_t getMode() { - return mode.entry; - } - - Submode_t getSubmode() { - return submode.entry; - } - - // Forbid copying, pointers are used. - ModePacket(const ModePacket&) = delete; - ModePacket& operator=(const ModePacket&) = delete; -private: - - void setLinks() { - setStart(&objectId); - objectId.setNext(&mode); - mode.setNext(&submode); - } - SerializeElement objectId; //!< [EXPORT] : [COMMENT] Target or source object - SerializeElement mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW - SerializeElement submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible -}; - -/** - * @brief Subservice 7 - * @ingroup spacepackets - */ -class CantReachModePacket: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 7 -public: - CantReachModePacket(object_id_t objectId, ReturnValue_t reason): - objectId(objectId), reason(reason) { - setStart(&this->objectId); - this->objectId.setNext(&this->reason); - } - - SerializeElement objectId; //!< [EXPORT] : [COMMENT] Reply source object - SerializeElement reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached -}; - -#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */ +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ + +#include "../../serialize/SerialLinkedListAdapter.h" +#include "../../modes/ModeMessage.h" +#include "../../serialize/SerializeIF.h" + +/** + * @brief Subservice 1, 2, 3, 4, 5 + * @ingroup spacepackets + */ +class ModePacket : public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6 +public: + + ModePacket() { + setLinks(); + } + + ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) : + objectId(objectId), mode(mode), submode(submode) { + setLinks(); + } + + Mode_t getMode() { + return mode.entry; + } + + Submode_t getSubmode() { + return submode.entry; + } + + // Forbid copying, pointers are used. + ModePacket(const ModePacket&) = delete; + ModePacket& operator=(const ModePacket&) = delete; +private: + + void setLinks() { + setStart(&objectId); + objectId.setNext(&mode); + mode.setNext(&submode); + } + SerializeElement objectId; //!< [EXPORT] : [COMMENT] Target or source object + SerializeElement mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW + SerializeElement submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible +}; + +/** + * @brief Subservice 7 + * @ingroup spacepackets + */ +class CantReachModePacket: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 7 +public: + CantReachModePacket(object_id_t objectId, ReturnValue_t reason): + objectId(objectId), reason(reason) { + setStart(&this->objectId); + this->objectId.setNext(&this->reason); + } + + SerializeElement objectId; //!< [EXPORT] : [COMMENT] Reply source object + SerializeElement reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */ diff --git a/pus/servicepackets/Service2Packets.h b/pus/servicepackets/Service2Packets.h index f292611e..d4f3fb17 100644 --- a/pus/servicepackets/Service2Packets.h +++ b/pus/servicepackets/Service2Packets.h @@ -1,76 +1,76 @@ -#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ -#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ - -#include -#include -#include -#include - -/** - * @brief Subservice 128 - * @ingroup spacepackets - */ -class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128 -public: - RawCommand(const uint8_t* buffer, size_t size) { - // Deserialize Adapter to get correct endianness - SerializeAdapter::deSerialize(&objectId, &buffer, &size, - SerializeIF::Endianness::BIG); - commandBuffer = buffer; - // size is decremented by AutoSerializeAdapter, - // remaining size is data size - dataSize = size; - } - object_id_t getObjectId() const { - return objectId; - } - - const uint8_t* getCommand() { - return commandBuffer; - } - - size_t getCommandSize() const { - return dataSize; - } -private: - object_id_t objectId = 0; - const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes - size_t dataSize = 0; //!< [EXPORT] : [IGNORE] -}; - - -/** - * @brief Subservice 129: Command packet to set wiretapping mode - * @ingroup spacepackets - */ -class WiretappingToggle: public SerialLinkedListAdapter{ //!< [EXPORT] : [SUBSERVICE] 129 -public: - static const size_t WIRETAPPING_COMMAND_SIZE = 5; - WiretappingToggle(){ - setStart(&objectId); - objectId.setNext(&wiretappingMode); - } - - uint8_t getWiretappingMode() const { - return wiretappingMode.entry; - } -private: - SerializeElement objectId; - SerializeElement wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW -}; - - -/** - * @brief Subservices 130 and 131: TM packets - * @ingroup spacepackets - */ -class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131 -public: - object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object - const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size - WiretappingPacket(object_id_t objectId, const uint8_t* buffer): - objectId(objectId), data(buffer) { - } -}; - -#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */ +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ + +#include "../../action/ActionMessage.h" +#include "../../objectmanager/SystemObjectIF.h" +#include "../../serialize/SerialLinkedListAdapter.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" + +/** + * @brief Subservice 128 + * @ingroup spacepackets + */ +class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128 +public: + RawCommand(const uint8_t* buffer, size_t size) { + // Deserialize Adapter to get correct endianness + SerializeAdapter::deSerialize(&objectId, &buffer, &size, + SerializeIF::Endianness::BIG); + commandBuffer = buffer; + // size is decremented by AutoSerializeAdapter, + // remaining size is data size + dataSize = size; + } + object_id_t getObjectId() const { + return objectId; + } + + const uint8_t* getCommand() { + return commandBuffer; + } + + size_t getCommandSize() const { + return dataSize; + } +private: + object_id_t objectId = 0; + const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes + size_t dataSize = 0; //!< [EXPORT] : [IGNORE] +}; + + +/** + * @brief Subservice 129: Command packet to set wiretapping mode + * @ingroup spacepackets + */ +class WiretappingToggle: public SerialLinkedListAdapter{ //!< [EXPORT] : [SUBSERVICE] 129 +public: + static const size_t WIRETAPPING_COMMAND_SIZE = 5; + WiretappingToggle(){ + setStart(&objectId); + objectId.setNext(&wiretappingMode); + } + + uint8_t getWiretappingMode() const { + return wiretappingMode.entry; + } +private: + SerializeElement objectId; + SerializeElement wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW +}; + + +/** + * @brief Subservices 130 and 131: TM packets + * @ingroup spacepackets + */ +class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131 +public: + object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object + const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size + WiretappingPacket(object_id_t objectId, const uint8_t* buffer): + objectId(objectId), data(buffer) { + } +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */ diff --git a/pus/servicepackets/Service5Packets.h b/pus/servicepackets/Service5Packets.h index 14219c93..9655608a 100644 --- a/pus/servicepackets/Service5Packets.h +++ b/pus/servicepackets/Service5Packets.h @@ -1,8 +1,8 @@ #ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ #define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ -#include -#include +#include "../../serialize/SerializeAdapter.h" +#include "../../tmtcservices/VerificationCodes.h" /** diff --git a/pus/servicepackets/Service8Packets.h b/pus/servicepackets/Service8Packets.h index 8ea0d108..14f8b6e6 100644 --- a/pus/servicepackets/Service8Packets.h +++ b/pus/servicepackets/Service8Packets.h @@ -1,121 +1,121 @@ -#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ -#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ - -#include -#include -#include -#include -#include -#include - - -/** - * @brief Subservice 128 - * @ingroup spacepackets - */ -class DirectCommand: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 128 -public: - - DirectCommand(const uint8_t* tcData, size_t size) { - SerializeAdapter::deSerialize(&objectId, &tcData, &size, - SerializeIF::Endianness::BIG); - SerializeAdapter::deSerialize(&actionId, &tcData, &size, - SerializeIF::Endianness::BIG); - parameterBuffer = tcData; - parametersSize = size; - } - - ActionId_t getActionId() const { - return actionId; - } - - object_id_t getObjectId() const { - return objectId; - } - - const uint8_t* getParameters() { - return parameterBuffer; - } - - uint32_t getParametersSize() const { - return parametersSize; - } - -private: - DirectCommand(const DirectCommand &command); - object_id_t objectId; - ActionId_t actionId; - uint32_t parametersSize; //!< [EXPORT] : [IGNORE] - const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes - -}; - - -/** - * @brief Subservice 130 - * Data reply (subservice 130) consists of - * 1. Target Object ID - * 2. Action ID - * 3. Data - * @ingroup spacepackets - */ -class DataReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 130 -public: - typedef uint16_t typeOfMaxDataSize; - static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); - DataReply(object_id_t objectId_, ActionId_t actionId_, - const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0): - objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){ - setLinks(); - } - -private: - DataReply(const DataReply &reply); - void setLinks() { - setStart(&objectId); - objectId.setNext(&actionId); - actionId.setNext(&replyData); - } - SerializeElement objectId; - SerializeElement actionId; - SerializeElement> replyData; -}; - - -/** - * @brief Subservice 132 - * @details - * Not used yet. Telecommand Verification takes care of this. - * @ingroup spacepackets - */ -class DirectReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 132 -public: - typedef uint16_t typeOfMaxDataSize; - static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); - - DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_, - bool isStep_ = false, uint8_t step_ = 0): - isStep(isStep_), objectId(objectId_), actionId(actionId_), - returnCode(returnCode_),step(step_) { - setLinks(); - } -private: - - void setLinks() { - setStart(&objectId); - objectId.setNext(&actionId); - actionId.setNext(&returnCode); - if(isStep) { - returnCode.setNext(&step); - } - } - - bool isStep; //!< [EXPORT] : [IGNORE] - SerializeElement objectId; //!< [EXPORT] : [IGNORE] - SerializeElement actionId; //!< [EXPORT] : [IGNORE] - SerializeElement returnCode; //!< [EXPORT] : [IGNORE] - SerializeElement step; //!< [EXPORT] : [OPTIONAL] [IGNORE] - -}; - -#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */ +#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ +#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ + +#include "../../action/ActionMessage.h" +#include "../../objectmanager/SystemObjectIF.h" +#include "../../serialize/SerialBufferAdapter.h" +#include "../../serialize/SerializeElement.h" +#include "../../serialize/SerialLinkedListAdapter.h" +#include "../../serialize/SerialFixedArrayListAdapter.h" + + +/** + * @brief Subservice 128 + * @ingroup spacepackets + */ +class DirectCommand: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 128 +public: + + DirectCommand(const uint8_t* tcData, size_t size) { + SerializeAdapter::deSerialize(&objectId, &tcData, &size, + SerializeIF::Endianness::BIG); + SerializeAdapter::deSerialize(&actionId, &tcData, &size, + SerializeIF::Endianness::BIG); + parameterBuffer = tcData; + parametersSize = size; + } + + ActionId_t getActionId() const { + return actionId; + } + + object_id_t getObjectId() const { + return objectId; + } + + const uint8_t* getParameters() { + return parameterBuffer; + } + + uint32_t getParametersSize() const { + return parametersSize; + } + +private: + DirectCommand(const DirectCommand &command); + object_id_t objectId; + ActionId_t actionId; + uint32_t parametersSize; //!< [EXPORT] : [IGNORE] + const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes + +}; + + +/** + * @brief Subservice 130 + * Data reply (subservice 130) consists of + * 1. Target Object ID + * 2. Action ID + * 3. Data + * @ingroup spacepackets + */ +class DataReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 130 +public: + typedef uint16_t typeOfMaxDataSize; + static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); + DataReply(object_id_t objectId_, ActionId_t actionId_, + const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0): + objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){ + setLinks(); + } + +private: + DataReply(const DataReply &reply); + void setLinks() { + setStart(&objectId); + objectId.setNext(&actionId); + actionId.setNext(&replyData); + } + SerializeElement objectId; + SerializeElement actionId; + SerializeElement> replyData; +}; + + +/** + * @brief Subservice 132 + * @details + * Not used yet. Telecommand Verification takes care of this. + * @ingroup spacepackets + */ +class DirectReply: public SerialLinkedListAdapter { //!< [EXPORT] : [SUBSERVICE] 132 +public: + typedef uint16_t typeOfMaxDataSize; + static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize); + + DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_, + bool isStep_ = false, uint8_t step_ = 0): + isStep(isStep_), objectId(objectId_), actionId(actionId_), + returnCode(returnCode_),step(step_) { + setLinks(); + } +private: + + void setLinks() { + setStart(&objectId); + objectId.setNext(&actionId); + actionId.setNext(&returnCode); + if(isStep) { + returnCode.setNext(&step); + } + } + + bool isStep; //!< [EXPORT] : [IGNORE] + SerializeElement objectId; //!< [EXPORT] : [IGNORE] + SerializeElement actionId; //!< [EXPORT] : [IGNORE] + SerializeElement returnCode; //!< [EXPORT] : [IGNORE] + SerializeElement step; //!< [EXPORT] : [OPTIONAL] [IGNORE] + +}; + +#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */ diff --git a/returnvalues/HasReturnvaluesIF.h b/returnvalues/HasReturnvaluesIF.h index d231f4ee..5fef91dd 100644 --- a/returnvalues/HasReturnvaluesIF.h +++ b/returnvalues/HasReturnvaluesIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ #define FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ -#include +#include "FwClassIds.h" #include #include diff --git a/rmap/RMAP.cpp b/rmap/RMAP.cpp index 4c95f6c9..4ab8b17b 100644 --- a/rmap/RMAP.cpp +++ b/rmap/RMAP.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "../devicehandlers/DeviceCommunicationIF.h" +#include "rmapStructs.h" +#include "RMAP.h" +#include "RMAPChannelIF.h" #include ReturnValue_t RMAP::reset(RMAPCookie* cookie) { diff --git a/rmap/RMAP.h b/rmap/RMAP.h index 195574f8..d14320cb 100644 --- a/rmap/RMAP.h +++ b/rmap/RMAP.h @@ -1,8 +1,8 @@ #ifndef RMAPpp_H_ #define RMAPpp_H_ -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "RMAPCookie.h" //SHOULDTODO: clean up includes for RMAP, should be enough to include RMAP.h but right now it's quite chaotic... diff --git a/rmap/RMAPChannelIF.h b/rmap/RMAPChannelIF.h index 6549c8ef..dac4a722 100644 --- a/rmap/RMAPChannelIF.h +++ b/rmap/RMAPChannelIF.h @@ -1,8 +1,8 @@ #ifndef RMAPCHANNELIF_H_ #define RMAPCHANNELIF_H_ -#include -#include +#include "RMAPCookie.h" +#include "../returnvalues/HasReturnvaluesIF.h" class RMAPChannelIF { public: diff --git a/rmap/RMAPCookie.cpp b/rmap/RMAPCookie.cpp index 5bf2ba9f..597f066c 100644 --- a/rmap/RMAPCookie.cpp +++ b/rmap/RMAPCookie.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "RMAPChannelIF.h" +#include "RMAPCookie.h" #include diff --git a/rmap/RMAPCookie.h b/rmap/RMAPCookie.h index 4890c516..4c6081bd 100644 --- a/rmap/RMAPCookie.h +++ b/rmap/RMAPCookie.h @@ -1,8 +1,8 @@ #ifndef RMAPCOOKIE_H_ #define RMAPCOOKIE_H_ -#include -#include +#include "../devicehandlers/CookieIF.h" +#include "rmapStructs.h" class RMAPChannelIF; diff --git a/rmap/RmapDeviceCommunicationIF.cpp b/rmap/RmapDeviceCommunicationIF.cpp index 674d050d..db4a75b5 100644 --- a/rmap/RmapDeviceCommunicationIF.cpp +++ b/rmap/RmapDeviceCommunicationIF.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "RmapDeviceCommunicationIF.h" +#include "RMAP.h" //TODO Cast here are all potential bugs RmapDeviceCommunicationIF::~RmapDeviceCommunicationIF() { diff --git a/rmap/RmapDeviceCommunicationIF.h b/rmap/RmapDeviceCommunicationIF.h index 9d756ea2..dacc720b 100644 --- a/rmap/RmapDeviceCommunicationIF.h +++ b/rmap/RmapDeviceCommunicationIF.h @@ -1,7 +1,7 @@ #ifndef MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ #define MISSION_RMAP_RMAPDEVICECOMMUNICATIONINTERFACE_H_ -#include +#include "../devicehandlers/DeviceCommunicationIF.h" /** * @brief This class is a implementation of a DeviceCommunicationIF for RMAP calls. It expects RMAPCookies or a derived class of RMAPCookies diff --git a/serialize/EndianConverter.h b/serialize/EndianConverter.h index cd5d5497..7461576d 100644 --- a/serialize/EndianConverter.h +++ b/serialize/EndianConverter.h @@ -1,7 +1,7 @@ #ifndef ENDIANSWAPPER_H_ #define ENDIANSWAPPER_H_ -#include +#include "../osal/Endiness.h" #include #include diff --git a/serialize/SerialArrayListAdapter.h b/serialize/SerialArrayListAdapter.h index 21c6951d..7576505a 100644 --- a/serialize/SerialArrayListAdapter.h +++ b/serialize/SerialArrayListAdapter.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_ #define FRAMEWORK_SERIALIZE_SERIALARRAYLISTADAPTER_H_ -#include -#include +#include "../container/ArrayList.h" +#include "SerializeIF.h" #include /** diff --git a/serialize/SerialBufferAdapter.cpp b/serialize/SerialBufferAdapter.cpp index d4d8d1c7..5dd01f54 100644 --- a/serialize/SerialBufferAdapter.cpp +++ b/serialize/SerialBufferAdapter.cpp @@ -1,4 +1,4 @@ -#include +#include "SerialBufferAdapter.h" #include diff --git a/serialize/SerialBufferAdapter.h b/serialize/SerialBufferAdapter.h index 78d42b80..c27a5424 100644 --- a/serialize/SerialBufferAdapter.h +++ b/serialize/SerialBufferAdapter.h @@ -1,8 +1,8 @@ #ifndef SERIALBUFFERADAPTER_H_ #define SERIALBUFFERADAPTER_H_ -#include -#include +#include "SerializeIF.h" +#include "SerializeAdapter.h" /** * \ingroup serialize diff --git a/serialize/SerialFixedArrayListAdapter.h b/serialize/SerialFixedArrayListAdapter.h index a2e683bf..38e0d438 100644 --- a/serialize/SerialFixedArrayListAdapter.h +++ b/serialize/SerialFixedArrayListAdapter.h @@ -1,8 +1,8 @@ #ifndef SERIALFIXEDARRAYLISTADAPTER_H_ #define SERIALFIXEDARRAYLISTADAPTER_H_ -#include -#include +#include "../container/FixedArrayList.h" +#include "SerialArrayListAdapter.h" /** * \ingroup serialize diff --git a/serialize/SerialLinkedListAdapter.h b/serialize/SerialLinkedListAdapter.h index 7b10e331..5de8c242 100644 --- a/serialize/SerialLinkedListAdapter.h +++ b/serialize/SerialLinkedListAdapter.h @@ -7,10 +7,10 @@ #ifndef SERIALLINKEDLISTADAPTER_H_ #define SERIALLINKEDLISTADAPTER_H_ -#include -#include -#include -#include +#include "../container/SinglyLinkedList.h" +#include "SerializeAdapter.h" +#include "SerializeElement.h" +#include "SerializeIF.h" //This is where we need the SerializeAdapter! /** diff --git a/serialize/SerializeAdapter.h b/serialize/SerializeAdapter.h index ec727515..af5ec116 100644 --- a/serialize/SerializeAdapter.h +++ b/serialize/SerializeAdapter.h @@ -1,10 +1,10 @@ #ifndef SERIALIZEADAPTER_H_ #define SERIALIZEADAPTER_H_ -#include -#include -#include -#include +#include "../container/IsDerivedFrom.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "EndianConverter.h" +#include "SerializeIF.h" #include /** diff --git a/serialize/SerializeElement.h b/serialize/SerializeElement.h index 3941e9fb..ffedeff9 100644 --- a/serialize/SerializeElement.h +++ b/serialize/SerializeElement.h @@ -1,8 +1,8 @@ #ifndef SERIALIZEELEMENT_H_ #define SERIALIZEELEMENT_H_ -#include -#include +#include "../container/SinglyLinkedList.h" +#include "SerializeAdapter.h" #include /** diff --git a/serialize/SerializeIF.h b/serialize/SerializeIF.h index 14244a7a..9ed52d29 100644 --- a/serialize/SerializeIF.h +++ b/serialize/SerializeIF.h @@ -1,7 +1,7 @@ #ifndef SERIALIZEIF_H_ #define SERIALIZEIF_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" #include /** diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp index 8c510eac..68fc4dec 100644 --- a/serviceinterface/ServiceInterfaceBuffer.cpp +++ b/serviceinterface/ServiceInterfaceBuffer.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../timemanager/Clock.h" +#include "ServiceInterfaceBuffer.h" #include #include @@ -127,7 +127,7 @@ std::string* ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) { #ifdef UT699 -#include +#include "../osal/rtems/Interrupt.h" ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) { diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h index 7a2ce2ee..c5d5b258 100644 --- a/serviceinterface/ServiceInterfaceBuffer.h +++ b/serviceinterface/ServiceInterfaceBuffer.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" #include #include #include diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp index 31bc7c73..5b7b9f00 100644 --- a/serviceinterface/ServiceInterfaceStream.cpp +++ b/serviceinterface/ServiceInterfaceStream.cpp @@ -1,4 +1,4 @@ -#include +#include "ServiceInterfaceStream.h" ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage, bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) : diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h index dc111459..76fa1bf2 100644 --- a/serviceinterface/ServiceInterfaceStream.h +++ b/serviceinterface/ServiceInterfaceStream.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ -#include +#include "ServiceInterfaceBuffer.h" #include #include diff --git a/storagemanager/LocalPool.h b/storagemanager/LocalPool.h index 3ddcc491..ad3deee1 100644 --- a/storagemanager/LocalPool.h +++ b/storagemanager/LocalPool.h @@ -7,11 +7,11 @@ #ifndef FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ #define FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ -#include -#include -#include -#include -#include +#include "../objectmanager/SystemObject.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "StorageManagerIF.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../internalError/InternalErrorReporterIF.h" #include /** @@ -178,6 +178,6 @@ private: ReturnValue_t findEmpty(uint16_t pool_index, uint16_t* element); }; -#include +#include "LocalPool.tpp" #endif /* FRAMEWORK_STORAGEMANAGER_LOCALPOOL_H_ */ diff --git a/storagemanager/PoolManager.h b/storagemanager/PoolManager.h index 67534cc5..0b101d66 100644 --- a/storagemanager/PoolManager.h +++ b/storagemanager/PoolManager.h @@ -2,8 +2,8 @@ #define POOLMANAGER_H_ -#include -#include +#include "LocalPool.h" +#include "../ipc/MutexHelper.h" /** * @brief The PoolManager class provides an intermediate data storage with diff --git a/storagemanager/StorageManagerIF.h b/storagemanager/StorageManagerIF.h index 101e0dcd..7c194d72 100644 --- a/storagemanager/StorageManagerIF.h +++ b/storagemanager/StorageManagerIF.h @@ -1,8 +1,8 @@ #ifndef STORAGEMANAGERIF_H_H #define STORAGEMANAGERIF_H_H -#include -#include +#include "../events/Event.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include /** diff --git a/subsystem/Subsystem.cpp b/subsystem/Subsystem.cpp index fcf2e189..ff3ef634 100644 --- a/subsystem/Subsystem.cpp +++ b/subsystem/Subsystem.cpp @@ -1,10 +1,10 @@ -#include -#include -#include -#include -#include -#include -#include +#include "../health/HealthMessage.h" +#include "../objectmanager/ObjectManagerIF.h" +#include "../serialize/SerialArrayListAdapter.h" +#include "../serialize/SerialFixedArrayListAdapter.h" +#include "../serialize/SerializeElement.h" +#include "../serialize/SerialLinkedListAdapter.h" +#include "Subsystem.h" #include Subsystem::Subsystem(object_id_t setObjectId, object_id_t parent, diff --git a/subsystem/Subsystem.h b/subsystem/Subsystem.h index ca1020b9..a40b8028 100644 --- a/subsystem/Subsystem.h +++ b/subsystem/Subsystem.h @@ -1,13 +1,13 @@ #ifndef SUBSYSTEM_H_ #define SUBSYSTEM_H_ -#include -#include -#include -#include -#include -#include -#include +#include "../container/FixedArrayList.h" +#include "../container/FixedMap.h" +#include "../container/HybridIterator.h" +#include "../container/SinglyLinkedList.h" +#include "../serialize/SerialArrayListAdapter.h" +#include "modes/ModeDefinitions.h" +#include "SubsystemBase.h" class Subsystem: public SubsystemBase, public HasModeSequenceIF { public: diff --git a/subsystem/SubsystemBase.cpp b/subsystem/SubsystemBase.cpp index cceb2d41..56ae1062 100644 --- a/subsystem/SubsystemBase.cpp +++ b/subsystem/SubsystemBase.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "SubsystemBase.h" +#include "../ipc/QueueFactory.h" SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t initialMode, uint16_t commandQueueDepth) : diff --git a/subsystem/SubsystemBase.h b/subsystem/SubsystemBase.h index 3294c46d..61a7eaef 100644 --- a/subsystem/SubsystemBase.h +++ b/subsystem/SubsystemBase.h @@ -1,15 +1,15 @@ #ifndef SUBSYSTEMBASE_H_ #define SUBSYSTEMBASE_H_ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "../container/HybridIterator.h" +#include "../health/HasHealthIF.h" +#include "../health/HealthHelper.h" +#include "../modes/HasModesIF.h" +#include "../objectmanager/SystemObject.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "modes/HasModeSequenceIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../ipc/MessageQueueIF.h" #include class SubsystemBase: public SystemObject, diff --git a/subsystem/modes/HasModeSequenceIF.h b/subsystem/modes/HasModeSequenceIF.h index e03de410..70b1667e 100644 --- a/subsystem/modes/HasModeSequenceIF.h +++ b/subsystem/modes/HasModeSequenceIF.h @@ -1,9 +1,9 @@ #ifndef HASMODESEQUENCEIF_H_ #define HASMODESEQUENCEIF_H_ -#include -#include -#include +#include "ModeDefinitions.h" +#include "ModeSequenceMessage.h" +#include "ModeStoreIF.h" class HasModeSequenceIF { diff --git a/subsystem/modes/ModeDefinitions.h b/subsystem/modes/ModeDefinitions.h index 153710af..a865ab0c 100644 --- a/subsystem/modes/ModeDefinitions.h +++ b/subsystem/modes/ModeDefinitions.h @@ -1,10 +1,10 @@ #ifndef MODEDEFINITIONS_H_ #define MODEDEFINITIONS_H_ -#include -#include -#include -#include +#include "../../modes/HasModesIF.h" +#include "../../objectmanager/SystemObjectIF.h" +#include "../../serialize/SerializeIF.h" +#include "../../serialize/SerialLinkedListAdapter.h" class ModeListEntry: public SerializeIF, public LinkedElement { public: ModeListEntry() : diff --git a/subsystem/modes/ModeSequenceMessage.cpp b/subsystem/modes/ModeSequenceMessage.cpp index 31661739..33019f58 100644 --- a/subsystem/modes/ModeSequenceMessage.cpp +++ b/subsystem/modes/ModeSequenceMessage.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../storagemanager/StorageManagerIF.h" +#include "ModeSequenceMessage.h" void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message, Command_t command, Mode_t sequence, store_address_t storeAddress) { diff --git a/subsystem/modes/ModeSequenceMessage.h b/subsystem/modes/ModeSequenceMessage.h index 830cf532..9f99cc99 100644 --- a/subsystem/modes/ModeSequenceMessage.h +++ b/subsystem/modes/ModeSequenceMessage.h @@ -1,9 +1,9 @@ #ifndef MODESEQUENCEMESSAGE_H_ #define MODESEQUENCEMESSAGE_H_ -#include -#include -#include +#include "../../ipc/CommandMessage.h" +#include "../../storagemanager/StorageManagerIF.h" +#include "ModeDefinitions.h" class ModeSequenceMessage { public: diff --git a/subsystem/modes/ModeStore.cpp b/subsystem/modes/ModeStore.cpp index 2aa02087..217e177c 100644 --- a/subsystem/modes/ModeStore.cpp +++ b/subsystem/modes/ModeStore.cpp @@ -1,4 +1,4 @@ -#include +#include "ModeStore.h" #ifdef USE_MODESTORE diff --git a/subsystem/modes/ModeStore.h b/subsystem/modes/ModeStore.h index cbc45b5a..0bf856a3 100644 --- a/subsystem/modes/ModeStore.h +++ b/subsystem/modes/ModeStore.h @@ -3,10 +3,10 @@ #ifdef USE_MODESTORE -#include -#include -#include -#include +#include "../../container/ArrayList.h" +#include "../../container/SinglyLinkedList.h" +#include "../../objectmanager/SystemObject.h" +#include "ModeStoreIF.h" class ModeStore: public ModeStoreIF, public SystemObject { public: diff --git a/subsystem/modes/ModeStoreIF.h b/subsystem/modes/ModeStoreIF.h index 7be7a5a7..e5cac3b2 100644 --- a/subsystem/modes/ModeStoreIF.h +++ b/subsystem/modes/ModeStoreIF.h @@ -3,10 +3,10 @@ #ifdef USE_MODESTORE -#include -#include -#include -#include +#include "../../container/ArrayList.h" +#include "../../container/SinglyLinkedList.h" +#include "../../returnvalues/HasReturnvaluesIF.h" +#include "ModeDefinitions.h" class ModeStoreIF { public: diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h index d716cdfb..06b837db 100644 --- a/tasks/ExecutableObjectIF.h +++ b/tasks/ExecutableObjectIF.h @@ -3,7 +3,7 @@ class PeriodicTaskIF; -#include +#include "../returnvalues/HasReturnvaluesIF.h" #include /** diff --git a/tasks/FixedTimeslotTaskIF.h b/tasks/FixedTimeslotTaskIF.h index 3a3582fb..421978f0 100644 --- a/tasks/FixedTimeslotTaskIF.h +++ b/tasks/FixedTimeslotTaskIF.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "PeriodicTaskIF.h" /** * Following the same principle as the base class IF. This is the interface for a Fixed timeslot task diff --git a/tasks/PeriodicTaskIF.h b/tasks/PeriodicTaskIF.h index 6f490977..17a64b96 100644 --- a/tasks/PeriodicTaskIF.h +++ b/tasks/PeriodicTaskIF.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_TASK_PERIODICTASKIF_H_ #define FRAMEWORK_TASK_PERIODICTASKIF_H_ -#include -#include +#include "../objectmanager/SystemObjectIF.h" +#include "../timemanager/Clock.h" #include class ExecutableObjectIF; diff --git a/tasks/TaskFactory.h b/tasks/TaskFactory.h index 8a59adf1..cbf2272c 100644 --- a/tasks/TaskFactory.h +++ b/tasks/TaskFactory.h @@ -2,8 +2,8 @@ #define FRAMEWORK_TASKS_TASKFACTORY_H_ #include -#include -#include +#include "FixedTimeslotTaskIF.h" +#include "Typedef.h" /** * Singleton Class that produces Tasks. diff --git a/tcdistribution/CCSDSDistributor.cpp b/tcdistribution/CCSDSDistributor.cpp index 878b8f7d..1ebb3185 100644 --- a/tcdistribution/CCSDSDistributor.cpp +++ b/tcdistribution/CCSDSDistributor.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "CCSDSDistributor.h" +#include "../tmtcpacket/SpacePacketBase.h" CCSDSDistributor::CCSDSDistributor( uint16_t setDefaultApid, object_id_t setObjectId ) : TcDistributor( setObjectId ), default_apid( setDefaultApid ), tcStore(NULL) { diff --git a/tcdistribution/CCSDSDistributor.h b/tcdistribution/CCSDSDistributor.h index 9dce34f2..bff72092 100644 --- a/tcdistribution/CCSDSDistributor.h +++ b/tcdistribution/CCSDSDistributor.h @@ -1,11 +1,11 @@ #ifndef CCSDSDISTRIBUTOR_H_ #define CCSDSDISTRIBUTOR_H_ -#include -#include -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "CCSDSDistributorIF.h" +#include "TcDistributor.h" +#include "../tmtcservices/AcceptsTelecommandsIF.h" /** * An instantiation of the CCSDSDistributorIF. * It receives Space Packets, and selects a destination depending on the APID of the telecommands. diff --git a/tcdistribution/CCSDSDistributorIF.h b/tcdistribution/CCSDSDistributorIF.h index dc1263a9..be3c2811 100644 --- a/tcdistribution/CCSDSDistributorIF.h +++ b/tcdistribution/CCSDSDistributorIF.h @@ -1,8 +1,8 @@ #ifndef CCSDSDISTRIBUTORIF_H_ #define CCSDSDISTRIBUTORIF_H_ -#include -#include +#include "../tmtcservices/AcceptsTelecommandsIF.h" +#include "../ipc/MessageQueueSenderIF.h" /** * This is the Interface to a CCSDS Distributor. * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves, diff --git a/tcdistribution/PUSDistributor.cpp b/tcdistribution/PUSDistributor.cpp index c214f674..f77eb99d 100644 --- a/tcdistribution/PUSDistributor.cpp +++ b/tcdistribution/PUSDistributor.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "CCSDSDistributorIF.h" +#include "PUSDistributor.h" +#include "../tmtcpacket/pus/TcPacketStored.h" +#include "../tmtcservices/PusVerificationReport.h" PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource) : TcDistributor(setObjectId), checker(setApid), verifyChannel(), currentPacket(), tcStatus( diff --git a/tcdistribution/PUSDistributor.h b/tcdistribution/PUSDistributor.h index 8d774662..e9d4be8c 100644 --- a/tcdistribution/PUSDistributor.h +++ b/tcdistribution/PUSDistributor.h @@ -1,12 +1,12 @@ #ifndef PUSDISTRIBUTOR_H_ #define PUSDISTRIBUTOR_H_ -#include -#include -#include -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "PUSDistributorIF.h" +#include "TcDistributor.h" +#include "TcPacketCheck.h" +#include "../tmtcservices/AcceptsTelecommandsIF.h" +#include "../tmtcservices/VerificationReporter.h" /** * This class accepts PUS Telecommands and forwards them to Application services. diff --git a/tcdistribution/PUSDistributorIF.h b/tcdistribution/PUSDistributorIF.h index bb101137..5e27b35c 100644 --- a/tcdistribution/PUSDistributorIF.h +++ b/tcdistribution/PUSDistributorIF.h @@ -1,8 +1,8 @@ #ifndef PUSDISTRIBUTORIF_H_ #define PUSDISTRIBUTORIF_H_ -#include -#include +#include "../tmtcservices/AcceptsTelecommandsIF.h" +#include "../ipc/MessageQueueSenderIF.h" /** * This interface allows PUS Services to register themselves at a PUS Distributor. * \ingroup tc_distribution diff --git a/tcdistribution/TcDistributor.cpp b/tcdistribution/TcDistributor.cpp index 57921459..49a996d9 100644 --- a/tcdistribution/TcDistributor.cpp +++ b/tcdistribution/TcDistributor.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "TcDistributor.h" +#include "../tmtcservices/TmTcMessage.h" +#include "../ipc/QueueFactory.h" TcDistributor::TcDistributor(object_id_t set_object_id) : SystemObject(set_object_id), tcQueue(NULL) { diff --git a/tcdistribution/TcDistributor.h b/tcdistribution/TcDistributor.h index b80f08e6..fed1cb3e 100644 --- a/tcdistribution/TcDistributor.h +++ b/tcdistribution/TcDistributor.h @@ -1,12 +1,12 @@ #ifndef TCDISTRIBUTOR_H_ #define TCDISTRIBUTOR_H_ -#include -#include -#include -#include -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "../objectmanager/SystemObject.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../tmtcservices/TmTcMessage.h" +#include "../ipc/MessageQueueIF.h" #include diff --git a/tcdistribution/TcPacketCheck.cpp b/tcdistribution/TcPacketCheck.cpp index 90a1167f..b5881083 100644 --- a/tcdistribution/TcPacketCheck.cpp +++ b/tcdistribution/TcPacketCheck.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../globalfunctions/CRC.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../storagemanager/StorageManagerIF.h" +#include "TcPacketCheck.h" +#include "../tmtcservices/VerificationCodes.h" TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) { } diff --git a/tcdistribution/TcPacketCheck.h b/tcdistribution/TcPacketCheck.h index 88810ed7..4ba269f5 100644 --- a/tcdistribution/TcPacketCheck.h +++ b/tcdistribution/TcPacketCheck.h @@ -1,9 +1,9 @@ #ifndef TCPACKETCHECK_H_ #define TCPACKETCHECK_H_ -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../tmtcpacket/pus/TcPacketStored.h" +#include "../tmtcservices/PusVerificationReport.h" /** * This class performs a formal packet check for incoming PUS Telecommand Packets. * Currently, it only checks if the APID and CRC are correct. diff --git a/thermal/AbstractTemperatureSensor.cpp b/thermal/AbstractTemperatureSensor.cpp index be143410..45ebe4a2 100644 --- a/thermal/AbstractTemperatureSensor.cpp +++ b/thermal/AbstractTemperatureSensor.cpp @@ -1,5 +1,5 @@ #include "AbstractTemperatureSensor.h" -#include +#include "../ipc/QueueFactory.h" AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid, ThermalModuleIF *thermalModule) : diff --git a/thermal/AbstractTemperatureSensor.h b/thermal/AbstractTemperatureSensor.h index 75437dca..726ab9f4 100644 --- a/thermal/AbstractTemperatureSensor.h +++ b/thermal/AbstractTemperatureSensor.h @@ -1,12 +1,12 @@ #ifndef ABSTRACTSENSOR_H_ #define ABSTRACTSENSOR_H_ -#include -#include -#include -#include -#include -#include +#include "../health/HasHealthIF.h" +#include "../health/HealthHelper.h" +#include "../objectmanager/SystemObject.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../parameters/ParameterHelper.h" +#include "../ipc/MessageQueueIF.h" #include "ThermalModuleIF.h" #include "tcsDefinitions.h" diff --git a/thermal/CoreComponent.h b/thermal/CoreComponent.h index f7e7aff8..48a49f7d 100644 --- a/thermal/CoreComponent.h +++ b/thermal/CoreComponent.h @@ -1,12 +1,12 @@ #ifndef MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ #define MISSION_CONTROLLERS_TCS_CORECOMPONENT_H_ -#include -#include -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PoolVariable.h" +#include "ThermalComponentIF.h" +#include "AbstractTemperatureSensor.h" +#include "ThermalModule.h" +#include "ThermalMonitor.h" class CoreComponent: public ThermalComponentIF { public: diff --git a/thermal/Heater.cpp b/thermal/Heater.cpp index 29daa15d..1301e2e0 100644 --- a/thermal/Heater.cpp +++ b/thermal/Heater.cpp @@ -1,8 +1,8 @@ -#include +#include "../devicehandlers/DeviceHandlerFailureIsolation.h" #include "Heater.h" -#include -#include +#include "../power/Fuse.h" +#include "../ipc/QueueFactory.h" Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) : HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher( diff --git a/thermal/Heater.h b/thermal/Heater.h index 41004e03..63fe2066 100644 --- a/thermal/Heater.h +++ b/thermal/Heater.h @@ -1,11 +1,11 @@ #ifndef FRAMEWORK_THERMAL_HEATER_H_ #define FRAMEWORK_THERMAL_HEATER_H_ -#include -#include -#include -#include -#include +#include "../devicehandlers/HealthDevice.h" +#include "../parameters/ParameterHelper.h" +#include "../power/PowerSwitchIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../timemanager/Countdown.h" #include //class RedundantHeater; diff --git a/thermal/RedundantHeater.h b/thermal/RedundantHeater.h index 29791a9a..ab745a69 100644 --- a/thermal/RedundantHeater.h +++ b/thermal/RedundantHeater.h @@ -1,7 +1,7 @@ #ifndef REDUNDANTHEATER_H_ #define REDUNDANTHEATER_H_ -#include +#include "Heater.h" class RedundantHeater { public: diff --git a/thermal/TemperatureSensor.h b/thermal/TemperatureSensor.h index de280d87..356ca722 100644 --- a/thermal/TemperatureSensor.h +++ b/thermal/TemperatureSensor.h @@ -1,9 +1,9 @@ #ifndef TEMPERATURESENSOR_H_ #define TEMPERATURESENSOR_H_ -#include +#include "../datapool/DataSet.h" #include "AbstractTemperatureSensor.h" -#include +#include "../monitoring/LimitMonitor.h" template class TemperatureSensor: public AbstractTemperatureSensor { diff --git a/thermal/ThermalComponentIF.h b/thermal/ThermalComponentIF.h index ad8dbd0a..522d4e44 100644 --- a/thermal/ThermalComponentIF.h +++ b/thermal/ThermalComponentIF.h @@ -1,10 +1,10 @@ #ifndef THERMALCOMPONENTIF_H_ #define THERMALCOMPONENTIF_H_ -#include -#include -#include -#include +#include "../events/Event.h" +#include "../parameters/HasParametersIF.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../objectmanager/SystemObjectIF.h" class ThermalComponentIF : public HasParametersIF { public: diff --git a/thermal/ThermalModule.cpp b/thermal/ThermalModule.cpp index 24a4c90d..c573008e 100644 --- a/thermal/ThermalModule.cpp +++ b/thermal/ThermalModule.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../monitoring/LimitViolationReporter.h" +#include "../monitoring/MonitoringMessageContent.h" #include "ThermalModule.h" #include "AbstractTemperatureSensor.h" diff --git a/thermal/ThermalModule.h b/thermal/ThermalModule.h index d8ac7d73..19ab9a54 100644 --- a/thermal/ThermalModule.h +++ b/thermal/ThermalModule.h @@ -1,10 +1,10 @@ #ifndef THERMALMODULE_H_ #define THERMALMODULE_H_ -#include -#include -#include -#include +#include "../datapool/DataSet.h" +#include "../datapool/PoolVariable.h" +#include "../devicehandlers/HealthDevice.h" +#include "../events/EventReportingProxyIF.h" #include "ThermalModuleIF.h" #include #include "tcsDefinitions.h" diff --git a/thermal/ThermalMonitor.cpp b/thermal/ThermalMonitor.cpp index 773fa084..11abfbe5 100644 --- a/thermal/ThermalMonitor.cpp +++ b/thermal/ThermalMonitor.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "ThermalMonitor.h" +#include "ThermalComponentIF.h" +#include "../monitoring/MonitoringIF.h" ThermalMonitor::~ThermalMonitor() { } diff --git a/thermal/ThermalMonitor.h b/thermal/ThermalMonitor.h index 6aca55ab..5c6806c1 100644 --- a/thermal/ThermalMonitor.h +++ b/thermal/ThermalMonitor.h @@ -1,8 +1,8 @@ #ifndef FRAMEWORK_THERMAL_THERMALMONITOR_H_ #define FRAMEWORK_THERMAL_THERMALMONITOR_H_ -#include -#include +#include "../monitoring/MonitorReporter.h" +#include "ThermalComponentIF.h" class ThermalMonitor: public MonitorReporter { public: diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp index 71b2539d..eddbb97b 100644 --- a/timemanager/CCSDSTime.cpp +++ b/timemanager/CCSDSTime.cpp @@ -1,4 +1,4 @@ -#include +#include "CCSDSTime.h" #include #include #include diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h index 92060d5d..8563cf0f 100644 --- a/timemanager/CCSDSTime.h +++ b/timemanager/CCSDSTime.h @@ -3,8 +3,8 @@ // COULDDO: have calls in Clock.h which return time quality and use timespec accordingly -#include -#include +#include "Clock.h" +#include "../returnvalues/HasReturnvaluesIF.h" #include bool operator<(const timeval& lhs, const timeval& rhs); diff --git a/timemanager/Clock.h b/timemanager/Clock.h index 121c63df..6f6a97da 100644 --- a/timemanager/Clock.h +++ b/timemanager/Clock.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_TIMEMANAGER_CLOCK_H_ #define FRAMEWORK_TIMEMANAGER_CLOCK_H_ -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../ipc/MutexFactory.h" +#include "../globalfunctions/timevalOperations.h" #include #include diff --git a/timemanager/Countdown.cpp b/timemanager/Countdown.cpp index e6565914..d5695730 100644 --- a/timemanager/Countdown.cpp +++ b/timemanager/Countdown.cpp @@ -6,7 +6,7 @@ */ -#include +#include "Countdown.h" Countdown::Countdown(uint32_t initialTimeout) : startTime(0), timeout(initialTimeout) { } diff --git a/timemanager/Countdown.h b/timemanager/Countdown.h index 57a11f91..b86d9fe0 100644 --- a/timemanager/Countdown.h +++ b/timemanager/Countdown.h @@ -8,7 +8,7 @@ #ifndef COUNTDOWN_H_ #define COUNTDOWN_H_ -#include +#include "Clock.h" class Countdown { private: diff --git a/timemanager/Stopwatch.cpp b/timemanager/Stopwatch.cpp index 52118d58..00373bd7 100644 --- a/timemanager/Stopwatch.cpp +++ b/timemanager/Stopwatch.cpp @@ -1,57 +1,57 @@ -#include -#include -#include - -Stopwatch::Stopwatch(bool displayOnDestruction, - StopwatchDisplayMode displayMode): displayOnDestruction( - displayOnDestruction), displayMode(displayMode) { - // Measures start time on initialization. - Clock::getClock_timeval(&startTime); -} - -void Stopwatch::start() { - Clock::getClock_timeval(&startTime); -} - -dur_millis_t Stopwatch::stop() { - stopInternal(); - return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000; -} - -dur_seconds_t Stopwatch::stopSeconds() { - stopInternal(); - return timevalOperations::toDouble(elapsedTime); -} - -void Stopwatch::display() { - if(displayMode == StopwatchDisplayMode::MILLIS) { - sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 + - elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl; - } - else if(displayMode == StopwatchDisplayMode::SECONDS) { - sif::info <<"Stopwatch: Operation took " << std::setprecision(3) - << std::fixed << timevalOperations::toDouble(elapsedTime) - << " seconds" << std::endl; - } -} - -Stopwatch::~Stopwatch() { - if(displayOnDestruction) { - stopInternal(); - display(); - } -} - -void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) { - this->displayMode = displayMode; -} - -StopwatchDisplayMode Stopwatch::getDisplayMode() const { - return displayMode; -} - -void Stopwatch::stopInternal() { - timeval endTime; - Clock::getClock_timeval(&endTime); - elapsedTime = endTime - startTime; -} +#include "Stopwatch.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include + +Stopwatch::Stopwatch(bool displayOnDestruction, + StopwatchDisplayMode displayMode): displayOnDestruction( + displayOnDestruction), displayMode(displayMode) { + // Measures start time on initialization. + Clock::getClock_timeval(&startTime); +} + +void Stopwatch::start() { + Clock::getClock_timeval(&startTime); +} + +dur_millis_t Stopwatch::stop() { + stopInternal(); + return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000; +} + +dur_seconds_t Stopwatch::stopSeconds() { + stopInternal(); + return timevalOperations::toDouble(elapsedTime); +} + +void Stopwatch::display() { + if(displayMode == StopwatchDisplayMode::MILLIS) { + sif::info << "Stopwatch: Operation took " << (elapsedTime.tv_sec * 1000 + + elapsedTime.tv_usec / 1000) << " milliseconds" << std::endl; + } + else if(displayMode == StopwatchDisplayMode::SECONDS) { + sif::info <<"Stopwatch: Operation took " << std::setprecision(3) + << std::fixed << timevalOperations::toDouble(elapsedTime) + << " seconds" << std::endl; + } +} + +Stopwatch::~Stopwatch() { + if(displayOnDestruction) { + stopInternal(); + display(); + } +} + +void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) { + this->displayMode = displayMode; +} + +StopwatchDisplayMode Stopwatch::getDisplayMode() const { + return displayMode; +} + +void Stopwatch::stopInternal() { + timeval endTime; + Clock::getClock_timeval(&endTime); + elapsedTime = endTime - startTime; +} diff --git a/timemanager/Stopwatch.h b/timemanager/Stopwatch.h index 630202cc..f216b7e1 100644 --- a/timemanager/Stopwatch.h +++ b/timemanager/Stopwatch.h @@ -1,71 +1,71 @@ -#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ -#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ -#include - -enum class StopwatchDisplayMode { - MILLIS, - SECONDS -}; - -/** - * @brief Simple Stopwatch implementation to measure elapsed time - * @details - * This class can be used to measure elapsed times. It also displays elapsed - * times automatically on destruction if not explicitely deactivated in the - * constructor. The default time format is the elapsed time in miliseconds - * in seconds as a double. - * @author R. Mueller - */ -class Stopwatch { -public: - /** - * Default constructor. Call "Stopwatch stopwatch" without brackets if - * no parameters are required! - * @param displayOnDestruction If set to true, displays measured time on - * object destruction - * @param displayMode Display format is either MS rounded or MS as double - * format - * @param outputPrecision If using double format, specify precision here. - */ - Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode - = StopwatchDisplayMode::MILLIS); - virtual~ Stopwatch(); - - /** - * Caches the start time - */ - void start(); - - /** - * Calculates the elapsed time since start and returns it - * @return elapsed time in milliseconds (rounded) - */ - dur_millis_t stop(); - /** - * Calculates the elapsed time since start and returns it - * @return elapsed time in seconds (double precision) - */ - dur_seconds_t stopSeconds(); - - /** - * Displays the elapsed times on the osstream, depending on internal display - * mode. - */ - void display(); - - StopwatchDisplayMode getDisplayMode() const; - void setDisplayMode(StopwatchDisplayMode displayMode); - bool displayOnDestruction = true; -private: - timeval startTime {0, 0}; - timeval elapsedTime {0, 0}; - - StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS; - - void stopInternal(); -}; - - - - -#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */ +#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ +#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ +#include "Clock.h" + +enum class StopwatchDisplayMode { + MILLIS, + SECONDS +}; + +/** + * @brief Simple Stopwatch implementation to measure elapsed time + * @details + * This class can be used to measure elapsed times. It also displays elapsed + * times automatically on destruction if not explicitely deactivated in the + * constructor. The default time format is the elapsed time in miliseconds + * in seconds as a double. + * @author R. Mueller + */ +class Stopwatch { +public: + /** + * Default constructor. Call "Stopwatch stopwatch" without brackets if + * no parameters are required! + * @param displayOnDestruction If set to true, displays measured time on + * object destruction + * @param displayMode Display format is either MS rounded or MS as double + * format + * @param outputPrecision If using double format, specify precision here. + */ + Stopwatch(bool displayOnDestruction = true, StopwatchDisplayMode displayMode + = StopwatchDisplayMode::MILLIS); + virtual~ Stopwatch(); + + /** + * Caches the start time + */ + void start(); + + /** + * Calculates the elapsed time since start and returns it + * @return elapsed time in milliseconds (rounded) + */ + dur_millis_t stop(); + /** + * Calculates the elapsed time since start and returns it + * @return elapsed time in seconds (double precision) + */ + dur_seconds_t stopSeconds(); + + /** + * Displays the elapsed times on the osstream, depending on internal display + * mode. + */ + void display(); + + StopwatchDisplayMode getDisplayMode() const; + void setDisplayMode(StopwatchDisplayMode displayMode); + bool displayOnDestruction = true; +private: + timeval startTime {0, 0}; + timeval elapsedTime {0, 0}; + + StopwatchDisplayMode displayMode = StopwatchDisplayMode::MILLIS; + + void stopInternal(); +}; + + + + +#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */ diff --git a/timemanager/TimeMessage.cpp b/timemanager/TimeMessage.cpp index bf514317..5a9a416b 100644 --- a/timemanager/TimeMessage.cpp +++ b/timemanager/TimeMessage.cpp @@ -5,7 +5,7 @@ * @author baetz */ -#include +#include "TimeMessage.h" TimeMessage::TimeMessage() { this->messageSize += sizeof(timeval) + sizeof(uint32_t); diff --git a/timemanager/TimeMessage.h b/timemanager/TimeMessage.h index 95685fec..116002e6 100644 --- a/timemanager/TimeMessage.h +++ b/timemanager/TimeMessage.h @@ -8,8 +8,8 @@ #ifndef TIMEMESSAGE_H_ #define TIMEMESSAGE_H_ -#include -#include +#include "../ipc/MessageQueueMessage.h" +#include "Clock.h" #include class TimeMessage : public MessageQueueMessage { diff --git a/timemanager/TimeStamperIF.h b/timemanager/TimeStamperIF.h index 7ed45371..bdc5e7e3 100644 --- a/timemanager/TimeStamperIF.h +++ b/timemanager/TimeStamperIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ #define FRAMEWORK_TIMEMANAGER_TIMESTAMPERIF_H_ -#include +#include "../returnvalues/HasReturnvaluesIF.h" /** * A class implementing this IF provides facilities to add a time stamp to the diff --git a/tmstorage/TmStoreBackendIF.h b/tmstorage/TmStoreBackendIF.h index 162bd766..a441808e 100644 --- a/tmstorage/TmStoreBackendIF.h +++ b/tmstorage/TmStoreBackendIF.h @@ -1,11 +1,11 @@ #ifndef PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ #define PLATFORM_TMTCSERVICES_TMSTOREBACKENDIF_H_ -#include -#include -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../objectmanager/SystemObjectIF.h" +#include "../parameters/HasParametersIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../timemanager/Clock.h" class TmPacketInformation; class TmPacketMinimal; class SpacePacketBase; diff --git a/tmstorage/TmStoreFrontendIF.h b/tmstorage/TmStoreFrontendIF.h index 787c3597..e1bc3a14 100644 --- a/tmstorage/TmStoreFrontendIF.h +++ b/tmstorage/TmStoreFrontendIF.h @@ -1,9 +1,9 @@ #ifndef PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ #define PLATFORM_TMTCSERVICES_TMSTOREFRONTENDIF_H_ -#include -#include -#include +#include "../returnvalues/HasReturnvaluesIF.h" +#include "TmStorePackets.h" +#include "../ipc/MessageQueueSenderIF.h" class TmPacketMinimal; class SpacePacketBase; class TmStoreBackendIF; diff --git a/tmstorage/TmStoreMessage.cpp b/tmstorage/TmStoreMessage.cpp index e908b923..d2efd403 100644 --- a/tmstorage/TmStoreMessage.cpp +++ b/tmstorage/TmStoreMessage.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "TmStoreMessage.h" TmStoreMessage::~TmStoreMessage() { diff --git a/tmstorage/TmStoreMessage.h b/tmstorage/TmStoreMessage.h index 0883063c..66fdefa5 100644 --- a/tmstorage/TmStoreMessage.h +++ b/tmstorage/TmStoreMessage.h @@ -1,10 +1,10 @@ #ifndef FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ #define FRAMEWORK_TMSTORAGE_TMSTOREMESSAGE_H_ -#include -#include -#include -#include +#include "../ipc/CommandMessage.h" +#include "../storagemanager/StorageManagerIF.h" +#include "TmStorePackets.h" +#include "../objectmanager/SystemObjectIF.h" class TmStoreMessage: public CommandMessage { public: static ReturnValue_t setEnableStoringMessage(CommandMessage* cmd, diff --git a/tmstorage/TmStorePackets.h b/tmstorage/TmStorePackets.h index 16768e68..e88e741a 100644 --- a/tmstorage/TmStorePackets.h +++ b/tmstorage/TmStorePackets.h @@ -1,14 +1,14 @@ #ifndef FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ #define FRAMEWORK_TMSTORAGE_TMSTOREPACKETS_H_ -#include -#include -#include -#include -#include -#include -#include -#include +#include "../serialize/SerialFixedArrayListAdapter.h" +#include "../serialize/SerializeElement.h" +#include "../serialize/SerialLinkedListAdapter.h" +#include "../serialize/SerialBufferAdapter.h" +#include "../tmtcpacket/pus/TmPacketMinimal.h" +#include "../timemanager/TimeStamperIF.h" +#include "../timemanager/CCSDSTime.h" +#include "../globalfunctions/timevalOperations.h" class ServiceSubservice: public SerialLinkedListAdapter { public: diff --git a/tmtcpacket/SpacePacket.cpp b/tmtcpacket/SpacePacket.cpp index d9bc08fa..b8ba27e9 100644 --- a/tmtcpacket/SpacePacket.cpp +++ b/tmtcpacket/SpacePacket.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "ccsds_header.h" +#include "SpacePacket.h" #include SpacePacket::SpacePacket( uint16_t packetDataLength, bool isTelecommand, uint16_t apid, uint16_t sequenceCount ): diff --git a/tmtcpacket/SpacePacket.h b/tmtcpacket/SpacePacket.h index f2d45752..49dd5ae5 100644 --- a/tmtcpacket/SpacePacket.h +++ b/tmtcpacket/SpacePacket.h @@ -1,7 +1,7 @@ #ifndef SPACEPACKET_H_ #define SPACEPACKET_H_ -#include +#include "SpacePacketBase.h" /** * The SpacePacket class is a representation of a simple CCSDS Space Packet diff --git a/tmtcpacket/SpacePacketBase.cpp b/tmtcpacket/SpacePacketBase.cpp index 13c062d8..a37e024b 100644 --- a/tmtcpacket/SpacePacketBase.cpp +++ b/tmtcpacket/SpacePacketBase.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "SpacePacketBase.h" #include SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) { diff --git a/tmtcpacket/SpacePacketBase.h b/tmtcpacket/SpacePacketBase.h index cc68f714..ef3ad79d 100644 --- a/tmtcpacket/SpacePacketBase.h +++ b/tmtcpacket/SpacePacketBase.h @@ -1,7 +1,7 @@ #ifndef SPACEPACKETBASE_H_ #define SPACEPACKETBASE_H_ -#include +#include "ccsds_header.h" /** * \defgroup tmtcpackets Space Packets diff --git a/tmtcpacket/packetmatcher/ApidMatcher.h b/tmtcpacket/packetmatcher/ApidMatcher.h index 3080ffef..4f196ac9 100644 --- a/tmtcpacket/packetmatcher/ApidMatcher.h +++ b/tmtcpacket/packetmatcher/ApidMatcher.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ #define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ -#include -#include -#include +#include "../../globalfunctions/matching/SerializeableMatcherIF.h" +#include "../../serialize/SerializeAdapter.h" +#include "../../tmtcpacket/pus/TmPacketMinimal.h" class ApidMatcher: public SerializeableMatcherIF { private: diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.cpp b/tmtcpacket/packetmatcher/PacketMatchTree.cpp index d8f61ffb..a4579657 100644 --- a/tmtcpacket/packetmatcher/PacketMatchTree.cpp +++ b/tmtcpacket/packetmatcher/PacketMatchTree.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "ApidMatcher.h" +#include "PacketMatchTree.h" +#include "ServiceMatcher.h" +#include "SubserviceMatcher.h" PacketMatchTree::PacketMatchTree(Node* root) : MatchTree(root, 2), factoryBackend(0, POOL_SIZES, diff --git a/tmtcpacket/packetmatcher/PacketMatchTree.h b/tmtcpacket/packetmatcher/PacketMatchTree.h index a6c0c61e..86fb087e 100644 --- a/tmtcpacket/packetmatcher/PacketMatchTree.h +++ b/tmtcpacket/packetmatcher/PacketMatchTree.h @@ -1,10 +1,10 @@ #ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ #define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ -#include -#include -#include -#include +#include "../../container/PlacementFactory.h" +#include "../../globalfunctions/matching/MatchTree.h" +#include "../../storagemanager/LocalPool.h" +#include "../../tmtcpacket/pus/TmPacketMinimal.h" class PacketMatchTree: public MatchTree, public HasReturnvaluesIF { public: diff --git a/tmtcpacket/packetmatcher/ServiceMatcher.h b/tmtcpacket/packetmatcher/ServiceMatcher.h index f6e9e360..eba23d75 100644 --- a/tmtcpacket/packetmatcher/ServiceMatcher.h +++ b/tmtcpacket/packetmatcher/ServiceMatcher.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ #define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ -#include -#include -#include +#include "../../globalfunctions/matching/SerializeableMatcherIF.h" +#include "../../serialize/SerializeAdapter.h" +#include "../../tmtcpacket/pus/TmPacketMinimal.h" class ServiceMatcher: public SerializeableMatcherIF { private: diff --git a/tmtcpacket/packetmatcher/SubserviceMatcher.h b/tmtcpacket/packetmatcher/SubserviceMatcher.h index 2e8b82b2..a9b6def8 100644 --- a/tmtcpacket/packetmatcher/SubserviceMatcher.h +++ b/tmtcpacket/packetmatcher/SubserviceMatcher.h @@ -1,9 +1,9 @@ #ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ #define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ -#include -#include -#include +#include "../../globalfunctions/matching/SerializeableMatcherIF.h" +#include "../../serialize/SerializeAdapter.h" +#include "../../tmtcpacket/pus/TmPacketMinimal.h" class SubServiceMatcher: public SerializeableMatcherIF { public: diff --git a/tmtcpacket/pus/PacketTimestampInterpreterIF.h b/tmtcpacket/pus/PacketTimestampInterpreterIF.h index 6e19381a..dd0c0328 100644 --- a/tmtcpacket/pus/PacketTimestampInterpreterIF.h +++ b/tmtcpacket/pus/PacketTimestampInterpreterIF.h @@ -1,7 +1,7 @@ #ifndef FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ #define FRAMEWORK_TMTCPACKET_PUS_PACKETTIMESTAMPINTERPRETERIF_H_ -#include +#include "../../returnvalues/HasReturnvaluesIF.h" class TmPacketMinimal; class PacketTimestampInterpreterIF { diff --git a/tmtcpacket/pus/TcPacketBase.cpp b/tmtcpacket/pus/TcPacketBase.cpp index 0f3bd52e..3815eb20 100644 --- a/tmtcpacket/pus/TcPacketBase.cpp +++ b/tmtcpacket/pus/TcPacketBase.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../../globalfunctions/CRC.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "TcPacketBase.h" #include TcPacketBase::TcPacketBase(const uint8_t* set_data) : diff --git a/tmtcpacket/pus/TcPacketBase.h b/tmtcpacket/pus/TcPacketBase.h index e6e6bdad..dd63d2be 100644 --- a/tmtcpacket/pus/TcPacketBase.h +++ b/tmtcpacket/pus/TcPacketBase.h @@ -1,7 +1,7 @@ #ifndef TCPACKETBASE_H_ #define TCPACKETBASE_H_ -#include +#include "../../tmtcpacket/SpacePacketBase.h" /** * This struct defines a byte-wise structured PUS TC Data Field Header. diff --git a/tmtcpacket/pus/TcPacketStored.cpp b/tmtcpacket/pus/TcPacketStored.cpp index 0187b08f..216f89c9 100644 --- a/tmtcpacket/pus/TcPacketStored.cpp +++ b/tmtcpacket/pus/TcPacketStored.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "TcPacketStored.h" #include TcPacketStored::TcPacketStored(store_address_t setAddress) : diff --git a/tmtcpacket/pus/TcPacketStored.h b/tmtcpacket/pus/TcPacketStored.h index c57f0e0f..2d86f89b 100644 --- a/tmtcpacket/pus/TcPacketStored.h +++ b/tmtcpacket/pus/TcPacketStored.h @@ -1,8 +1,8 @@ #ifndef TCPACKETSTORED_H_ #define TCPACKETSTORED_H_ -#include -#include +#include "../../storagemanager/StorageManagerIF.h" +#include "TcPacketBase.h" /** * This class generates a ECSS PUS Telecommand packet within a given diff --git a/tmtcpacket/pus/TmPacketBase.cpp b/tmtcpacket/pus/TmPacketBase.cpp index a7bda5af..3c1a8ca4 100644 --- a/tmtcpacket/pus/TmPacketBase.cpp +++ b/tmtcpacket/pus/TmPacketBase.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include "../../globalfunctions/CRC.h" +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "TmPacketBase.h" +#include "../../timemanager/CCSDSTime.h" #include TmPacketBase::TmPacketBase(uint8_t* set_data) : diff --git a/tmtcpacket/pus/TmPacketBase.h b/tmtcpacket/pus/TmPacketBase.h index d03beba5..85ae4dac 100644 --- a/tmtcpacket/pus/TmPacketBase.h +++ b/tmtcpacket/pus/TmPacketBase.h @@ -1,10 +1,10 @@ #ifndef TMPACKETBASE_H_ #define TMPACKETBASE_H_ -#include -#include -#include -#include +#include "../../timemanager/TimeStamperIF.h" +#include "../../tmtcpacket/SpacePacketBase.h" +#include "../../timemanager/Clock.h" +#include "../../objectmanager/SystemObjectIF.h" namespace Factory{ void setStaticFrameworkObjectIds(); diff --git a/tmtcpacket/pus/TmPacketMinimal.cpp b/tmtcpacket/pus/TmPacketMinimal.cpp index 9df0fe5d..18e9dda1 100644 --- a/tmtcpacket/pus/TmPacketMinimal.cpp +++ b/tmtcpacket/pus/TmPacketMinimal.cpp @@ -1,7 +1,7 @@ -#include +#include "TmPacketMinimal.h" #include #include -#include +#include "PacketTimestampInterpreterIF.h" TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( set_data ) { this->tm_data = (TmPacketMinimalPointer*)set_data; diff --git a/tmtcpacket/pus/TmPacketMinimal.h b/tmtcpacket/pus/TmPacketMinimal.h index 7bfe0883..728acb15 100644 --- a/tmtcpacket/pus/TmPacketMinimal.h +++ b/tmtcpacket/pus/TmPacketMinimal.h @@ -2,8 +2,8 @@ #define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ -#include -#include +#include "../../tmtcpacket/SpacePacketBase.h" +#include "../../returnvalues/HasReturnvaluesIF.h" struct timeval; class PacketTimestampInterpreterIF; diff --git a/tmtcpacket/pus/TmPacketStored.cpp b/tmtcpacket/pus/TmPacketStored.cpp index 7c327581..4e4c9434 100644 --- a/tmtcpacket/pus/TmPacketStored.cpp +++ b/tmtcpacket/pus/TmPacketStored.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "../../objectmanager/ObjectManagerIF.h" +#include "../../serviceinterface/ServiceInterfaceStream.h" +#include "TmPacketStored.h" +#include "../../tmtcservices/TmTcMessage.h" #include TmPacketStored::TmPacketStored(store_address_t setAddress) : diff --git a/tmtcpacket/pus/TmPacketStored.h b/tmtcpacket/pus/TmPacketStored.h index eaa26ce7..8962d343 100644 --- a/tmtcpacket/pus/TmPacketStored.h +++ b/tmtcpacket/pus/TmPacketStored.h @@ -1,11 +1,11 @@ #ifndef TMPACKETSTORED_H_ #define TMPACKETSTORED_H_ -#include -#include -#include -#include -#include +#include "../../serialize/SerializeIF.h" +#include "../../storagemanager/StorageManagerIF.h" +#include "TmPacketBase.h" +#include "../../internalError/InternalErrorReporterIF.h" +#include "../../ipc/MessageQueueSenderIF.h" /** * This class generates a ECSS PUS Telemetry packet within a given diff --git a/tmtcservices/AcceptsTelecommandsIF.h b/tmtcservices/AcceptsTelecommandsIF.h index 03a57aae..76d10a59 100644 --- a/tmtcservices/AcceptsTelecommandsIF.h +++ b/tmtcservices/AcceptsTelecommandsIF.h @@ -1,7 +1,7 @@ #ifndef ACCEPTSTELECOMMANDSIF_H_ #define ACCEPTSTELECOMMANDSIF_H_ -#include +#include "../ipc/MessageQueueSenderIF.h" /** * @brief This interface is implemented by classes that are sinks for diff --git a/tmtcservices/AcceptsTelemetryIF.h b/tmtcservices/AcceptsTelemetryIF.h index 8c00b5c6..2325dbe0 100644 --- a/tmtcservices/AcceptsTelemetryIF.h +++ b/tmtcservices/AcceptsTelemetryIF.h @@ -1,7 +1,7 @@ #ifndef ACCEPTSTELEMETRYIF_H_ #define ACCEPTSTELEMETRYIF_H_ -#include +#include "../ipc/MessageQueueSenderIF.h" /** * @brief This interface is implemented by classes that are sinks for * Telemetry. diff --git a/tmtcservices/AcceptsVerifyMessageIF.h b/tmtcservices/AcceptsVerifyMessageIF.h index fe8bb288..c9318ab0 100644 --- a/tmtcservices/AcceptsVerifyMessageIF.h +++ b/tmtcservices/AcceptsVerifyMessageIF.h @@ -1,7 +1,7 @@ #ifndef ACCEPTSVERIFICATIONMESSAGEIF_H_ #define ACCEPTSVERIFICATIONMESSAGEIF_H_ -#include +#include "../ipc/MessageQueueSenderIF.h" class AcceptsVerifyMessageIF { public: diff --git a/tmtcservices/CommandingServiceBase.cpp b/tmtcservices/CommandingServiceBase.cpp index 330fd00f..0b33e3aa 100644 --- a/tmtcservices/CommandingServiceBase.cpp +++ b/tmtcservices/CommandingServiceBase.cpp @@ -1,12 +1,12 @@ -#include -#include -#include +#include "../tcdistribution/PUSDistributorIF.h" +#include "AcceptsTelemetryIF.h" +#include "../objectmanager/ObjectManagerIF.h" -#include -#include -#include -#include -#include +#include "CommandingServiceBase.h" +#include "TmTcMessage.h" +#include "../ipc/QueueFactory.h" +#include "../tmtcpacket/pus/TcPacketStored.h" +#include "../tmtcpacket/pus/TmPacketStored.h" object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT; object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT; diff --git a/tmtcservices/CommandingServiceBase.h b/tmtcservices/CommandingServiceBase.h index b3a15985..c0453f2f 100644 --- a/tmtcservices/CommandingServiceBase.h +++ b/tmtcservices/CommandingServiceBase.h @@ -1,17 +1,17 @@ #ifndef FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ #define FRAMEWORK_TMTCSERVICES_COMMANDINGSERVICEBASE_H_ -#include -#include -#include -#include -#include +#include "../objectmanager/SystemObject.h" +#include "../storagemanager/StorageManagerIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../ipc/MessageQueueIF.h" +#include "AcceptsTelecommandsIF.h" -#include -#include -#include -#include -#include +#include "VerificationReporter.h" +#include "../ipc/CommandMessage.h" +#include "../container/FixedMap.h" +#include "../container/FIFO.h" +#include "../serialize/SerializeIF.h" class TcPacketStored; diff --git a/tmtcservices/PusServiceBase.cpp b/tmtcservices/PusServiceBase.cpp index 82e5ff5c..d35944a4 100644 --- a/tmtcservices/PusServiceBase.cpp +++ b/tmtcservices/PusServiceBase.cpp @@ -1,10 +1,10 @@ -#include -#include -#include -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../tcdistribution/PUSDistributorIF.h" +#include "AcceptsTelemetryIF.h" +#include "PusServiceBase.h" +#include "PusVerificationReport.h" +#include "TmTcMessage.h" +#include "../ipc/QueueFactory.h" object_id_t PusServiceBase::packetSource = 0; object_id_t PusServiceBase::packetDestination = 0; diff --git a/tmtcservices/PusServiceBase.h b/tmtcservices/PusServiceBase.h index 6d3d9bac..98d65efb 100644 --- a/tmtcservices/PusServiceBase.h +++ b/tmtcservices/PusServiceBase.h @@ -1,15 +1,15 @@ #ifndef FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_ #define FRAMEWORK_TMTCSERVICES_PUSSERVICEBASE_H_ -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "../objectmanager/SystemObject.h" +#include "../returnvalues/HasReturnvaluesIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../tmtcpacket/pus/TcPacketStored.h" +#include "AcceptsTelecommandsIF.h" +#include "VerificationCodes.h" +#include "VerificationReporter.h" +#include "../ipc/MessageQueueIF.h" namespace Factory{ void setStaticFrameworkObjectIds(); diff --git a/tmtcservices/PusVerificationReport.cpp b/tmtcservices/PusVerificationReport.cpp index 07631801..b047576b 100644 --- a/tmtcservices/PusVerificationReport.cpp +++ b/tmtcservices/PusVerificationReport.cpp @@ -1,5 +1,5 @@ -#include -#include +#include "../serialize/SerializeAdapter.h" +#include "PusVerificationReport.h" PusVerificationMessage::PusVerificationMessage() { } diff --git a/tmtcservices/PusVerificationReport.h b/tmtcservices/PusVerificationReport.h index ee84f0c1..b4739577 100644 --- a/tmtcservices/PusVerificationReport.h +++ b/tmtcservices/PusVerificationReport.h @@ -1,9 +1,9 @@ #ifndef PUSVERIFICATIONREPORT_H_ #define PUSVERIFICATIONREPORT_H_ -#include -#include -#include +#include "../ipc/MessageQueueMessage.h" +#include "../tmtcpacket/pus/TcPacketBase.h" +#include "VerificationCodes.h" class PusVerificationMessage: public MessageQueueMessage { private: diff --git a/tmtcservices/SourceSequenceCounter.h b/tmtcservices/SourceSequenceCounter.h index b92a5c84..1cc58758 100644 --- a/tmtcservices/SourceSequenceCounter.h +++ b/tmtcservices/SourceSequenceCounter.h @@ -7,7 +7,7 @@ #ifndef SOURCESEQUENCECOUNTER_H_ #define SOURCESEQUENCECOUNTER_H_ -#include +#include "../tmtcpacket/SpacePacketBase.h" class SourceSequenceCounter { private: diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp index b55803cb..021b0d7b 100644 --- a/tmtcservices/TmTcBridge.cpp +++ b/tmtcservices/TmTcBridge.cpp @@ -1,211 +1,211 @@ -#include - -#include -#include -#include -#include - -TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination, - object_id_t tmStoreId, object_id_t tcStoreId): - SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId), - tcDestination(tcDestination) - -{ - tmTcReceptionQueue = QueueFactory::instance()-> - createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH); -} - -TmTcBridge::~TmTcBridge() {} - -ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle( - uint8_t sentPacketsPerCycle) { - if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) { - this->sentPacketsPerCycle = sentPacketsPerCycle; - return RETURN_OK; - } - else { - sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of " - << "packets sent per cycle exceeds limits. " - << "Keeping default value." << std::endl; - return RETURN_FAILED; - } -} - -ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored( - uint8_t maxNumberOfPacketsStored) { - if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) { - this->maxNumberOfPacketsStored = maxNumberOfPacketsStored; - return RETURN_OK; - } - else { - sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of " - << "packets stored exceeds limits. " - << "Keeping default value." << std::endl; - return RETURN_FAILED; - } -} - -ReturnValue_t TmTcBridge::initialize() { - tcStore = objectManager->get(tcStoreId); - if (tcStore == nullptr) { - sif::error << "TmTcBridge::initialize: TC store invalid. Make sure" - "it is created and set up properly." << std::endl; - return ObjectManagerIF::CHILD_INIT_FAILED; - } - tmStore = objectManager->get(tmStoreId); - if (tmStore == nullptr) { - sif::error << "TmTcBridge::initialize: TM store invalid. Make sure" - "it is created and set up properly." << std::endl; - return ObjectManagerIF::CHILD_INIT_FAILED; - } - AcceptsTelecommandsIF* tcDistributor = - objectManager->get(tcDestination); - if (tcDistributor == nullptr) { - sif::error << "TmTcBridge::initialize: TC Distributor invalid" - << std::endl; - return ObjectManagerIF::CHILD_INIT_FAILED; - } - - tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue()); - return RETURN_OK; -} - -ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) { - ReturnValue_t result; - result = handleTc(); - if(result != RETURN_OK) { - sif::debug << "TmTcBridge::performOperation: " - << "Error handling TCs" << std::endl; - } - result = handleTm(); - if (result != RETURN_OK) { - sif::debug << "TmTcBridge::performOperation: " - << "Error handling TMs" << std::endl; - } - return result; -} - -ReturnValue_t TmTcBridge::handleTc() { - return HasReturnvaluesIF::RETURN_OK; -} - -ReturnValue_t TmTcBridge::handleTm() { - ReturnValue_t result = handleTmQueue(); - if(result != RETURN_OK) { - sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl; - return RETURN_FAILED; - } - - if(tmStored and communicationLinkUp) { - result = handleStoredTm(); - } - return result; - -} - -ReturnValue_t TmTcBridge::handleTmQueue() { - TmTcMessage message; +#include "TmTcBridge.h" + +#include "../ipc/QueueFactory.h" +#include "AcceptsTelecommandsIF.h" +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "../globalfunctions/arrayprinter.h" + +TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination, + object_id_t tmStoreId, object_id_t tcStoreId): + SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId), + tcDestination(tcDestination) + +{ + tmTcReceptionQueue = QueueFactory::instance()-> + createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH); +} + +TmTcBridge::~TmTcBridge() {} + +ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle( + uint8_t sentPacketsPerCycle) { + if(sentPacketsPerCycle <= LIMIT_STORED_DATA_SENT_PER_CYCLE) { + this->sentPacketsPerCycle = sentPacketsPerCycle; + return RETURN_OK; + } + else { + sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of " + << "packets sent per cycle exceeds limits. " + << "Keeping default value." << std::endl; + return RETURN_FAILED; + } +} + +ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored( + uint8_t maxNumberOfPacketsStored) { + if(maxNumberOfPacketsStored <= LIMIT_DOWNLINK_PACKETS_STORED) { + this->maxNumberOfPacketsStored = maxNumberOfPacketsStored; + return RETURN_OK; + } + else { + sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of " + << "packets stored exceeds limits. " + << "Keeping default value." << std::endl; + return RETURN_FAILED; + } +} + +ReturnValue_t TmTcBridge::initialize() { + tcStore = objectManager->get(tcStoreId); + if (tcStore == nullptr) { + sif::error << "TmTcBridge::initialize: TC store invalid. Make sure" + "it is created and set up properly." << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; + } + tmStore = objectManager->get(tmStoreId); + if (tmStore == nullptr) { + sif::error << "TmTcBridge::initialize: TM store invalid. Make sure" + "it is created and set up properly." << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; + } + AcceptsTelecommandsIF* tcDistributor = + objectManager->get(tcDestination); + if (tcDistributor == nullptr) { + sif::error << "TmTcBridge::initialize: TC Distributor invalid" + << std::endl; + return ObjectManagerIF::CHILD_INIT_FAILED; + } + + tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue()); + return RETURN_OK; +} + +ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) { + ReturnValue_t result; + result = handleTc(); + if(result != RETURN_OK) { + sif::debug << "TmTcBridge::performOperation: " + << "Error handling TCs" << std::endl; + } + result = handleTm(); + if (result != RETURN_OK) { + sif::debug << "TmTcBridge::performOperation: " + << "Error handling TMs" << std::endl; + } + return result; +} + +ReturnValue_t TmTcBridge::handleTc() { + return HasReturnvaluesIF::RETURN_OK; +} + +ReturnValue_t TmTcBridge::handleTm() { + ReturnValue_t result = handleTmQueue(); + if(result != RETURN_OK) { + sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl; + return RETURN_FAILED; + } + + if(tmStored and communicationLinkUp) { + result = handleStoredTm(); + } + return result; + +} + +ReturnValue_t TmTcBridge::handleTmQueue() { + TmTcMessage message; const uint8_t* data = nullptr; size_t size = 0; - for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message); - result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message)) - { - if(communicationLinkUp == false) { - result = storeDownlinkData(&message); - return result; - } - - result = tmStore->getData(message.getStorageId(), &data, &size); - if (result != HasReturnvaluesIF::RETURN_OK) { - continue; - } - - result = sendTm(data, size); - if (result != RETURN_OK) { - sif::warning << "TmTcBridge: Could not send TM packet" << std::endl; - tmStore->deleteData(message.getStorageId()); - return result; - - } - tmStore->deleteData(message.getStorageId()); - } - return RETURN_OK; -} - -ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) { - store_address_t storeId = 0; - - if(tmFifo.full()) { - sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number " - << "of stored packet IDs reached! " - << "Overwriting old data" << std::endl; - tmFifo.retrieve(&storeId); - tmStore->deleteData(storeId); - } - storeId = message->getStorageId(); - tmFifo.insert(storeId); - tmStored = true; - return RETURN_OK; -} - -ReturnValue_t TmTcBridge::handleStoredTm() { - uint8_t counter = 0; - ReturnValue_t result = RETURN_OK; - while(not tmFifo.empty() and counter < sentPacketsPerCycle) { - //info << "TMTC Bridge: Sending stored TM data. There are " - // << (int) fifo.size() << " left to send\r\n" << std::flush; - store_address_t storeId; + for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message); + result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message)) + { + if(communicationLinkUp == false) { + result = storeDownlinkData(&message); + return result; + } + + result = tmStore->getData(message.getStorageId(), &data, &size); + if (result != HasReturnvaluesIF::RETURN_OK) { + continue; + } + + result = sendTm(data, size); + if (result != RETURN_OK) { + sif::warning << "TmTcBridge: Could not send TM packet" << std::endl; + tmStore->deleteData(message.getStorageId()); + return result; + + } + tmStore->deleteData(message.getStorageId()); + } + return RETURN_OK; +} + +ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) { + store_address_t storeId = 0; + + if(tmFifo.full()) { + sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number " + << "of stored packet IDs reached! " + << "Overwriting old data" << std::endl; + tmFifo.retrieve(&storeId); + tmStore->deleteData(storeId); + } + storeId = message->getStorageId(); + tmFifo.insert(storeId); + tmStored = true; + return RETURN_OK; +} + +ReturnValue_t TmTcBridge::handleStoredTm() { + uint8_t counter = 0; + ReturnValue_t result = RETURN_OK; + while(not tmFifo.empty() and counter < sentPacketsPerCycle) { + //info << "TMTC Bridge: Sending stored TM data. There are " + // << (int) fifo.size() << " left to send\r\n" << std::flush; + store_address_t storeId; const uint8_t* data = nullptr; size_t size = 0; - tmFifo.retrieve(&storeId); - result = tmStore->getData(storeId, &data, &size); - - sendTm(data,size); - - if(result != RETURN_OK) { - sif::error << "TMTC Bridge: Could not send stored downlink data" - << std::endl; - result = RETURN_FAILED; - } - counter ++; - - if(tmFifo.empty()) { - tmStored = false; - } - tmStore->deleteData(storeId); - } - return result; -} - -void TmTcBridge::registerCommConnect() { - if(not communicationLinkUp) { - //info << "TMTC Bridge: Registered Comm Link Connect" << std::endl; - communicationLinkUp = true; - } -} - -void TmTcBridge::registerCommDisconnect() { - //info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl; - if(communicationLinkUp) { - communicationLinkUp = false; - } -} - -MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) { - return tmTcReceptionQueue->getId(); -} - - -void TmTcBridge::printData(uint8_t * data, size_t dataLen) { - arrayprinter::print(data, dataLen); -} - -uint16_t TmTcBridge::getIdentifier() { - // This is no PUS service, so we just return 0 - return 0; -} - -MessageQueueId_t TmTcBridge::getRequestQueue() { - // Default implementation: Relay TC messages to TC distributor directly. - return tmTcReceptionQueue->getDefaultDestination(); -} + tmFifo.retrieve(&storeId); + result = tmStore->getData(storeId, &data, &size); + + sendTm(data,size); + + if(result != RETURN_OK) { + sif::error << "TMTC Bridge: Could not send stored downlink data" + << std::endl; + result = RETURN_FAILED; + } + counter ++; + + if(tmFifo.empty()) { + tmStored = false; + } + tmStore->deleteData(storeId); + } + return result; +} + +void TmTcBridge::registerCommConnect() { + if(not communicationLinkUp) { + //info << "TMTC Bridge: Registered Comm Link Connect" << std::endl; + communicationLinkUp = true; + } +} + +void TmTcBridge::registerCommDisconnect() { + //info << "TMTC Bridge: Registered Comm Link Disconnect" << std::endl; + if(communicationLinkUp) { + communicationLinkUp = false; + } +} + +MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) { + return tmTcReceptionQueue->getId(); +} + + +void TmTcBridge::printData(uint8_t * data, size_t dataLen) { + arrayprinter::print(data, dataLen); +} + +uint16_t TmTcBridge::getIdentifier() { + // This is no PUS service, so we just return 0 + return 0; +} + +MessageQueueId_t TmTcBridge::getRequestQueue() { + // Default implementation: Relay TC messages to TC distributor directly. + return tmTcReceptionQueue->getDefaultDestination(); +} diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h index 993cd5b9..32eaf7f2 100644 --- a/tmtcservices/TmTcBridge.h +++ b/tmtcservices/TmTcBridge.h @@ -1,154 +1,154 @@ -#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ -#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ - -#include -#include -#include -#include -#include -#include - -#include -#include - -class TmTcBridge : public AcceptsTelemetryIF, - public AcceptsTelecommandsIF, - public ExecutableObjectIF, - public HasReturnvaluesIF, - public SystemObject { -public: - static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20; - static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15; - static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20; - - static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5; - static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10; - - TmTcBridge(object_id_t objectId, object_id_t tcDestination, - object_id_t tmStoreId, object_id_t tcStoreId); - virtual ~TmTcBridge(); - - /** - * Set number of packets sent per performOperation().Please note that this - * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE - * @param sentPacketsPerCycle - * @return -@c RETURN_OK if value was set successfully - * -@c RETURN_FAILED otherwise, stored value stays the same - */ - ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle); - - /** - * Set number of packets sent per performOperation().Please note that this - * value must be smaller than MAX_DOWNLINK_PACKETS_STORED - * @param sentPacketsPerCycle - * @return -@c RETURN_OK if value was set successfully - * -@c RETURN_FAILED otherwise, stored value stays the same - */ - ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored); - - virtual void registerCommConnect(); - virtual void registerCommDisconnect(); - - /** - * Initializes necessary FSFW components for the TMTC Bridge - * @return - */ - virtual ReturnValue_t initialize() override; - - /** - * @brief Handles TMTC reception - */ - virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; - - - /** AcceptsTelemetryIF override */ - virtual MessageQueueId_t getReportReceptionQueue( - uint8_t virtualChannel = 0) override; - - /** AcceptsTelecommandsIF override */ - virtual uint16_t getIdentifier() override; - virtual MessageQueueId_t getRequestQueue() override; - -protected: - //! Cached for initialize function. - object_id_t tmStoreId = objects::NO_OBJECT; - object_id_t tcStoreId = objects::NO_OBJECT; - object_id_t tcDestination = objects::NO_OBJECT; - - //! Used to send and receive TMTC messages. - //! The TmTcMessage class is used to transport messages between tasks. - MessageQueueIF* tmTcReceptionQueue = nullptr; - - StorageManagerIF* tmStore = nullptr; - StorageManagerIF* tcStore = nullptr; - - //! Used to specify whether communication link is up. Will be true - //! by default, so telemetry will be handled immediately. - bool communicationLinkUp = true; - bool tmStored = false; - - /** - * @brief Handle TC reception - * @details - * Default implementation provided, but is empty. - * In most cases, TC reception will be handled in a separate task anyway. - * @return - */ - virtual ReturnValue_t handleTc(); - - /** - * Handle Telemetry. Default implementation provided. - * Calls sendTm() - * @return - */ - virtual ReturnValue_t handleTm(); - - /** - * Read the TM Queue and send TM if necessary. - * Default implementation provided - * @return - */ - virtual ReturnValue_t handleTmQueue(); - - /** - * Send stored data if communication link is active - * @return - */ - virtual ReturnValue_t handleStoredTm(); - - /** - * Implemented by child class. Perform sending of Telemetry by implementing - * communication drivers or wrappers, e.g. serial communication or a socket - * call. - * @param data - * @param dataLen - * @return - */ - virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0; - - /** - * Store data to be sent later if communication link is not up. - * @param message - * @return - */ - virtual ReturnValue_t storeDownlinkData(TmTcMessage * message); - - - /** - * Print data as hexidecimal array - * @param data - * @param dataLen - */ - void printData(uint8_t * data, size_t dataLen); - - /** - * This fifo can be used to store downlink data - * which can not be sent at the moment. - */ - FIFO tmFifo; - uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE; - uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED; -}; - - -#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */ +#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ +#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ + +#include "../objectmanager/SystemObject.h" +#include "AcceptsTelemetryIF.h" +#include "../tasks/ExecutableObjectIF.h" +#include "../ipc/MessageQueueIF.h" +#include "../storagemanager/StorageManagerIF.h" +#include "AcceptsTelecommandsIF.h" + +#include "../container/FIFO.h" +#include "TmTcMessage.h" + +class TmTcBridge : public AcceptsTelemetryIF, + public AcceptsTelecommandsIF, + public ExecutableObjectIF, + public HasReturnvaluesIF, + public SystemObject { +public: + static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20; + static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15; + static constexpr uint8_t LIMIT_DOWNLINK_PACKETS_STORED = 20; + + static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5; + static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10; + + TmTcBridge(object_id_t objectId, object_id_t tcDestination, + object_id_t tmStoreId, object_id_t tcStoreId); + virtual ~TmTcBridge(); + + /** + * Set number of packets sent per performOperation().Please note that this + * value must be smaller than MAX_STORED_DATA_SENT_PER_CYCLE + * @param sentPacketsPerCycle + * @return -@c RETURN_OK if value was set successfully + * -@c RETURN_FAILED otherwise, stored value stays the same + */ + ReturnValue_t setNumberOfSentPacketsPerCycle(uint8_t sentPacketsPerCycle); + + /** + * Set number of packets sent per performOperation().Please note that this + * value must be smaller than MAX_DOWNLINK_PACKETS_STORED + * @param sentPacketsPerCycle + * @return -@c RETURN_OK if value was set successfully + * -@c RETURN_FAILED otherwise, stored value stays the same + */ + ReturnValue_t setMaxNumberOfPacketsStored(uint8_t maxNumberOfPacketsStored); + + virtual void registerCommConnect(); + virtual void registerCommDisconnect(); + + /** + * Initializes necessary FSFW components for the TMTC Bridge + * @return + */ + virtual ReturnValue_t initialize() override; + + /** + * @brief Handles TMTC reception + */ + virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; + + + /** AcceptsTelemetryIF override */ + virtual MessageQueueId_t getReportReceptionQueue( + uint8_t virtualChannel = 0) override; + + /** AcceptsTelecommandsIF override */ + virtual uint16_t getIdentifier() override; + virtual MessageQueueId_t getRequestQueue() override; + +protected: + //! Cached for initialize function. + object_id_t tmStoreId = objects::NO_OBJECT; + object_id_t tcStoreId = objects::NO_OBJECT; + object_id_t tcDestination = objects::NO_OBJECT; + + //! Used to send and receive TMTC messages. + //! The TmTcMessage class is used to transport messages between tasks. + MessageQueueIF* tmTcReceptionQueue = nullptr; + + StorageManagerIF* tmStore = nullptr; + StorageManagerIF* tcStore = nullptr; + + //! Used to specify whether communication link is up. Will be true + //! by default, so telemetry will be handled immediately. + bool communicationLinkUp = true; + bool tmStored = false; + + /** + * @brief Handle TC reception + * @details + * Default implementation provided, but is empty. + * In most cases, TC reception will be handled in a separate task anyway. + * @return + */ + virtual ReturnValue_t handleTc(); + + /** + * Handle Telemetry. Default implementation provided. + * Calls sendTm() + * @return + */ + virtual ReturnValue_t handleTm(); + + /** + * Read the TM Queue and send TM if necessary. + * Default implementation provided + * @return + */ + virtual ReturnValue_t handleTmQueue(); + + /** + * Send stored data if communication link is active + * @return + */ + virtual ReturnValue_t handleStoredTm(); + + /** + * Implemented by child class. Perform sending of Telemetry by implementing + * communication drivers or wrappers, e.g. serial communication or a socket + * call. + * @param data + * @param dataLen + * @return + */ + virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) = 0; + + /** + * Store data to be sent later if communication link is not up. + * @param message + * @return + */ + virtual ReturnValue_t storeDownlinkData(TmTcMessage * message); + + + /** + * Print data as hexidecimal array + * @param data + * @param dataLen + */ + void printData(uint8_t * data, size_t dataLen); + + /** + * This fifo can be used to store downlink data + * which can not be sent at the moment. + */ + FIFO tmFifo; + uint8_t sentPacketsPerCycle = DEFAULT_STORED_DATA_SENT_PER_CYCLE; + uint8_t maxNumberOfPacketsStored = DEFAULT_DOWNLINK_PACKETS_STORED; +}; + + +#endif /* FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ */ diff --git a/tmtcservices/TmTcMessage.cpp b/tmtcservices/TmTcMessage.cpp index d437b41e..987bd232 100644 --- a/tmtcservices/TmTcMessage.cpp +++ b/tmtcservices/TmTcMessage.cpp @@ -1,4 +1,4 @@ -#include +#include "TmTcMessage.h" #include diff --git a/tmtcservices/TmTcMessage.h b/tmtcservices/TmTcMessage.h index 73f741fb..b5e1ff8d 100644 --- a/tmtcservices/TmTcMessage.h +++ b/tmtcservices/TmTcMessage.h @@ -1,8 +1,8 @@ #ifndef TMTCMESSAGE_H_ #define TMTCMESSAGE_H_ -#include -#include +#include "../ipc/MessageQueueMessage.h" +#include "../storagemanager/StorageManagerIF.h" /** * @brief This message class is used to pass Telecommand and Telemetry * packets between tasks. diff --git a/tmtcservices/VerificationReporter.cpp b/tmtcservices/VerificationReporter.cpp index 4484fb9b..43e712a2 100644 --- a/tmtcservices/VerificationReporter.cpp +++ b/tmtcservices/VerificationReporter.cpp @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include "../serviceinterface/ServiceInterfaceStream.h" +#include "AcceptsVerifyMessageIF.h" +#include "PusVerificationReport.h" +#include "VerificationReporter.h" object_id_t VerificationReporter::messageReceiver = 0; diff --git a/tmtcservices/VerificationReporter.h b/tmtcservices/VerificationReporter.h index 370c44c8..29a273c5 100644 --- a/tmtcservices/VerificationReporter.h +++ b/tmtcservices/VerificationReporter.h @@ -1,8 +1,8 @@ #ifndef VERIFICATIONREPORTER_H_ #define VERIFICATIONREPORTER_H_ -#include -#include +#include "../objectmanager/ObjectManagerIF.h" +#include "PusVerificationReport.h" namespace Factory{ void setStaticFrameworkObjectIds(); From 9e0a90509629730ed1c5f316b6bdd4895dcba649 Mon Sep 17 00:00:00 2001 From: Steffen Gaisser Date: Thu, 13 Aug 2020 20:58:49 +0200 Subject: [PATCH 12/12] Two paths gone wrong --- pus/Service1TelecommandVerification.cpp | 2 +- pus/Service5EventReporting.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pus/Service1TelecommandVerification.cpp b/pus/Service1TelecommandVerification.cpp index 570005c5..578eb02d 100644 --- a/pus/Service1TelecommandVerification.cpp +++ b/pus/Service1TelecommandVerification.cpp @@ -3,7 +3,7 @@ #include "../ipc/QueueFactory.h" #include "../tmtcservices/PusVerificationReport.h" -#include "/tmtcpacketTmPacketStored.h" +#include "../tmtcpacket/pus/TmPacketStored.h" #include "../serviceinterface/ServiceInterfaceStream.h" #include "../tmtcservices/AcceptsTelemetryIF.h" #include "../serviceinterface/ServiceInterfaceStream.h" diff --git a/pus/Service5EventReporting.cpp b/pus/Service5EventReporting.cpp index 831f92c1..829d04bd 100644 --- a/pus/Service5EventReporting.cpp +++ b/pus/Service5EventReporting.cpp @@ -4,7 +4,7 @@ #include "../serviceinterface/ServiceInterfaceStream.h" #include "../events/EventManagerIF.h" #include "../ipc/QueueFactory.h" -#include "/tmtcpacketTmPacketStored.h" +#include "../tmtcpacket/pus/TmPacketStored.h" Service5EventReporting::Service5EventReporting(object_id_t objectId,