eive-obsw/mission/devices/devicedefinitions/GomSpacePackets.h

467 lines
14 KiB
C
Raw Normal View History

2020-12-14 08:42:48 +01:00
#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_
#define MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_
2020-12-29 14:39:03 +01:00
#include <fsfw/serialize/SerialBufferAdapter.h>
#include <fsfw/serialize/SerializeElement.h>
#include <fsfw/serialize/SerialLinkedListAdapter.h>
#include <fsfw/serialize/SerialFixedArrayListAdapter.h>
2021-01-28 14:55:21 +01:00
#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
2020-12-14 08:42:48 +01:00
2020-12-17 13:26:00 +01:00
/**
* @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<SerializeIF> {
public:
WatchdogResetCommand() {
setLinks();
}
private:
WatchdogResetCommand(const WatchdogResetCommand &command);
void setLinks() {
setStart(&cspPort);
cspPort.setNext(&querySize);
querySize.setNext(&magic);
}
SerializeElement<uint8_t> cspPort = GOMSPACE::P60_PORT_GNDWDT_RESET;
SerializeElement<uint16_t> querySize = 1;
/* Sending 0x78 to port 9 of a gomspace device resets the ground watchdog */
SerializeElement<uint8_t> magic = 0x78;
};
2020-12-14 08:42:48 +01:00
/**
* @brief A serial linked list adapter implementation to generate ping
2020-12-16 15:17:10 +01:00
* commands for devices supporting the CSP protocol. This command can
* be sent to the CspComIF which will send out the ping request.
2020-12-14 08:42:48 +01:00
*
* @details A ping request simply sends back the received data provided by the
* data buffer. cspPort and querySize are only informations required
* by the CspComI and other than the data array not physically
* transmitted to the target device.
*/
2020-12-16 15:17:10 +01:00
class CspPingCommand : public SerialLinkedListAdapter<SerializeIF> {
2020-12-14 08:42:48 +01:00
public:
/**
* @brief Constructor
*
* @param querySize_ The size of bytes replied by the ping request.
* Amounts to the number of bytes send.
2020-12-17 13:26:00 +01:00
* @param data_ Pointer to data which should be sent to the device.
2020-12-14 08:42:48 +01:00
* All data will be sent back by the ping target.
*/
2020-12-17 13:26:00 +01:00
CspPingCommand(const uint8_t* data_, uint16_t querySize_) :
querySize(querySize_), data(data_, querySize_) {
2020-12-14 08:42:48 +01:00
setLinks();
}
private:
2020-12-16 15:17:10 +01:00
CspPingCommand(const CspPingCommand &command);
2020-12-14 08:42:48 +01:00
void setLinks() {
setStart(&cspPort);
cspPort.setNext(&querySize);
querySize.setNext(&data);
}
SerializeElement<uint8_t> cspPort = GOMSPACE::PING_PORT;
SerializeElement<uint16_t> querySize;
SerializeElement<SerialBufferAdapter<uint8_t>> data;
};
/**
* @brief A serial linked list adapter implementation of the gs_rparam_query_t
* struct defined in rparam.h. Can be used to build the message to set
* a parameter in gomspace devices.
*
* @note cspPort and querySize will not be sent with the CSP packet to the
* gomspace device but are required for the CspComIF to get the port
* and the size to query.
*/
class CspSetParamCommand : public SerialLinkedListAdapter<SerializeIF> {
public:
2020-12-20 13:31:44 +01:00
CspSetParamCommand(uint16_t querySize_, uint16_t payloadlength_,
uint16_t checksum_, uint16_t seq_, uint16_t total_, uint16_t addr_,
const uint8_t* parameter_, uint8_t parameterCount_) :
querySize(querySize_), payloadlength(
payloadlength_), checksum(checksum_), seq(seq_), total(
2020-12-20 13:31:44 +01:00
total_), addr(addr_), parameter(parameter_, parameterCount_) {
2020-12-14 08:42:48 +01:00
setLinks();
}
private:
CspSetParamCommand(const CspSetParamCommand &command);
void setLinks() {
setStart(&cspPort);
cspPort.setNext(&querySize);
querySize.setNext(&action);
action.setNext(&tableId);
tableId.setNext(&payloadlength);
payloadlength.setNext(&checksum);
2020-12-14 08:42:48 +01:00
checksum.setNext(&seq);
seq.setNext(&total);
total.setNext(&addr);
addr.setNext(&parameter);
2020-12-14 08:42:48 +01:00
}
SerializeElement<uint8_t> cspPort = GOMSPACE::PARAM_PORT;
/* Only a parameter will be set. No data will be queried with this command */
SerializeElement<uint16_t> querySize;
2020-12-20 13:31:44 +01:00
SerializeElement<uint8_t> action = 0xFF; // param set
/* We will never set a parameter in a table other than the configuration
* table */
SerializeElement<uint8_t> tableId = 1;
SerializeElement<uint16_t> payloadlength;
2020-12-14 08:42:48 +01:00
SerializeElement<uint16_t> checksum;
SerializeElement<uint16_t> seq;
SerializeElement<uint16_t> total;
SerializeElement<uint16_t> addr;
SerializeElement<SerialBufferAdapter<uint8_t>> parameter;
2020-12-14 08:42:48 +01:00
};
/**
* @brief This class can be used to generate a get param command for the
* gomspace devices which will be sent to the device communication
* interface object.
*
* @note cspPort and querySize only serve as information for the CspComIF
* and will not be transmitted physically to the target device.
*/
class CspGetParamCommand : public SerialLinkedListAdapter<SerializeIF> {
public:
2020-12-14 09:46:59 +01:00
/* The size of the header of a gomspace CSP packet. */
static const uint8_t GS_HDR_LENGTH = 12;
2020-12-14 08:42:48 +01:00
2020-12-20 13:31:44 +01:00
CspGetParamCommand(uint16_t querySize_, uint8_t tableId_,
2020-12-14 08:42:48 +01:00
uint16_t addresslength_, uint16_t checksum_, uint16_t seq_,
uint16_t total_, uint16_t addr_) :
2020-12-20 13:31:44 +01:00
querySize(querySize_), tableId(tableId_), addresslength(
2020-12-14 08:42:48 +01:00
addresslength_), checksum(checksum_), seq(seq_), total(
total_), addr(addr_) {
fixedValuesInit();
setLinks();
}
private:
CspGetParamCommand(const CspGetParamCommand &command);
void setLinks() {
setStart(&cspPort);
cspPort.setNext(&querySize);
querySize.setNext(&action);
action.setNext(&tableId);
tableId.setNext(&addresslength);
addresslength.setNext(&checksum);
checksum.setNext(&seq);
seq.setNext(&total);
total.setNext(&addr);
}
void fixedValuesInit(){
cspPort.entry = GOMSPACE::PARAM_PORT;
}
SerializeElement<uint8_t> cspPort;
SerializeElement<uint16_t> querySize; // size of bytes to query
/* Following information will also be physically transmitted to the target
* device*/
2020-12-20 13:31:44 +01:00
SerializeElement<uint8_t> action = 0x00; // get param
2020-12-14 08:42:48 +01:00
SerializeElement<uint8_t> tableId;
2021-01-23 17:22:40 +01:00
SerializeElement<uint16_t> addresslength;
2020-12-14 08:42:48 +01:00
SerializeElement<uint16_t> checksum;
SerializeElement<uint16_t> seq;
SerializeElement<uint16_t> total;
SerializeElement<uint16_t> addr;
};
2021-01-28 14:55:21 +01:00
/**
* @brief This class can be used to generate a get param command for the
* gomspace devices which will be sent to the device communication
* interface object.
*
* @note cspPort and querySize only serve as information for the CspComIF
* and will not be transmitted physically to the target device.
*/
class RequestFullTableCommand : public SerialLinkedListAdapter<SerializeIF> {
public:
RequestFullTableCommand(uint16_t querySize_, uint8_t tableId_) :
2021-01-28 14:55:21 +01:00
querySize(querySize_), tableId(tableId_) {
setLinks();
}
private:
RequestFullTableCommand(const RequestFullTableCommand &command);
void setLinks() {
setStart(&cspPort);
cspPort.setNext(&querySize);
querySize.setNext(&action);
action.setNext(&tableId);
tableId.setNext(&addresslength);
addresslength.setNext(&checksum);
checksum.setNext(&seq);
seq.setNext(&total);
}
SerializeElement<uint8_t> cspPort = GOMSPACE::PARAM_PORT;
/** Size of bytes to query (size of csp header + size of table) */
SerializeElement<uint16_t> querySize;
/* Following information will also be physically transmitted to the target
* device*/
SerializeElement<uint8_t> action = 0x00; // get param
SerializeElement<uint8_t> tableId;
/* Size of address. Set to 0 to get full table */
SerializeElement<uint16_t> addresslength = 0;
SerializeElement<uint16_t> checksum = GOMSPACE::IGNORE_CHECKSUM;
SerializeElement<uint16_t> seq = 0;
SerializeElement<uint16_t> total = 0;
};
2020-12-14 08:42:48 +01:00
/**
* @brief This class can be used to deserialize replies from gomspace devices
* and extract the relevant data.
*/
class CspGetParamReply : public SerialLinkedListAdapter<SerializeIF> {
public:
/**
* @brief Constructor
*
* @param payloadBuffer Pointer to a buffer to store the payload data of
* the CSP packet.
* @param payloadBufferSz The size of the payload buffer where the payload
* data will be stored.
*/
CspGetParamReply(uint8_t* payloadBuffer_, uint8_t payloadBufferSz_) :
payload(payloadBuffer_, payloadBufferSz_) {
setLinks();
}
uint8_t getAction(){
return action;
}
uint8_t getTableId(){
return tableId;
}
uint16_t getLength(){
return length;
}
uint16_t getAddress(){
return addr;
}
private:
CspGetParamReply(const CspGetParamReply &reply);
void setLinks() {
setStart(&action);
action.setNext(&tableId);
tableId.setNext(&length);
length.setNext(&checksum);
checksum.setNext(&seq);
seq.setNext(&total);
total.setNext(&addr);
2020-12-14 08:42:48 +01:00
addr.setNext(&payload);
}
SerializeElement<uint8_t> action;
SerializeElement<uint8_t> tableId;
SerializeElement<uint16_t> length; //length of address field + payload data
2020-12-14 08:42:48 +01:00
SerializeElement<uint16_t> checksum;
SerializeElement<uint16_t> seq;
SerializeElement<uint16_t> total;
SerializeElement<uint16_t> addr;
SerializeElement<SerialBufferAdapter<uint8_t>> payload;
};
/**
* @brief This class generates telemetry packets containing data from
* CSP get-parameter-replies.
*/
class ParamReply : public SerialLinkedListAdapter<SerializeIF> {
public:
/**
* @brief Constructor
*
* @param payloadBuffer Pointer to a buffer to store the payload data of
* the CSP packet.
* @param payloadBufferSz The size of the payload buffer where the payload
* data will be stored.
*/
ParamReply(uint8_t action_, uint8_t tableId_, uint16_t addr_,
uint16_t payloadLength_, uint8_t* payloadBuffer_) :
action(action_), tableId(tableId_), addr(addr_), payloadLength(
payloadLength_), payload(payloadBuffer_, payloadLength) {
2020-12-14 08:42:48 +01:00
setLinks();
}
private:
ParamReply(const CspGetParamReply &reply);
void setLinks() {
setStart(&action);
action.setNext(&tableId);
tableId.setNext(&addr);
addr.setNext(&payloadLength);
payloadLength.setNext(&payload);
2020-12-14 08:42:48 +01:00
}
SerializeElement<uint8_t> action;
SerializeElement<uint8_t> tableId;
SerializeElement<uint16_t> addr;
SerializeElement<uint16_t> payloadLength;
SerializeElement<SerialBufferAdapter<uint16_t>> payload;
2020-12-14 08:42:48 +01:00
};
2021-01-28 14:55:21 +01:00
/**
2021-02-06 11:57:45 +01:00
* @brief This class generates the reply containing data from a full housekeeping table request
* of the PDU2.
2021-01-28 14:55:21 +01:00
*/
2021-02-06 11:57:45 +01:00
class Pdu2FullTableReply : public SerialLinkedListAdapter<SerializeIF> {
2021-01-28 14:55:21 +01:00
public:
/**
* @brief Constructor
*
2021-02-06 11:57:45 +01:00
* @param action_ The command which triggered the full table request.
2021-01-28 14:55:21 +01:00
* @param tableId_ The id of the requested table.
2021-02-06 11:57:45 +01:00
* @param tableDataset_ The dataset holding the table data.
2021-01-28 14:55:21 +01:00
*/
2021-02-08 11:48:58 +01:00
Pdu2FullTableReply(uint8_t action_, uint8_t tableId_, SerializeIF* tableDataset_) :
action(action_), tableId(tableId_), dataset(tableDataset_) {
2021-01-28 14:55:21 +01:00
setLinks();
}
private:
2021-02-06 11:57:45 +01:00
Pdu2FullTableReply(const Pdu2FullTableReply &reply);
2021-01-28 14:55:21 +01:00
void setLinks() {
setStart(&action);
action.setNext(&tableId);
2021-02-08 11:48:58 +01:00
tableId.setNext(&dataset);
2021-01-28 14:55:21 +01:00
}
SerializeElement<uint8_t> action;
SerializeElement<uint8_t> tableId;
2021-02-08 11:48:58 +01:00
LinkedElement<SerializeIF> dataset;
2021-01-28 14:55:21 +01:00
};
2020-12-14 08:42:48 +01:00
/**
2020-12-20 13:31:44 +01:00
* @brief This class helps to unpack information from an action message
2020-12-14 08:42:48 +01:00
* to set a parameter in gomspace devices. The action message can be
* for example received from the PUS Service 8.
*/
class SetParamMessageUnpacker: public SerialLinkedListAdapter<SerializeIF> {
public:
2020-12-20 13:31:44 +01:00
/* Largest parameter is a uint32_t */
static const uint32_t MAX_SIZE = 4;
2020-12-14 08:42:48 +01:00
2020-12-20 13:31:44 +01:00
SetParamMessageUnpacker() {
setLinks();
2020-12-14 08:42:48 +01:00
}
2020-12-20 13:31:44 +01:00
uint16_t getAddress() {
2020-12-14 08:42:48 +01:00
return address;
}
2020-12-20 13:31:44 +01:00
uint8_t* getParameter() {
return parameter->front();
2020-12-14 08:42:48 +01:00
}
uint8_t getParameterSize(){
2020-12-20 13:31:44 +01:00
return parameter->size;
2020-12-14 08:42:48 +01:00
}
private:
2020-12-20 13:31:44 +01:00
void setLinks() {
setStart(&address);
address.setNext(&parameter);
}
2020-12-14 08:42:48 +01:00
SetParamMessageUnpacker(const SetParamMessageUnpacker &message);
2020-12-20 13:31:44 +01:00
SerializeElement<uint16_t> address;
SerializeElement<SerialFixedArrayListAdapter<uint8_t, MAX_SIZE, uint8_t>> parameter;
2020-12-14 08:42:48 +01:00
};
2021-01-28 14:55:21 +01:00
/**
* @brief This class generates a message which can be sent to the GomspaceDeviceHandler to
* command a parameter change.
*
* @details Structure of set parameter command:
* | memory address | size of parameter value | parameter value |
*/
class GomspaceSetParamMessage : public SerialLinkedListAdapter<SerializeIF> {
public:
/* The size of the largest parameter */
2021-02-11 08:19:48 +01:00
static const uint8_t MAX_SIZE = 4;
2021-01-28 14:55:21 +01:00
/**
* @brief Constructor
*
* @param memoryAddress The address of the parameter to change in the configuration table.
* @param parameterValue Pointer to the parameter value to set.
* @param parameterSize The size of the parameter.
*
*/
2021-02-11 08:19:48 +01:00
GomspaceSetParamMessage(uint16_t memoryAddress, const uint8_t* parameterValue,
uint8_t parameterSize) :
2021-02-11 08:19:48 +01:00
memoryAddress(memoryAddress), parameterValueBuffer(parameterValue, parameterSize, true) {
2021-01-28 14:55:21 +01:00
setLinks();
}
private:
2021-02-06 11:57:45 +01:00
GomspaceSetParamMessage(const GomspaceSetParamMessage &reply);
2021-01-28 14:55:21 +01:00
void setLinks() {
setStart(&memoryAddress);
2021-02-11 08:19:48 +01:00
memoryAddress.setNext(&parameterValueBuffer);
2021-01-28 14:55:21 +01:00
}
SerializeElement<uint16_t> memoryAddress;
2021-02-11 08:19:48 +01:00
/**
* Parameter can be uint8_t, uint16_t or uint32_t. Thus max size of parameterValueBuffer is
* four bytes.
*/
SerializeElement<SerialBufferAdapter<uint8_t>> parameterValueBuffer;
2021-01-28 14:55:21 +01:00
};
2020-12-14 08:42:48 +01:00
/**
* @brief This class helps to unpack information from an action message
* to get a parameter from gomspace devices. The action message can be
* for example received from the PUS Service 8.
*/
class GetParamMessageUnpacker: public SerialLinkedListAdapter<SerializeIF> {
public:
2020-12-20 13:31:44 +01:00
GetParamMessageUnpacker() {
setLinks();
2020-12-14 08:42:48 +01:00
}
2020-12-20 13:31:44 +01:00
uint8_t getTableId() {
2020-12-14 08:42:48 +01:00
return tableId;
}
2020-12-20 13:31:44 +01:00
uint16_t getAddress() {
2020-12-14 08:42:48 +01:00
return address;
}
uint8_t getParameterSize(){
return parameterSize;
2020-12-14 08:42:48 +01:00
}
private:
GetParamMessageUnpacker(const GetParamMessageUnpacker &message);
2020-12-20 13:31:44 +01:00
void setLinks() {
setStart(&tableId);
tableId.setNext(&address);
address.setNext(&parameterSize);
}
SerializeElement<uint8_t> tableId;
SerializeElement<uint16_t> address; //The memory address offset within the table
/* The size of the requested value (e.g. temperature is a uint16_t value) */
2020-12-20 13:31:44 +01:00
SerializeElement<uint8_t> parameterSize;
2020-12-14 08:42:48 +01:00
};
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */