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

456 lines
15 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/SerialFixedArrayListAdapter.h>
2022-01-17 15:58:27 +01:00
#include <fsfw/serialize/SerialLinkedListAdapter.h>
#include <fsfw/serialize/SerializeElement.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> {
2022-01-17 15:58:27 +01:00
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-17 13:26:00 +01:00
};
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> {
2022-01-17 15:58:27 +01:00
public:
/**
* @brief Constructor
*
* @param querySize_ The size of bytes replied by the ping request.
* Amounts to the number of bytes send.
* @param data_ Pointer to data which should be sent to the device.
* All data will be sent back by the ping target.
*/
CspPingCommand(const uint8_t *data_, uint16_t querySize_)
: querySize(querySize_), data(data_, querySize_) {
setLinks();
}
private:
CspPingCommand(const CspPingCommand &command);
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;
2020-12-14 08:42:48 +01:00
};
/**
* @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> {
2022-01-17 15:58:27 +01:00
public:
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(total_),
addr(addr_),
parameter(parameter_, parameterCount_) {
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);
checksum.setNext(&seq);
seq.setNext(&total);
total.setNext(&addr);
addr.setNext(&parameter);
}
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;
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;
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> {
2022-01-17 15:58:27 +01:00
public:
/* The size of the header of a gomspace CSP packet. */
static const uint8_t GS_HDR_LENGTH = 12;
CspGetParamCommand(uint16_t querySize_, uint8_t tableId_, uint16_t addresslength_,
uint16_t checksum_, uint16_t seq_, uint16_t total_, uint16_t addr_)
: querySize(querySize_),
tableId(tableId_),
addresslength(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*/
SerializeElement<uint8_t> action = 0x00; // get param
SerializeElement<uint8_t> tableId;
SerializeElement<uint16_t> addresslength;
SerializeElement<uint16_t> checksum;
SerializeElement<uint16_t> seq;
SerializeElement<uint16_t> total;
SerializeElement<uint16_t> addr;
2020-12-14 08:42:48 +01:00
};
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> {
2022-01-17 15:58:27 +01:00
public:
RequestFullTableCommand(uint16_t querySize_, uint8_t tableId_)
: 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;
2021-01-28 14:55:21 +01:00
};
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> {
2022-01-17 15:58:27 +01:00
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);
addr.setNext(&payload);
}
SerializeElement<uint8_t> action;
SerializeElement<uint8_t> tableId;
SerializeElement<uint16_t> length; // length of address field + payload data
SerializeElement<uint16_t> checksum;
SerializeElement<uint16_t> seq;
SerializeElement<uint16_t> total;
SerializeElement<uint16_t> addr;
SerializeElement<SerialBufferAdapter<uint8_t>> payload;
2020-12-14 08:42:48 +01:00
};
/**
* @brief This class generates telemetry packets containing data from
* CSP get-parameter-replies.
*/
class ParamReply : public SerialLinkedListAdapter<SerializeIF> {
2022-01-17 15:58:27 +01:00
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) {
setLinks();
}
private:
ParamReply(const CspGetParamReply &reply);
void setLinks() {
setStart(&action);
action.setNext(&tableId);
tableId.setNext(&addr);
addr.setNext(&payloadLength);
payloadLength.setNext(&payload);
}
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
/**
2022-01-17 15:58:27 +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> {
2022-01-17 15:58:27 +01:00
public:
/**
* @brief Constructor
*
* @param action_ The command which triggered the full table request.
* @param tableId_ The id of the requested table.
* @param tableDataset_ The dataset holding the table data.
*/
Pdu2FullTableReply(uint8_t action_, uint8_t tableId_, SerializeIF *tableDataset_)
: action(action_), tableId(tableId_), dataset(tableDataset_) {
setLinks();
}
private:
Pdu2FullTableReply(const Pdu2FullTableReply &reply);
void setLinks() {
setStart(&action);
action.setNext(&tableId);
tableId.setNext(&dataset);
}
SerializeElement<uint8_t> action;
SerializeElement<uint8_t> tableId;
LinkedElement<SerializeIF> dataset;
2021-01-28 14:55:21 +01:00
};
2022-08-24 17:19:14 +02:00
class SetParamMessageCache {
public:
SetParamMessageCache() : address(0), parameter(0), parameterSize(1) {}
2022-08-24 17:19:14 +02:00
void set(uint16_t address, uint32_t parameter, uint8_t parameterSize) {
this->address = address;
this->parameter = parameter;
this->parameterSize = parameterSize;
}
uint16_t getAddress() { return address; }
uint32_t getParameter() { return parameter; }
uint8_t getParameterSize() { return parameterSize; }
private:
uint16_t address;
uint32_t parameter;
uint8_t parameterSize;
};
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
* to set a parameter in gomspace devices. The action message can be
* for example received from the PUS Service 8.
2020-12-14 08:42:48 +01:00
*/
2022-08-24 17:19:14 +02:00
/*
2022-01-17 15:58:27 +01:00
class SetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
public:
2022-08-24 17:19:14 +02:00
// Largest parameter is a uint32_t
2022-01-17 15:58:27 +01:00
static const uint32_t MAX_SIZE = 4;
SetParamMessageUnpacker() { setLinks(); }
2020-12-14 08:42:48 +01:00
2022-01-17 15:58:27 +01:00
uint16_t getAddress() { return address; }
uint8_t *getParameter() { return parameter->front(); }
uint8_t getParameterSize() { return parameter->size; }
private:
void setLinks() {
setStart(&address);
address.setNext(&parameter);
}
SetParamMessageUnpacker(const SetParamMessageUnpacker &message);
SerializeElement<uint16_t> address;
SerializeElement<SerialFixedArrayListAdapter<uint8_t, MAX_SIZE, uint8_t>> parameter;
2022-08-24 17:19:14 +02:00
};*/
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> {
2022-01-17 15:58:27 +01:00
public:
/* The size of the largest parameter */
static const uint8_t MAX_SIZE = 4;
/**
* @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.
*
*/
GomspaceSetParamMessage(uint16_t memoryAddress, const uint8_t *parameterValue,
uint8_t parameterSize)
: memoryAddress(memoryAddress), parameterValueBuffer(parameterValue, parameterSize, true) {
setLinks();
}
private:
GomspaceSetParamMessage(const GomspaceSetParamMessage &reply);
void setLinks() {
setStart(&memoryAddress);
memoryAddress.setNext(&parameterValueBuffer);
}
SerializeElement<uint16_t> memoryAddress;
/**
* 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.
*/
2022-08-24 17:19:14 +02:00
/*
2022-01-17 15:58:27 +01:00
class GetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
public:
GetParamMessageUnpacker() { setLinks(); }
uint8_t getTableId() { return tableId; }
uint16_t getAddress() { return address; }
uint8_t getParameterSize() { return parameterSize; }
private:
GetParamMessageUnpacker(const GetParamMessageUnpacker &message);
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
2022-08-24 17:19:14 +02:00
// The size of the requested value (e.g. temperature is a uint16_t value)
2022-01-17 15:58:27 +01:00
SerializeElement<uint8_t> parameterSize;
2022-08-24 17:19:14 +02:00
};*/
2020-12-14 08:42:48 +01:00
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */