fsfw/src/fsfw/tmstorage/TmStorePackets.h

269 lines
9.5 KiB
C
Raw Normal View History

2020-12-22 15:58:52 +01:00
#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
2022-02-02 10:29:30 +01:00
#include "fsfw/globalfunctions/timevalOperations.h"
#include "fsfw/serialize/SerialBufferAdapter.h"
2021-07-19 18:26:54 +02:00
#include "fsfw/serialize/SerialFixedArrayListAdapter.h"
#include "fsfw/serialize/SerialLinkedListAdapter.h"
2022-02-02 10:29:30 +01:00
#include "fsfw/serialize/SerializeElement.h"
2021-07-19 18:26:54 +02:00
#include "fsfw/timemanager/CCSDSTime.h"
2022-02-02 10:29:30 +01:00
#include "fsfw/timemanager/TimeStamperIF.h"
#include "fsfw/tmtcpacket/pus/tm/TmPacketMinimal.h"
#include "tmStorageConf.h"
2022-02-02 10:29:30 +01:00
class ServiceSubservice : public SerialLinkedListAdapter<SerializeIF> {
public:
SerializeElement<uint8_t> service;
SerialFixedArrayListAdapter<uint8_t, 16> subservices;
LinkedElement<SerializeIF> linkedSubservices;
ServiceSubservice()
: SerialLinkedListAdapter<SerializeIF>(&service), linkedSubservices(&subservices) {
service.setNext(&linkedSubservices);
}
};
2022-02-02 10:29:30 +01:00
class ApidSsc : public SerializeIF {
public:
ApidSsc() : apid(SpacePacketBase::LIMIT_APID), ssc(0) {}
ApidSsc(uint16_t apid, uint16_t ssc) : apid(apid), ssc(ssc) {}
uint16_t apid;
uint16_t ssc;
ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
Endianness streamEndianness) const {
ReturnValue_t result =
SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::serialize(&ssc, buffer, size, maxSize, streamEndianness);
}
2022-02-02 10:29:30 +01:00
size_t getSerializedSize() const { return sizeof(apid) + sizeof(ssc); }
2022-02-02 10:29:30 +01:00
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::deSerialize(&ssc, buffer, size, streamEndianness);
}
};
2022-02-02 10:29:30 +01:00
class ChangeSelectionDefinition : public SerialLinkedListAdapter<SerializeIF> {
public:
SerializeElement<uint16_t> apid;
SerialFixedArrayListAdapter<ServiceSubservice, 16> serviceList;
LinkedElement<SerializeIF> linkedServiceList;
ChangeSelectionDefinition()
: SerialLinkedListAdapter<SerializeIF>(&apid), linkedServiceList(&serviceList) {
apid.setNext(&linkedServiceList);
}
};
2022-02-02 10:29:30 +01:00
class TmPacketInformation : public SerializeIF {
public:
TmPacketInformation(TmPacketMinimal* packet) { setContent(packet); }
TmPacketInformation()
: apid(SpacePacketBase::LIMIT_APID),
sourceSequenceCount(0),
serviceType(0),
serviceSubtype(0),
subCounter(0) {}
void reset() {
apid = SpacePacketBase::LIMIT_APID;
sourceSequenceCount = 0;
serviceType = 0;
serviceSubtype = 0;
subCounter = 0;
memset(rawTimestamp, 0, sizeof(rawTimestamp));
}
void setContent(TmPacketMinimal* packet) {
apid = packet->getAPID();
sourceSequenceCount = packet->getPacketSequenceCount();
serviceType = packet->getService();
serviceSubtype = packet->getSubService();
subCounter = packet->getPacketSubcounter();
memset(rawTimestamp, 0, sizeof(rawTimestamp));
const uint8_t* pField = NULL;
uint32_t size = 0;
ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
if (*pField == CCSDSTime::P_FIELD_CDS_SHORT && size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE) {
// Shortcut to avoid converting CDS back and forth.
memcpy(rawTimestamp, pField, size);
return;
}
timeval time = {0, 0};
result = packet->getPacketTime(&time);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
2022-02-02 10:29:30 +01:00
CCSDSTime::CDS_short cdsFormat;
result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
}
void setContent(TmPacketInformation* content) {
apid = content->apid;
sourceSequenceCount = content->sourceSequenceCount;
serviceType = content->serviceType;
serviceSubtype = content->serviceSubtype;
subCounter = content->subCounter;
memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
}
bool isValid() const { return (apid < SpacePacketBase::LIMIT_APID) ? true : false; }
static void reset(TmPacketInformation* packet) { packet->reset(); }
2022-02-02 10:29:30 +01:00
static bool isOlderThan(const TmPacketInformation* packet, const timeval* cmpTime) {
if (packet->isValid()) {
timeval packetTime = {0, 0};
size_t foundlen = 0;
CCSDSTime::convertFromCcsds(&packetTime, &packet->rawTimestamp[0], &foundlen,
sizeof(rawTimestamp));
if (packetTime <= *cmpTime) {
return true;
}
}
return false;
}
2022-02-02 10:29:30 +01:00
static bool isNewerThan(const TmPacketInformation* packet, const timeval* cmpTime) {
if (packet->isValid()) {
timeval packetTime = {0, 0};
size_t foundlen = 0;
CCSDSTime::convertFromCcsds(&packetTime, &packet->rawTimestamp[0], &foundlen,
sizeof(rawTimestamp));
if (packetTime >= *cmpTime) {
return true;
}
}
return false;
}
2022-02-02 10:29:30 +01:00
static bool isSmallerSSC(const TmPacketInformation* packet, const ApidSsc* compareSSC) {
if (packet->isValid()) {
if (packet->apid == compareSSC->apid) {
if (packet->sourceSequenceCount <= compareSSC->ssc) {
return true;
}
}
}
return false;
}
2022-02-02 10:29:30 +01:00
static bool isLargerSSC(const TmPacketInformation* packet, const ApidSsc* compareSSC) {
if (packet->isValid()) {
if (packet->apid == compareSSC->apid) {
if (packet->sourceSequenceCount >= compareSSC->ssc) {
return true;
}
}
}
return false;
}
2022-02-02 10:29:30 +01:00
uint16_t getApid() const { return apid; }
2022-02-02 10:29:30 +01:00
uint16_t getSsc() const { return sourceSequenceCount; }
2022-02-02 10:29:30 +01:00
uint8_t getServiceType() const { return serviceType; }
2022-02-02 10:29:30 +01:00
uint8_t getServiceSubtype() const { return serviceSubtype; }
2022-02-02 10:29:30 +01:00
uint8_t getSubCounter() const { return subCounter; }
2022-02-02 10:29:30 +01:00
timeval getTime() const {
timeval packetTime = {0, 0};
size_t foundlen = 0;
CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0], &foundlen,
sizeof(rawTimestamp));
return packetTime;
}
2022-02-02 10:29:30 +01:00
bool operator==(const TmPacketInformation& other) {
// TODO Does not compare Raw Timestamp
return ((apid == other.getApid()) && (sourceSequenceCount == other.getSsc()) &&
(serviceType == other.getServiceType()) &&
(serviceSubtype = other.getServiceSubtype()));
}
2022-02-02 10:29:30 +01:00
ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
Endianness streamEndianness) const {
ReturnValue_t result =
SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result =
SerializeAdapter::serialize(&sourceSequenceCount, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&serviceType, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&serviceSubtype, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::serialize(&subCounter, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
return adapter.serialize(buffer, size, maxSize, streamEndianness);
}
2022-02-02 10:29:30 +01:00
size_t getSerializedSize() const {
uint32_t size = 0;
size += SerializeAdapter::getSerializedSize(&apid);
size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
size += SerializeAdapter::getSerializedSize(&serviceType);
size += SerializeAdapter::getSerializedSize(&serviceSubtype);
size += SerializeAdapter::getSerializedSize(&subCounter);
SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
size += adapter.getSerializedSize();
return size;
};
2022-02-02 10:29:30 +01:00
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&serviceType, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&serviceSubtype, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter::deSerialize(&subCounter, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
SerialBufferAdapter<uint8_t> adapter(rawTimestamp, sizeof(rawTimestamp));
return adapter.deSerialize(buffer, size, streamEndianness);
}
2022-02-02 10:29:30 +01:00
private:
uint16_t apid;
uint16_t sourceSequenceCount;
uint8_t serviceType;
uint8_t serviceSubtype;
uint8_t subCounter;
uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
};
2020-12-22 15:58:52 +01:00
#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */