From 771adb37431e446f8aebbc75becdfa9c4145a42e Mon Sep 17 00:00:00 2001 From: "Jakob.Meier" Date: Thu, 17 Dec 2020 13:26:00 +0100 Subject: [PATCH] p60 dock handler completed --- bsp_linux/comIF/CspComIF.cpp | 22 +++-- bsp_linux/comIF/CspComIF.h | 10 +- mission/devices/P60DockHandler.cpp | 40 ++++++-- mission/devices/P60DockHandler.h | 2 + .../devicedefinitions/GomSpacePackets.h | 93 ++++++------------- 5 files changed, 91 insertions(+), 76 deletions(-) diff --git a/bsp_linux/comIF/CspComIF.cpp b/bsp_linux/comIF/CspComIF.cpp index afebeb83..77b52c1e 100644 --- a/bsp_linux/comIF/CspComIF.cpp +++ b/bsp_linux/comIF/CspComIF.cpp @@ -86,7 +86,8 @@ ReturnValue_t CspComIF::sendMessage(CookieIF *cookie, SerializeAdapter::deSerialize(&querySize, &sendData, &sendLen, SerializeIF::Endianness::BIG); uint8_t cspAddress = cspCookie->getCspAddress(); - if(cspPort == csp_reserved_ports_e::CSP_PING){ + switch(cspPort) { + case(Ports::CSP_PING): { uint32_t timeout = 1000; // ms unsigned int pingSize = 100; // 100 bytes uint32_t replyTime = csp_ping(cspAddress, timeout, pingSize, @@ -96,11 +97,15 @@ ReturnValue_t CspComIF::sendMessage(CookieIF *cookie, /* Store reply time in reply buffer * */ uint8_t* replyBuffer = cspDeviceMap[cspAddress].data(); memcpy(replyBuffer, &replyTime, sizeof(replyTime)); + replySize = sizeof(replyTime); + break; } - else if(cspPort == csp_reserved_ports_e::CSP_REBOOT){ - csp_reboot(cspCookie->getCspAddress()); + case(Ports::CSP_REBOOT): { + csp_reboot(cspAddress); + break; } - else{ + case(Ports::P60_PORT_GNDWDT_RESET): + case(Ports::P60_PORT_RPARAM): { /* No CSP fixed port was selected. Send data to the specified port and * wait for querySize number of bytes */ result = cspTransfer(cspAddress, cspPort, sendData, sendLen, @@ -108,7 +113,12 @@ ReturnValue_t CspComIF::sendMessage(CookieIF *cookie, if(result != HasReturnvaluesIF::RETURN_OK){ return HasReturnvaluesIF::RETURN_FAILED; } - rememberQuerySize = querySize; + replySize = querySize; + break; + } + default: + sif::error << "CspComIF: Invalid port specified" << std::endl; + break; } return HasReturnvaluesIF::RETURN_OK; } @@ -135,7 +145,7 @@ ReturnValue_t CspComIF::readReceivedMessage(CookieIF *cookie, uint8_t cspAddress = cspCookie->getCspAddress(); *buffer = cspDeviceMap[cspAddress].data(); - *size = rememberQuerySize; + *size = replySize; return HasReturnvaluesIF::RETURN_OK; } diff --git a/bsp_linux/comIF/CspComIF.h b/bsp_linux/comIF/CspComIF.h index 4fb24226..fd4057a8 100644 --- a/bsp_linux/comIF/CspComIF.h +++ b/bsp_linux/comIF/CspComIF.h @@ -46,6 +46,14 @@ private: ReturnValue_t cspTransfer(uint8_t cspAddress, uint8_t cspPort, const uint8_t* cmdBuffer, int cmdBufferLen, uint16_t querySize); + enum Ports { + CSP_PING = 1, + CSP_REBOOT = 4, + P60_PORT_RPARAM = 7, + P60_PORT_GNDWDT_RESET = 9 + }; + + typedef uint8_t node_t; using vectorBuffer = std::vector; using VectorBufferMap = std::unordered_map; @@ -54,7 +62,7 @@ private: /* In this map assigns reply buffers to a CSP device */ VectorBufferMap cspDeviceMap; - uint16_t rememberQuerySize = 0; + uint16_t replySize = 0; /* This is the CSP address of the OBC. */ node_t cspClientAddress = 1; diff --git a/mission/devices/P60DockHandler.cpp b/mission/devices/P60DockHandler.cpp index cf584039..c6cff969 100644 --- a/mission/devices/P60DockHandler.cpp +++ b/mission/devices/P60DockHandler.cpp @@ -34,10 +34,9 @@ ReturnValue_t P60DockHandler::buildCommandFromCommand( size_t commandDataLen) { switch(deviceCommand) { case(PING): { - PingMessageUnpacker pingMessageUnpacker(commandData, commandDataLen); - const uint8_t* pingData = pingMessageUnpacker.getPingData(); - uint8_t pingDataSz = pingMessageUnpacker.getPingDataSz(); - CspPingCommand cspPingCommand(pingDataSz, pingData); + const uint8_t* pingData = commandData; + uint8_t pingDataSz = commandDataLen; + CspPingCommand cspPingCommand(pingData, pingDataSz); size_t cspPacketLen = 0; uint8_t* buffer = cspPacket; cspPingCommand.serialize(&buffer, &cspPacketLen, sizeof(cspPacket), @@ -52,6 +51,16 @@ ReturnValue_t P60DockHandler::buildCommandFromCommand( rememberCommandId = PING; break; } + case(REBOOT): { + uint8_t cspPort = GOMSPACE::REBOOT_PORT; + uint16_t querySize = 0; + *cspPacket = GOMSPACE::REBOOT_PORT; + *(cspPacket + 1) = querySize; + size_t cspPacketLen = sizeof(cspPort) + sizeof(cspPacketLen); + rawPacket = cspPacket; + rawPacketLen = cspPacketLen; + break; + } case(PARAM_SET):{ SetParamMessageUnpacker setParamMessageUnpacker(commandData, commandDataLen); @@ -112,6 +121,23 @@ ReturnValue_t P60DockHandler::buildCommandFromCommand( rememberCommandId = PARAM_GET; break; } + case(GNDWDT_RESET): { + WatchdogResetCommand watchdogResetCommand; + size_t cspPacketLen = 0; + uint8_t* buffer = cspPacket; + watchdogResetCommand.serialize(&buffer, &cspPacketLen, sizeof(cspPacket), + SerializeIF::Endianness::BIG); + if(cspPacketLen > MAX_PACKET_LEN){ + sif::error << "P60DockHandler: Received invalid ground watchdog" + "reset command" << std::endl; + return HasReturnvaluesIF::RETURN_FAILED; + } + rawPacket = cspPacket; + rawPacketLen = cspPacketLen; + rememberRequestedSize = 0; // No bytes will be queried with the ground + // watchdog command. + rememberCommandId = GNDWDT_RESET; + } default: break; } @@ -120,8 +146,10 @@ ReturnValue_t P60DockHandler::buildCommandFromCommand( void P60DockHandler::fillCommandAndReplyMap(){ this->insertInCommandAndReplyMap(PING, 3); + this->insertInCommandMap(REBOOT); this->insertInCommandAndReplyMap(PARAM_SET, 3); this->insertInCommandAndReplyMap(PARAM_GET, 3); + this->insertInCommandMap(GNDWDT_RESET); } ReturnValue_t P60DockHandler::scanForReply(const uint8_t *start, @@ -154,8 +182,8 @@ ReturnValue_t P60DockHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) { switch(id) { case(PING): { - PingReply pingReply(*packet, *(packet + 1)); - handleDeviceTM(&pingReply, id, true, true); + SerializeElement replyTime = *packet; + handleDeviceTM(&replyTime, id, true); break; } case(PARAM_GET): { diff --git a/mission/devices/P60DockHandler.h b/mission/devices/P60DockHandler.h index 3c4cb3bb..8f3a2f77 100644 --- a/mission/devices/P60DockHandler.h +++ b/mission/devices/P60DockHandler.h @@ -39,6 +39,8 @@ private: /* Device commands are derived from the rparam.h of the gomspace lib */ static const DeviceCommandId_t PING = 0x1; //!< [EXPORT] : [COMMAND] static const DeviceCommandId_t NONE = 0x2; // Set when no command is pending + static const DeviceCommandId_t REBOOT = 0x4; //!< [EXPORT] : [COMMAND] + static const DeviceCommandId_t GNDWDT_RESET = 0x9; //!< [EXPORT] : [COMMAND] static const DeviceCommandId_t PARAM_GET = 0x00; //!< [EXPORT] : [COMMAND] static const DeviceCommandId_t PARAM_SET = 0xFF; //!< [EXPORT] : [COMMAND] diff --git a/mission/devices/devicedefinitions/GomSpacePackets.h b/mission/devices/devicedefinitions/GomSpacePackets.h index 88977a86..e41ea162 100644 --- a/mission/devices/devicedefinitions/GomSpacePackets.h +++ b/mission/devices/devicedefinitions/GomSpacePackets.h @@ -12,8 +12,35 @@ namespace GOMSPACE{ static const uint8_t REBOOT_PORT = 4; /* CSP port of gomspace devices to request or set parameters */ static const uint8_t PARAM_PORT = 7; + static const uint8_t P60_PORT_GNDWDT_RESET = 9; } + +/** + * @brief This class can be used to generated the command for the CspComIF + * to reset the watchdog in a gomspace device. + */ +class WatchdogResetCommand : public SerialLinkedListAdapter { +public: + + WatchdogResetCommand() { + setLinks(); + } + +private: + WatchdogResetCommand(const WatchdogResetCommand &command); + void setLinks() { + setStart(&cspPort); + cspPort.setNext(&querySize); + querySize.setNext(&magic); + } + SerializeElement cspPort = GOMSPACE::P60_PORT_GNDWDT_RESET; + SerializeElement querySize = 1; + /* Sending 0x78 to port 9 of a gomspace device resets the ground watchdog */ + SerializeElement magic = 0x78; +}; + + /** * @brief A serial linked list adapter implementation to generate ping * commands for devices supporting the CSP protocol. This command can @@ -31,11 +58,11 @@ public: * * @param querySize_ The size of bytes replied by the ping request. * Amounts to the number of bytes send. - * @param parameters_ Pointer to data which should be sent to the device. + * @param data_ Pointer to data which should be sent to the device. * All data will be sent back by the ping target. */ - CspPingCommand(uint16_t querySize_, const uint8_t* parameters_) : - querySize(querySize_), data(parameters_, querySize_) { + CspPingCommand(const uint8_t* data_, uint16_t querySize_) : + querySize(querySize_), data(data_, querySize_) { setLinks(); } @@ -256,29 +283,6 @@ private: SerializeElement> payload; }; - -/** - * @brief This class generates telemetry packets containing data from - * CSP get-parameter-replies. - */ -class PingReply : public SerialLinkedListAdapter { -public: - PingReply(uint8_t action_, uint8_t replyTime_) : - action(action_), replyTime(replyTime_) { - setLinks(); - } - -private: - PingReply(const PingReply &reply); - void setLinks() { - setStart(&action); - action.setNext(&replyTime); - } - SerializeElement action; - SerializeElement replyTime; -}; - - /** * @brief This class helps to unpack information from an action messages * to set a parameter in gomspace devices. The action message can be @@ -360,41 +364,4 @@ private: uint8_t parameterSize; }; - -/** - * @brief This class helps to extract the information of a message received - * from an other software component (e.g. the service 8) to generate - * a ping request for gomspace devices. - */ -class PingMessageUnpacker: public SerialLinkedListAdapter { -public: - - PingMessageUnpacker(const uint8_t* commandData, size_t commandDataLen) { - SerializeAdapter::deSerialize(&action, &commandData, &commandDataLen, - SerializeIF::Endianness::BIG); - pingData = commandData; - pingDataSz = commandDataLen; - } - - uint8_t getAction() const { - return action; - } - - const uint8_t* getPingData() { - return pingData; - } - - uint8_t getPingDataSz(){ - return pingDataSz; - } - - -private: - PingMessageUnpacker(const PingMessageUnpacker &message); - uint8_t action; - const uint8_t * pingData; - uint8_t pingDataSz; -}; - - #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */