456 lines
15 KiB
C++
456 lines
15 KiB
C++
#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_
|
|
#define MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_
|
|
|
|
#include <fsfw/serialize/SerialBufferAdapter.h>
|
|
#include <fsfw/serialize/SerialFixedArrayListAdapter.h>
|
|
#include <fsfw/serialize/SerialLinkedListAdapter.h>
|
|
#include <fsfw/serialize/SerializeElement.h>
|
|
#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
|
|
|
|
/**
|
|
* @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;
|
|
};
|
|
|
|
/**
|
|
* @brief A serial linked list adapter implementation to generate ping
|
|
* commands for devices supporting the CSP protocol. This command can
|
|
* be sent to the CspComIF which will send out the ping request.
|
|
*
|
|
* @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.
|
|
*/
|
|
class CspPingCommand : public SerialLinkedListAdapter<SerializeIF> {
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @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:
|
|
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(¶meter);
|
|
}
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @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:
|
|
/* 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;
|
|
};
|
|
|
|
/**
|
|
* @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_)
|
|
: 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;
|
|
};
|
|
|
|
/**
|
|
* @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);
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @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) {
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @brief This class generates the reply containing data from a full housekeeping table
|
|
* request of the PDU2.
|
|
*/
|
|
class Pdu2FullTableReply : public SerialLinkedListAdapter<SerializeIF> {
|
|
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;
|
|
};
|
|
|
|
class SetParamMessageCache {
|
|
public:
|
|
SetParamMessageCache() : address(0), parameter(0), parameterSize(1) {}
|
|
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/*
|
|
class SetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
|
|
public:
|
|
// Largest parameter is a uint32_t
|
|
static const uint32_t MAX_SIZE = 4;
|
|
|
|
SetParamMessageUnpacker() { setLinks(); }
|
|
|
|
uint16_t getAddress() { return address; }
|
|
|
|
uint8_t *getParameter() { return parameter->front(); }
|
|
|
|
uint8_t getParameterSize() { return parameter->size; }
|
|
|
|
private:
|
|
void setLinks() {
|
|
setStart(&address);
|
|
address.setNext(¶meter);
|
|
}
|
|
SetParamMessageUnpacker(const SetParamMessageUnpacker &message);
|
|
SerializeElement<uint16_t> address;
|
|
SerializeElement<SerialFixedArrayListAdapter<uint8_t, MAX_SIZE, uint8_t>> parameter;
|
|
};*/
|
|
|
|
/**
|
|
* @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 */
|
|
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(¶meterValueBuffer);
|
|
}
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* @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:
|
|
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(¶meterSize);
|
|
}
|
|
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)
|
|
SerializeElement<uint8_t> parameterSize;
|
|
};*/
|
|
|
|
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */
|