fsfw/fsfw
fsfw/fsfw
10
3
Fork 6
Code Issues 31 Pull Requests 4 Releases 10 Wiki Activity

serialize changes. #35

Closed
muellerr wants to merge 21 commits from KSat:mueller_Serialization into master
pull from: KSat:mueller_Serialization
merge into: fsfw:master
Conversation 4 Commits 21 Files Changed 50 +78 -69
22 changed files with 78 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 83080cd4e3 - Show all commits

6
devicehandlers/DeviceTmReportingWrapper.cpp
View File

@ -12,7 +12,7 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
}
ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) const {
size_t* size, const size_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<object_id_t>::serialize(&objectId,
buffer, size, max_size, bigEndian);
if (result != HasReturnvaluesIF::RETURN_OK) {
@ -26,12 +26,12 @@ ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
return data->serialize(buffer, size, max_size, bigEndian);
}
uint32_t DeviceTmReportingWrapper::getSerializedSize() const {
size_t DeviceTmReportingWrapper::getSerializedSize() const {
return sizeof(objectId) + sizeof(ActionId_t) + data->getSerializedSize();
}
ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) {
size_t* size, bool bigEndian) {
ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
buffer, size, bigEndian);
if (result != HasReturnvaluesIF::RETURN_OK) {

7
events/eventmatching/EventRangeMatcherBase.h
View File

@ -11,15 +11,16 @@ class EventRangeMatcherBase: public SerializeableMatcherIF<EventMessage*> {
public:
EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) { }
virtual ~EventRangeMatcherBase() { }
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const {
const size_t max_size, bool bigEndian) const override {
return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
}
size_t getSerializedSize() const {
size_t getSerializedSize() const override {
return rangeMatcher.getSerializedSize();
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
bool bigEndian) override {
return rangeMatcher.deSerialize(buffer, size, bigEndian);
}
protected:

8
globalfunctions/Type.cpp
View File

@ -59,8 +59,8 @@ uint8_t Type::getSize() const {
}
}
ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
uint8_t ptc;
uint8_t pfc;
ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@ -81,12 +81,12 @@ ReturnValue_t Type::serialize(uint8_t** buffer, uint32_t* size,
}
uint32_t Type::getSerializedSize() const {
size_t Type::getSerializedSize() const {
uint8_t dontcare = 0;
return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
}
ReturnValue_t Type::deSerialize(const uint8_t** buffer, int32_t* size,
ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
uint8_t ptc;
uint8_t pfc;

4
health/HealthTable.cpp
View File

@ -63,9 +63,9 @@ bool HealthTable::hasHealth(object_id_t object) {
return exits;
}
void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) {
void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
mutex->lockMutex(MutexIF::NO_TIMEOUT);
uint32_t size = 0;
size_t size = 0;
uint16_t count = healthMap.size();
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
&pointer, &size, maxSize, true);

2
health/HealthTable.h
View File

@ -21,7 +21,7 @@ public:
virtual HasHealthIF::HealthState getHealth(object_id_t);
virtual uint32_t getPrintSize();
virtual void printAll(uint8_t *pointer, uint32_t maxSize);
virtual void printAll(uint8_t *pointer, size_t maxSize);
protected:
MutexIF* mutex;

2
health/HealthTableIF.h
View File

@ -17,7 +17,7 @@ public:
HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
virtual uint32_t getPrintSize() = 0;
virtual void printAll(uint8_t *pointer, uint32_t maxSize) = 0;
virtual void printAll(uint8_t *pointer, size_t maxSize) = 0;
protected:
virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;

2
monitoring/LimitViolationReporter.cpp
View File

@ -26,7 +26,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
uint32_t size = 0;
size_t size = 0;
result = data->serialize(&dataTarget, &size, maxSize, true);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;

2
parameters/ParameterHelper.cpp
View File

@ -94,7 +94,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
return result;
}
uint32_t storeElementSize = 0;
size_t storeElementSize = 0;
result = description->serialize(&storeElement, &storeElementSize,
serializedSize, true);

6
parameters/ParameterWrapper.cpp
View File

@ -77,8 +77,8 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
return result;
}
uint32_t ParameterWrapper::getSerializedSize() const {
uint32_t serializedSize = 0;
size_t ParameterWrapper::getSerializedSize() const {
size_t serializedSize = 0;
serializedSize += type.getSerializedSize();
serializedSize += sizeof(rows);
serializedSize += sizeof(columns);
@ -112,7 +112,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
//treat from as a continuous Stream as we copy all of it
const uint8_t *fromAsStream = (const uint8_t *) from;
int32_t streamSize = fromRows * fromColumns * sizeof(T);
size_t streamSize = fromRows * fromColumns * sizeof(T);
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;

8
power/Fuse.cpp
View File

@ -86,8 +86,8 @@ ReturnValue_t Fuse::check() {
return result;
}
ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
@ -99,7 +99,7 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, uint32_t* size,
return RETURN_OK;
}
uint32_t Fuse::getSerializedSize() const {
size_t Fuse::getSerializedSize() const {
uint32_t size = 0;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
@ -108,7 +108,7 @@ uint32_t Fuse::getSerializedSize() const {
return size;
}
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, int32_t* size,
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();

15
power/Fuse.h
View File

@ -18,7 +18,8 @@ void setStaticFrameworkObjectIds();
class Fuse: public SystemObject,
public HasHealthIF,
public HasReturnvaluesIF,
public ReceivesParameterMessagesIF {
public ReceivesParameterMessagesIF,
public SerializeIF {
friend void (Factory::setStaticFrameworkObjectIds)();
private:
static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
@ -49,11 +50,13 @@ public:
uint8_t getFuseId() const;
ReturnValue_t initialize();
DeviceList devices;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
uint32_t getSerializedSize() const;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
void setAllMonitorsToUnchecked();
ReturnValue_t performOperation(uint8_t opCode);
MessageQueueId_t getCommandQueue() const;

8
power/PowerComponent.cpp
View File

@ -17,8 +17,8 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
twoSwitches), min(min), max(max), moduleId(moduleId) {
}
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<float>::serialize(&min, buffer,
size, max_size, bigEndian);
if (result != HasReturnvaluesIF::RETURN_OK) {
@ -28,7 +28,7 @@ ReturnValue_t PowerComponent::serialize(uint8_t** buffer, uint32_t* size,
bigEndian);
}
uint32_t PowerComponent::getSerializedSize() const {
size_t PowerComponent::getSerializedSize() const {
return sizeof(min) + sizeof(max);
}
@ -56,7 +56,7 @@ float PowerComponent::getMax() {
return max;
}
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, int32_t* size,
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
size, bigEndian);

10
power/PowerComponent.h
View File

@ -19,13 +19,13 @@ public:
float getMin();
float getMax();
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
uint32_t getSerializedSize() const;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,

2
serialize/SerialBufferAdapter.cpp
View File

@ -23,7 +23,7 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const {
const size_t max_size, bool bigEndian) const {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(

11
thermal/ThermalComponent.cpp
View File

@ -42,19 +42,18 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
}
}
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, uint32_t size) {
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
if (size != 4 * sizeof(parameters.lowerOpLimit)) {
return MonitoringIF::INVALID_SIZE;
}
int32_t readSize = size;
SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
&readSize, true);
&size, true);
SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
&readSize, true);
&size, true);
SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
&readSize, true);
&size, true);
SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
&readSize, true);
&size, true);
return HasReturnvaluesIF::RETURN_OK;
}

2
thermal/ThermalComponent.h
View File

@ -29,7 +29,7 @@ public:
ReturnValue_t setTargetState(int8_t newState);
virtual ReturnValue_t setLimits( const uint8_t* data, uint32_t size);
virtual ReturnValue_t setLimits( const uint8_t* data, size_t size);
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,

16
tmtcpacket/packetmatcher/ApidMatcher.h
View File

@ -22,16 +22,18 @@ public:
return false;
}
}
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size,
max_size, bigEndian);
}
uint32_t getSerializedSize() const {
size_t getSerializedSize() const override {
return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
}
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
size, bigEndian);
}
};

14
tmtcpacket/packetmatcher/ServiceMatcher.h
View File

@ -22,16 +22,18 @@ public:
return false;
}
}
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return SerializeAdapter<uint8_t>::serialize(&service, buffer, size,
max_size, bigEndian);
}
uint32_t getSerializedSize() const {
size_t getSerializedSize() const {
return SerializeAdapter<uint8_t>::getSerializedSize(&service);
}
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
size, bigEndian);
}
};

14
tmtcpacket/packetmatcher/SubserviceMatcher.h
View File

@ -20,16 +20,18 @@ public:
return false;
}
}
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return SerializeAdapter<uint8_t>::serialize(&subService, buffer,
size, max_size, bigEndian);
}
uint32_t getSerializedSize() const {
size_t getSerializedSize() const {
return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
}
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
size, bigEndian);
}
private:
uint8_t subService;

2
tmtcpacket/pus/TmPacketStored.cpp
View File

@ -57,7 +57,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
setData(p_data);
initializeTmPacket(apid, service, subservice, packetSubcounter);
uint8_t* putDataHere = getSourceData();
uint32_t size = 0;
size_t size = 0;
if (header != NULL) {
header->serialize(&putDataHere, &size, sourceDataSize, true);
}

2
tmtcservices/CommandingServiceBase.cpp
View File

@ -235,7 +235,7 @@ void CommandingServiceBase::sendTmPacket(uint8_t subservice,
object_id_t objectId, const uint8_t *data, uint32_t dataLen) {
uint8_t buffer[sizeof(object_id_t)];
uint8_t* pBuffer = buffer;
uint32_t size = 0;
size_t size = 0;
SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
sizeof(object_id_t), true);
TmPacketStored tmPacketStored(this->apid, this->service, subservice,

4
tmtcservices/PusVerificationReport.h
View File

@ -49,7 +49,7 @@ class PusSuccessReport {
private:
static const uint16_t MAX_SIZE = 7;
uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize;
size_t reportSize;
uint8_t * pBuffer;
public:
PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@ -63,7 +63,7 @@ class PusFailureReport {
private:
static const uint16_t MAX_SIZE = 16;
uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize;
size_t reportSize;
uint8_t * pBuffer;
public:
PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,