EIVE Cleanroom
664670573a
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
222 lines
9.2 KiB
C++
222 lines
9.2 KiB
C++
#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
|
|
#define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
|
|
|
|
#include <string>
|
|
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
|
|
#include "fsfw_hal/linux/uart/UartComIF.h"
|
|
#include "fsfw/ipc/QueueFactory.h"
|
|
#include "fsfw/tmtcservices/SourceSequenceCounter.h"
|
|
#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
|
|
#include "PlocMPSoCHelper.h"
|
|
|
|
/**
|
|
* @brief This is the device handler for the MPSoC of the payload computer.
|
|
*
|
|
* @details The PLOC uses the space packet protocol for communication. On each command the PLOC
|
|
* answers with at least one acknowledgment and one execution report.
|
|
* Flight manual: https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC
|
|
* ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263
|
|
*
|
|
* @note The sequence count in the space packets must be incremented with each received and sent
|
|
* packet.
|
|
*
|
|
* @author J. Meier
|
|
*/
|
|
class PlocMPSoCHandler: public DeviceHandlerBase {
|
|
public:
|
|
|
|
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HANDLER;
|
|
|
|
//! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC
|
|
static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
|
|
//! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC
|
|
static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
|
|
//! [EXPORT] : [COMMENT] Received execution failure reply from PLOC
|
|
static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
|
|
//! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC
|
|
static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
|
|
//! [EXPORT] : [COMMENT] Received command with invalid length
|
|
static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4);
|
|
//! [EXPORT] : [COMMENT] Received command with invalid filename
|
|
static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5);
|
|
//! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command
|
|
static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6);
|
|
|
|
PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie,
|
|
PlocMPSoCHelper* plocMPSoCHelper);
|
|
virtual ~PlocMPSoCHandler();
|
|
virtual ReturnValue_t initialize() override;
|
|
ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
|
const uint8_t* data, size_t size) override;
|
|
void performOperationHook() override;
|
|
|
|
protected:
|
|
void doStartUp() override;
|
|
void doShutDown() override;
|
|
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
|
|
ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) override;
|
|
void fillCommandAndReplyMap() override;
|
|
ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
|
|
const uint8_t * commandData,size_t commandDataLen) override;
|
|
ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
|
|
DeviceCommandId_t *foundId, size_t *foundLen) override;
|
|
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
|
|
const uint8_t *packet) override;
|
|
void setNormalDatapoolEntriesInvalid() override;
|
|
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
|
|
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
|
LocalDataPoolManager& poolManager) override;
|
|
ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator command,
|
|
uint8_t expectedReplies = 1, bool useAlternateId = false,
|
|
DeviceCommandId_t alternateReplyID = 0) override;
|
|
size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
|
|
|
|
private:
|
|
|
|
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
|
|
|
|
//! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
|
|
static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
|
|
//! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report
|
|
static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
|
|
//! [EXPORT] : [COMMENT] PLOC receive execution failure report
|
|
static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
|
|
//! [EXPORT] : [COMMENT] PLOC reply has invalid crc
|
|
static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
|
|
//! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected count
|
|
//! P1: Expected sequence count
|
|
//! P2: Received sequence count
|
|
static const Event MPSOC_HANDLER_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
|
|
|
|
//! [EXPORT] : [COMMENT] Received command has file string with invalid length
|
|
static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xD0);
|
|
|
|
static const uint16_t APID_MASK = 0x7FF;
|
|
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
|
|
|
|
MessageQueueIF* eventQueue = nullptr;
|
|
|
|
SourceSequenceCounter sequenceCount;
|
|
|
|
uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
|
|
|
|
/**
|
|
* This variable is used to store the id of the next reply to receive. This is necessary
|
|
* because the PLOC sends as reply to each command at least one acknowledgment and execution
|
|
* report.
|
|
*/
|
|
DeviceCommandId_t nextReplyId = mpsoc::NONE;
|
|
|
|
UartComIF* uartComIf = nullptr;
|
|
|
|
PlocMPSoCHelper* plocMPSoCHelper = nullptr;
|
|
|
|
// Used to block incoming commands when MPSoC helper class is currently executing a command
|
|
bool plocMPSoCHelperExecuting = false;
|
|
|
|
class TmMemReadReport {
|
|
public:
|
|
static const uint8_t FIX_SIZE = 14;
|
|
size_t rememberRequestedSize = 0;
|
|
};
|
|
|
|
TmMemReadReport tmMemReadReport;
|
|
|
|
/**
|
|
* @brief Handles events received from the PLOC MPSoC helper
|
|
*/
|
|
void handleEvent(EventMessage* eventMessage);
|
|
|
|
ReturnValue_t prepareTcMemWrite(const uint8_t * commandData, size_t commandDataLen);
|
|
ReturnValue_t prepareTcMemRead(const uint8_t * commandData, size_t commandDataLen);
|
|
ReturnValue_t prepareTcFlashDelete(const uint8_t * commandData, size_t commandDataLen);
|
|
ReturnValue_t prepareTcReplayStart(const uint8_t * commandData, size_t commandDataLen);
|
|
// ReturnValue_t prepareTcReplayStop(const uint8_t * commandData, size_t commandDataLen);
|
|
// ReturnValue_t prepareTcDownlinkPwrOff(const uint8_t * commandData, size_t commandDataLen);
|
|
// ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t * commandData, size_t commandDataLen);
|
|
|
|
/**
|
|
* @brief Copies space packet into command buffer
|
|
*/
|
|
void copyToCommandBuffer(mpsoc::TcBase* tc);
|
|
|
|
/**
|
|
* @brief This function checks the crc of the received PLOC reply.
|
|
*
|
|
* @param start Pointer to the first byte of the reply.
|
|
* @param foundLen Pointer to the length of the whole packet.
|
|
*
|
|
* @return RETURN_OK if CRC is ok, otherwise CRC_FAILURE.
|
|
*/
|
|
ReturnValue_t verifyPacket(const uint8_t* start, size_t foundLen);
|
|
|
|
/**
|
|
* @brief This function handles the acknowledgment report.
|
|
*
|
|
* @param data Pointer to the data holding the acknowledgment report.
|
|
*
|
|
* @return RETURN_OK if successful, otherwise an error code.
|
|
*/
|
|
ReturnValue_t handleAckReport(const uint8_t* data);
|
|
|
|
/**
|
|
* @brief This function handles the data of a execution report.
|
|
*
|
|
* @param data Pointer to the received data packet.
|
|
*
|
|
* @return RETURN_OK if successful, otherwise an error code.
|
|
*/
|
|
ReturnValue_t handleExecutionReport(const uint8_t* data);
|
|
|
|
/**
|
|
* @brief This function handles the memory read report.
|
|
*
|
|
* @param data Pointer to the data buffer holding the memory read report.
|
|
*
|
|
* @return RETURN_OK if successful, otherwise an error code.
|
|
*/
|
|
ReturnValue_t handleMemoryReadReport(const uint8_t* data);
|
|
|
|
/**
|
|
* @brief Depending on the current active command, this function sets the reply id of the
|
|
* next reply after a successful acknowledgment report has been received. This is
|
|
* required by the function getNextReplyLength() to identify the length of the next
|
|
* reply to read.
|
|
*/
|
|
void setNextReplyId();
|
|
|
|
/**
|
|
* @brief This function handles action message replies in case the telemetry has been
|
|
* requested by another object.
|
|
*
|
|
* @param data Pointer to the telemetry data.
|
|
* @param dataSize Size of telemetry in bytes.
|
|
* @param replyId Id of the reply. This will be added to the ActionMessage.
|
|
*/
|
|
void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
|
|
|
|
/**
|
|
* @brief In case an acknowledgment failure reply has been received this function disables
|
|
* all previously enabled commands and resets the exepected replies variable of an
|
|
* active command.
|
|
*/
|
|
void disableAllReplies();
|
|
|
|
/**
|
|
* @brief This function sends a failure report if the active action was commanded by an other
|
|
* object.
|
|
*
|
|
* @param replyId The id of the reply which signals a failure.
|
|
* @param status A status byte which gives information about the failure type.
|
|
*/
|
|
void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);
|
|
|
|
/**
|
|
* @brief This function disables the execution report reply. Within this function also the
|
|
* the variable expectedReplies of an active command will be set to 0.
|
|
*/
|
|
void disableExeReportReply();
|
|
};
|
|
|
|
#endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */
|