304 lines
8.9 KiB
C++
304 lines
8.9 KiB
C++
#ifndef FSFW_TMSTORAGE_TMSTOREPACKETS_H_
|
|
#define FSFW_TMSTORAGE_TMSTOREPACKETS_H_
|
|
|
|
#include "../serialize/SerialFixedArrayListAdapter.h"
|
|
#include "../serialize/SerializeElement.h"
|
|
#include "../serialize/SerialLinkedListAdapter.h"
|
|
#include "../serialize/SerialBufferAdapter.h"
|
|
#include "../tmtcpacket/pus/tm/TmPacketMinimal.h"
|
|
#include "../timemanager/TimeStamperIF.h"
|
|
#include "../timemanager/CCSDSTime.h"
|
|
#include "../globalfunctions/timevalOperations.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(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);
|
|
|
|
}
|
|
|
|
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 != HasReturnvaluesIF::RETURN_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(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;
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
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!=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);
|
|
}
|
|
|
|
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;
|
|
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
private:
|
|
uint16_t apid;
|
|
uint16_t sourceSequenceCount;
|
|
uint8_t serviceType;
|
|
uint8_t serviceSubtype;
|
|
uint8_t subCounter;
|
|
uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
|
|
|
|
};
|
|
#endif /* FSFW_TMSTORAGE_TMSTOREPACKETS_H_ */
|