282 lines
9.7 KiB
C++
282 lines
9.7 KiB
C++
#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
|
|
#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
|
|
|
|
#include <fsfw/tmtcpacket/pus/tm/PusTmReader.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "fsfw/globalfunctions/timevalOperations.h"
|
|
#include "fsfw/serialize/SerialBufferAdapter.h"
|
|
#include "fsfw/serialize/SerialFixedArrayListAdapter.h"
|
|
#include "fsfw/serialize/SerialLinkedListAdapter.h"
|
|
#include "fsfw/serialize/SerializeElement.h"
|
|
#include "fsfw/timemanager/CCSDSTime.h"
|
|
#include "fsfw/timemanager/TimeWriterIF.h"
|
|
#include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
|
|
#include "tmStorageConf.h"
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
class ApidSsc : public SerializeIF {
|
|
public:
|
|
ApidSsc() : apid(ccsds::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 != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
return SerializeAdapter::serialize(&ssc, buffer, size, maxSize, streamEndianness);
|
|
}
|
|
|
|
size_t getSerializedSize() const { return sizeof(apid) + sizeof(ssc); }
|
|
|
|
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
|
|
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
return SerializeAdapter::deSerialize(&ssc, buffer, size, streamEndianness);
|
|
}
|
|
};
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
class TmPacketInformation : public SerializeIF {
|
|
public:
|
|
TmPacketInformation(PusTmReader* packet, size_t timestampLen) : rawTimestamp(timestampLen) {
|
|
setContent(packet);
|
|
}
|
|
TmPacketInformation(size_t timestampLen)
|
|
: apid(ccsds::LIMIT_APID),
|
|
sourceSequenceCount(0),
|
|
serviceType(0),
|
|
serviceSubtype(0),
|
|
subCounter(0),
|
|
rawTimestamp(timestampLen) {}
|
|
void reset() {
|
|
apid = ccsds::LIMIT_APID;
|
|
sourceSequenceCount = 0;
|
|
serviceType = 0;
|
|
serviceSubtype = 0;
|
|
subCounter = 0;
|
|
memset(rawTimestamp.data(), 0, rawTimestamp.size());
|
|
}
|
|
void setContent(PusTmReader* packet) {
|
|
apid = packet->getApid();
|
|
sourceSequenceCount = packet->getSequenceCount();
|
|
serviceType = packet->getService();
|
|
serviceSubtype = packet->getSubService();
|
|
subCounter = packet->getMessageTypeCounter();
|
|
memset(rawTimestamp.data(), 0, rawTimestamp.size());
|
|
// TODO: Fix all of this
|
|
// const uint8_t* pField = NULL;
|
|
// uint32_t size = 0;
|
|
// auto* timeReader = packet->getTimeReader();
|
|
// ReturnValue_t result = packet->getPacketTimeRaw(&pField, &size);
|
|
// if (result != returnvalue::OK) {
|
|
// return;
|
|
//}
|
|
// if (*pField == CCSDSTime::P_FIELD_CDS_SHORT && size <= TimeStamperIF::MISSION_TIMESTAMP_SIZE)
|
|
// {
|
|
// Shortcut to avoid converting CDS back and forth.
|
|
// TODO: Fix
|
|
// memcpy(rawTimestamp, pField, size);
|
|
// return;
|
|
// }
|
|
// timeval time = {0, 0};
|
|
// result = packet->getPacketTime(&time);
|
|
// if (result != returnvalue::OK) {
|
|
// return;
|
|
// }
|
|
//
|
|
// CCSDSTime::CDS_short cdsFormat;
|
|
// result = CCSDSTime::convertToCcsds(&cdsFormat, &time);
|
|
// if (result != returnvalue::OK) {
|
|
// return;
|
|
// }
|
|
// TODO: Fix
|
|
// memcpy(rawTimestamp, &cdsFormat, sizeof(cdsFormat));
|
|
}
|
|
void setContent(TmPacketInformation* content) {
|
|
apid = content->apid;
|
|
sourceSequenceCount = content->sourceSequenceCount;
|
|
serviceType = content->serviceType;
|
|
serviceSubtype = content->serviceSubtype;
|
|
subCounter = content->subCounter;
|
|
// TODO: Fix
|
|
// memcpy(rawTimestamp, content->rawTimestamp, sizeof(rawTimestamp));
|
|
}
|
|
bool isValid() const { return (apid < ccsds::LIMIT_APID) ? true : false; }
|
|
static void reset(TmPacketInformation* packet) { packet->reset(); }
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
uint16_t getApid() const { return apid; }
|
|
|
|
uint16_t getSsc() const { return sourceSequenceCount; }
|
|
|
|
uint8_t getServiceType() const { return serviceType; }
|
|
|
|
uint8_t getServiceSubtype() const { return serviceSubtype; }
|
|
|
|
uint8_t getSubCounter() const { return subCounter; }
|
|
|
|
timeval getTime() const {
|
|
timeval packetTime = {0, 0};
|
|
size_t foundlen = 0;
|
|
CCSDSTime::convertFromCcsds(&packetTime, &this->rawTimestamp[0], &foundlen,
|
|
sizeof(rawTimestamp));
|
|
return packetTime;
|
|
}
|
|
|
|
bool operator==(const TmPacketInformation& other) {
|
|
// TODO Does not compare Raw Timestamp
|
|
return ((apid == other.getApid()) && (sourceSequenceCount == other.getSsc()) &&
|
|
(serviceType == other.getServiceType()) &&
|
|
(serviceSubtype = other.getServiceSubtype()));
|
|
}
|
|
|
|
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 != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result =
|
|
SerializeAdapter::serialize(&sourceSequenceCount, buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::serialize(&serviceType, buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::serialize(&serviceSubtype, buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::serialize(&subCounter, buffer, size, maxSize, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
|
|
return adapter.serialize(buffer, size, maxSize, streamEndianness);
|
|
}
|
|
|
|
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.data(), rawTimestamp.size());
|
|
size += adapter.getSerializedSize();
|
|
return size;
|
|
};
|
|
|
|
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
|
|
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::deSerialize(&serviceType, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::deSerialize(&serviceSubtype, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = SerializeAdapter::deSerialize(&subCounter, buffer, size, streamEndianness);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
SerialBufferAdapter<uint8_t> adapter(rawTimestamp.data(), rawTimestamp.size());
|
|
return adapter.deSerialize(buffer, size, streamEndianness);
|
|
}
|
|
|
|
private:
|
|
uint16_t apid;
|
|
uint16_t sourceSequenceCount;
|
|
uint8_t serviceType;
|
|
uint8_t serviceSubtype;
|
|
uint8_t subCounter;
|
|
std::vector<uint8_t> rawTimestamp;
|
|
};
|
|
#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */
|