Merge branch 'mueller_framework' into front_branch

This commit is contained in:
Robin Müller 2020-07-06 23:31:38 +02:00
commit e48de981f5
103 changed files with 1951 additions and 1336 deletions

View File

@ -85,7 +85,7 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = data->serialize(&dataPtr, &size, maxSize, true);
result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
ipcStore->deleteData(storeAddress);
return result;

View File

@ -4,7 +4,7 @@
#include <framework/action/HasActionsIF.h>
#include <framework/objectmanager/ObjectManagerIF.h>
CommandActionHelper::CommandActionHelper(CommandsActionsIF* setOwner) :
CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
owner(setOwner), queueToUse(NULL), ipcStore(
NULL), commandCount(0), lastTarget(0) {
}
@ -13,13 +13,13 @@ CommandActionHelper::~CommandActionHelper() {
}
ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
ActionId_t actionId, SerializeIF* data) {
HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
ActionId_t actionId, SerializeIF *data) {
HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
if (receiver == NULL) {
return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
}
store_address_t storeId;
uint8_t* storePointer;
uint8_t *storePointer;
size_t maxSize = data->getSerializedSize();
ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
&storePointer);
@ -27,7 +27,8 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
return result;
}
size_t size = 0;
result = data->serialize(&storePointer, &size, maxSize, true);
result = data->serialize(&storePointer, &size, maxSize,
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -35,11 +36,11 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
}
ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
ActionId_t actionId, const uint8_t* data, uint32_t size) {
ActionId_t actionId, const uint8_t *data, uint32_t size) {
// if (commandCount != 0) {
// return CommandsFunctionsIF::ALREADY_COMMANDING;
// }
HasActionsIF* receiver = objectManager->get<HasActionsIF>(commandTo);
HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
if (receiver == NULL) {
return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
}
@ -71,13 +72,13 @@ ReturnValue_t CommandActionHelper::initialize() {
}
queueToUse = owner->getCommandQueuePtr();
if(queueToUse == NULL){
if (queueToUse == NULL) {
return HasReturnvaluesIF::RETURN_FAILED;
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
if (reply->getSender() != lastTarget) {
return HasReturnvaluesIF::RETURN_FAILED;
}
@ -88,7 +89,8 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::COMPLETION_FAILED:
commandCount--;
owner->completionFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getReturnCode(reply));
owner->completionFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getReturnCode(reply));
return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::STEP_SUCCESS:
owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
@ -96,11 +98,13 @@ ReturnValue_t CommandActionHelper::handleReply(CommandMessage* reply) {
return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::STEP_FAILED:
commandCount--;
owner->stepFailedReceived(ActionMessage::getActionId(reply), ActionMessage::getStep(reply),
owner->stepFailedReceived(ActionMessage::getActionId(reply),
ActionMessage::getStep(reply),
ActionMessage::getReturnCode(reply));
return HasReturnvaluesIF::RETURN_OK;
case ActionMessage::DATA_REPLY:
extractDataForOwner(ActionMessage::getActionId(reply), ActionMessage::getStoreId(reply));
extractDataForOwner(ActionMessage::getActionId(reply),
ActionMessage::getStoreId(reply));
return HasReturnvaluesIF::RETURN_OK;
default:
return HasReturnvaluesIF::RETURN_FAILED;

View File

@ -1,82 +1,31 @@
#ifndef FIFO_H_
#define FIFO_H_
#ifndef FRAMEWORK_CONTAINER_FIFO_H_
#define FRAMEWORK_CONTAINER_FIFO_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/container/FIFOBase.h>
#include <vector>
namespace fsfw {
/**
* @brief Simple First-In-First-Out data structure
* @brief Simple First-In-First-Out data structure. The maximum size
* can be set in the constructor.
* @details
* The maximum capacity can be determined at run-time, so this container
* performs dynamic memory allocation!
* The public interface of FIFOBase exposes the user interface for the FIFO.
* @tparam T Entry Type
* @tparam capacity Maximum capacity
*/
template<typename T, uint8_t capacity>
class FIFO {
private:
uint8_t readIndex, writeIndex, currentSize;
T data[capacity];
uint8_t next(uint8_t current) {
++current;
if (current == capacity) {
current = 0;
}
return current;
}
template<typename T>
class FIFO: public FIFOBase<T> {
public:
FIFO() :
readIndex(0), writeIndex(0), currentSize(0) {
}
FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity),
values(maxCapacity) {};
bool empty() {
return (currentSize == 0);
}
bool full() {
return (currentSize == capacity);
}
uint8_t size(){
return currentSize;
}
ReturnValue_t insert(T value) {
if (full()) {
return FULL;
} else {
data[writeIndex] = value;
writeIndex = next(writeIndex);
++currentSize;
return HasReturnvaluesIF::RETURN_OK;
}
}
ReturnValue_t retrieve(T *value) {
if (empty()) {
return EMPTY;
} else {
*value = data[readIndex];
readIndex = next(readIndex);
--currentSize;
return HasReturnvaluesIF::RETURN_OK;
}
}
ReturnValue_t peek(T * value) {
if(empty()) {
return EMPTY;
} else {
*value = data[readIndex];
return HasReturnvaluesIF::RETURN_OK;
}
}
ReturnValue_t pop() {
T value;
return this->retrieve(&value);
}
static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
private:
std::vector<T> values;
};
#endif /* FIFO_H_ */
}
#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */

65
container/FIFOBase.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
#define FRAMEWORK_CONTAINER_FIFOBASE_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <cstddef>
namespace fsfw {
template <typename T>
class FIFOBase {
public:
static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
/** Default ctor, takes pointer to first entry of underlying container
* and maximum capacity */
FIFOBase(T* values, const size_t maxCapacity);
/**
* Insert value into FIFO
* @param value
* @return
*/
ReturnValue_t insert(T value);
/**
* Retrieve item from FIFO. This removes the item from the FIFO.
* @param value
* @return
*/
ReturnValue_t retrieve(T *value);
/**
* Retrieve item from FIFO without removing it from FIFO.
* @param value
* @return
*/
ReturnValue_t peek(T * value);
/**
* Remove item from FIFO.
* @return
*/
ReturnValue_t pop();
bool empty();
bool full();
size_t size();
size_t getMaxCapacity() const;
private:
T* values;
size_t maxCapacity = 0;
size_t readIndex = 0;
size_t writeIndex = 0;
size_t currentSize = 0;
size_t next(size_t current);
};
#include <framework/container/FIFOBase.tpp>
}
#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */

81
container/FIFOBase.tpp Normal file
View File

@ -0,0 +1,81 @@
#ifndef FRAMEWORK_CONTAINER_FIFOBASE_TPP_
#define FRAMEWORK_CONTAINER_FIFOBASE_TPP_
#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
#error Include FIFOBase.h before FIFOBase.tpp!
#endif
template<typename T>
inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
values(values), maxCapacity(maxCapacity) {};
template<typename T>
inline ReturnValue_t FIFOBase<T>::insert(T value) {
if (full()) {
return FULL;
} else {
values[writeIndex] = value;
writeIndex = next(writeIndex);
++currentSize;
return HasReturnvaluesIF::RETURN_OK;
}
};
template<typename T>
inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
if (empty()) {
return EMPTY;
} else {
*value = values[readIndex];
readIndex = next(readIndex);
--currentSize;
return HasReturnvaluesIF::RETURN_OK;
}
};
template<typename T>
inline ReturnValue_t FIFOBase<T>::peek(T* value) {
if(empty()) {
return EMPTY;
} else {
*value = values[readIndex];
return HasReturnvaluesIF::RETURN_OK;
}
};
template<typename T>
inline ReturnValue_t FIFOBase<T>::pop() {
T value;
return this->retrieve(&value);
};
template<typename T>
inline bool FIFOBase<T>::empty() {
return (currentSize == 0);
};
template<typename T>
inline bool FIFOBase<T>::full() {
return (currentSize == maxCapacity);
}
template<typename T>
inline size_t FIFOBase<T>::size() {
return currentSize;
}
template<typename T>
inline size_t FIFOBase<T>::next(size_t current) {
++current;
if (current == maxCapacity) {
current = 0;
}
return current;
}
template<typename T>
inline size_t FIFOBase<T>::getMaxCapacity() const {
return maxCapacity;
}
#endif

View File

@ -164,6 +164,7 @@ public:
return theMap.maxSize();
}
bool full() {
if(_size == theMap.maxSize()) {
return true;
@ -174,15 +175,15 @@ public:
}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size,
buffer, size, max_size, bigEndian);
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
buffer, size, maxSize, streamEndianness);
uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer,
size, max_size, bigEndian);
result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&theMap[i].first, buffer,
size, maxSize, streamEndianness);
result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
maxSize, streamEndianness);
++i;
}
return result;
@ -193,27 +194,27 @@ public:
uint32_t i = 0;
for (i = 0; i < _size; ++i) {
printSize += SerializeAdapter<key_t>::getSerializedSize(
printSize += SerializeAdapter::getSerializedSize(
&theMap[i].first);
printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second);
printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
}
return printSize;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size,
buffer, size, bigEndian);
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
buffer, size, streamEndianness);
if (this->_size > theMap.maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS;
}
uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer,
size, bigEndian);
result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
size, streamEndianness);
result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
streamEndianness);
++i;
}
return result;

View File

@ -75,50 +75,50 @@ public:
return this->storedPackets;
}
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t result = AutoSerializeAdapter::serialize(&blockStartAddress,buffer,size,max_size,bigEndian);
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = indexType.serialize(buffer,size,max_size,bigEndian);
result = indexType.serialize(buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&this->storedPackets,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
return result;
}
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian){
ReturnValue_t result = AutoSerializeAdapter::deSerialize(&blockStartAddress,buffer,size,bigEndian);
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness){
ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = indexType.deSerialize(buffer,size,bigEndian);
result = indexType.deSerialize(buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::deSerialize(&this->size,buffer,size,bigEndian);
result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::deSerialize(&this->storedPackets,buffer,size,bigEndian);
result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
return result;
}
uint32_t getSerializedSize() const {
uint32_t size = AutoSerializeAdapter::getSerializedSize(&blockStartAddress);
size_t getSerializedSize() const {
uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
size += indexType.getSerializedSize();
size += AutoSerializeAdapter::getSerializedSize(&this->size);
size += AutoSerializeAdapter::getSerializedSize(&this->storedPackets);
size += SerializeAdapter::getSerializedSize(&this->size);
size += SerializeAdapter::getSerializedSize(&this->storedPackets);
return size;
}
@ -509,37 +509,37 @@ public:
* Parameters according to HasSerializeIF
* @param buffer
* @param size
* @param max_size
* @param bigEndian
* @param maxSize
* @param streamEndianness
* @return
*/
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,
size_t maxSize, Endianness streamEndianness) const{
uint8_t* crcBuffer = *buffer;
uint32_t oldSize = *size;
if(additionalInfo!=NULL){
additionalInfo->serialize(buffer,size,max_size,bigEndian);
additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
}
ReturnValue_t result = currentWriteBlock->serialize(buffer,size,max_size,bigEndian);
ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&this->size,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
result = SerializeAdapter<Index<T> >::serialize(&this->entries[i], buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
maxSize, streamEndianness);
++i;
}
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
result = AutoSerializeAdapter::serialize(&crc,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
return result;
}
@ -555,10 +555,10 @@ public:
size += additionalInfo->getSerializedSize();
}
size += currentWriteBlock->getSerializedSize();
size += AutoSerializeAdapter::getSerializedSize(&this->size);
size += SerializeAdapter::getSerializedSize(&this->size);
size += (this->entries[0].getSerializedSize()) * this->size;
uint16_t crc = 0;
size += AutoSerializeAdapter::getSerializedSize(&crc);
size += SerializeAdapter::getSerializedSize(&crc);
return size;
}
/**
@ -566,28 +566,28 @@ public:
* CRC Has to be checked before!
* @param buffer
* @param size
* @param bigEndian
* @param streamEndianness
* @return
*/
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian){
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness){
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
if(additionalInfo!=NULL){
result = additionalInfo->deSerialize(buffer,size,bigEndian);
result = additionalInfo->deSerialize(buffer,size,streamEndianness);
}
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
Index<T> tempIndex;
result = tempIndex.deSerialize(buffer,size,bigEndian);
result = tempIndex.deSerialize(buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
uint32_t tempSize = 0;
result = AutoSerializeAdapter::deSerialize(&tempSize,buffer,size,bigEndian);
result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK){
return result;
}
@ -596,9 +596,9 @@ public:
}
uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
result = SerializeAdapter<Index<T> >::deSerialize(
result = SerializeAdapter::deSerialize(
&this->entries[i], buffer, size,
bigEndian);
streamEndianness);
++i;
}
if(result != HasReturnvaluesIF::RETURN_OK){

30
container/StaticFIFO.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
#define FRAMEWORK_CONTAINER_STATICFIFO_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/container/FIFOBase.h>
#include <array>
namespace fsfw {
/**
* @brief Simple First-In-First-Out data structure with size fixed at
* compile time
* @details
* Performs no dynamic memory allocation.
* The public interface of FIFOBase exposes the user interface for the FIFO.
* @tparam T Entry Type
* @tparam capacity Maximum capacity
*/
template<typename T, size_t capacity>
class StaticFIFO: public FIFOBase<T> {
public:
StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
private:
std::array<T, capacity> values;
};
}
#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */

View File

@ -1,8 +1,11 @@
#include <framework/datapool/DataSetBase.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
DataSetBase::DataSetBase() {
for (uint8_t count = 0; count < DATA_SET_MAX_SIZE; count++) {
DataSetBase::DataSetBase(PoolVariableIF** registeredVariablesArray,
const size_t maxFillCount):
registeredVariables(registeredVariablesArray),
maxFillCount(maxFillCount) {
for (uint8_t count = 0; count < maxFillCount; count++) {
registeredVariables[count] = nullptr;
}
}
@ -21,7 +24,7 @@ ReturnValue_t DataSetBase::registerVariable(
"Pool variable is nullptr." << std::endl;
return DataSetIF::POOL_VAR_NULL;
}
if (fillCount >= DATA_SET_MAX_SIZE) {
if (fillCount >= maxFillCount) {
sif::error << "DataSet::registerVariable: "
"DataSet is full." << std::endl;
return DataSetIF::DATA_SET_FULL;
@ -131,11 +134,11 @@ ReturnValue_t DataSetBase::unlockDataPool() {
}
ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
const size_t maxSize, bool bigEndian) const {
const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
for (uint16_t count = 0; count < fillCount; count++) {
result = registeredVariables[count]->serialize(buffer, size, maxSize,
bigEndian);
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -144,11 +147,11 @@ ReturnValue_t DataSetBase::serialize(uint8_t** buffer, size_t* size,
}
ReturnValue_t DataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
SerializeIF::Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
for (uint16_t count = 0; count < fillCount; count++) {
result = registeredVariables[count]->deSerialize(buffer, size,
bigEndian);
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}

View File

@ -37,7 +37,8 @@ public:
* supply a pointer to this dataset to PoolVariable
* initializations to register pool variables.
*/
DataSetBase();
DataSetBase(PoolVariableIF** registeredVariablesArray,
const size_t maxFillCount);
virtual~ DataSetBase();
/**
@ -105,15 +106,11 @@ public:
/* SerializeIF implementations */
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t maxSize, bool bigEndian) const override;
const size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
// SHOULDDO we could use a linked list of datapool variables
//!< This definition sets the maximum number of variables to
//! register in one DataSet.
static const uint8_t DATA_SET_MAX_SIZE = 63;
SerializeIF::Endianness streamEndianness) override;
protected:
/**
@ -137,8 +134,11 @@ protected:
/**
* @brief This array represents all pool variables registered in this set.
* Child classes can use a static or dynamic container to create
* an array of registered variables and assign the first entry here.
*/
PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE] = { };
PoolVariableIF** registeredVariables = nullptr;
const size_t maxFillCount = 0;
private:
ReturnValue_t readVariable(uint16_t count);

View File

@ -24,8 +24,9 @@ PoolRawAccessHelper::~PoolRawAccessHelper() {
}
ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
const size_t max_size, bool bigEndian) {
SerializationArgs serializationArgs = {buffer, size, max_size, bigEndian};
const size_t max_size, SerializeIF::Endianness streamEndianness) {
SerializationArgs serializationArgs = {buffer, size, max_size,
streamEndianness};
ReturnValue_t result = RETURN_OK;
size_t remainingParametersSize = numberOfParameters * 4;
for(uint8_t count=0; count < numberOfParameters; count++) {
@ -44,9 +45,10 @@ ReturnValue_t PoolRawAccessHelper::serialize(uint8_t **buffer, size_t *size,
}
ReturnValue_t PoolRawAccessHelper::serializeWithValidityMask(uint8_t ** buffer,
size_t * size, const size_t max_size, bool bigEndian) {
size_t * size, const size_t max_size,
SerializeIF::Endianness streamEndianness) {
ReturnValue_t result = RETURN_OK;
SerializationArgs argStruct = {buffer, size, max_size, bigEndian};
SerializationArgs argStruct = {buffer, size, max_size, streamEndianness};
size_t remainingParametersSize = numberOfParameters * 4;
uint8_t validityMaskSize = ceil((float)numberOfParameters/8.0);
uint8_t validityMask[validityMaskSize];
@ -76,8 +78,8 @@ ReturnValue_t PoolRawAccessHelper::serializeCurrentPoolEntryIntoBuffer(
bool withValidMask, uint8_t * validityMask) {
uint32_t currentPoolId;
// Deserialize current pool ID from pool ID buffer
ReturnValue_t result = AutoSerializeAdapter::deSerialize(&currentPoolId,
&poolIdBuffer,remainingParameters, false);
ReturnValue_t result = SerializeAdapter::deSerialize(&currentPoolId,
&poolIdBuffer,remainingParameters, SerializeIF::Endianness::MACHINE);
if(result != RETURN_OK) {
sif::debug << std::hex << "PoolRawAccessHelper: Error deSeralizing "
"pool IDs" << std::dec << std::endl;
@ -109,8 +111,8 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
GlobDataSet currentDataSet;
//debug << "Current array position: " << (int)arrayPosition << std::endl;
PoolRawAccess currentPoolRawAccess(currentPoolId,arrayPosition,
&currentDataSet,PoolVariableIF::VAR_READ);
PoolRawAccess currentPoolRawAccess(currentPoolId, arrayPosition,
&currentDataSet, PoolVariableIF::VAR_READ);
result = currentDataSet.read();
if (result != RETURN_OK) {
@ -137,7 +139,7 @@ ReturnValue_t PoolRawAccessHelper::handlePoolEntrySerialization(
}
result = currentDataSet.serialize(argStruct.buffer, argStruct.size,
argStruct.max_size, argStruct.bigEndian);
argStruct.max_size, argStruct.streamEndianness);
if (result != RETURN_OK) {
sif::debug << "Pool Raw Access Helper: Error serializing pool data with "
"ID 0x" << std::hex << currentPoolId << " into send buffer "

View File

@ -43,7 +43,7 @@ public:
* @c RETURN_FAILED on failure
*/
ReturnValue_t serialize(uint8_t ** buffer, size_t * size,
const size_t max_size, bool bigEndian);
const size_t max_size, SerializeIF::Endianness streamEndianness);
/**
* Serializes data pool entries into provided buffer with the validity mask buffer
@ -56,7 +56,7 @@ public:
* @c RETURN_FAILED on failure
*/
ReturnValue_t serializeWithValidityMask(uint8_t ** buffer, size_t * size,
const size_t max_size, bool bigEndian);
const size_t max_size, SerializeIF::Endianness streamEndianness);
private:
@ -71,7 +71,7 @@ private:
uint8_t ** buffer;
size_t * size;
const size_t max_size;
bool bigEndian;
SerializeIF::Endianness streamEndianness;
};
/**
* Helper function to serialize single pool entries

View File

@ -26,7 +26,7 @@ MessageQueueId_t DataPoolAdmin::getCommandQueue() const {
}
ReturnValue_t DataPoolAdmin::executeAction(ActionId_t actionId,
MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size) {
MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
if (actionId != SET_VALIDITY) {
return INVALID_ACTION_ID;
}
@ -91,7 +91,7 @@ void DataPoolAdmin::handleCommand() {
}
ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
const uint8_t* data, uint32_t size, uint8_t** dataPointer) {
const uint8_t* data, size_t size, uint8_t** dataPointer) {
uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
GlobDataSet testSet;
@ -129,7 +129,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryLoad(uint32_t address,
return ACTIVITY_COMPLETED;
}
ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, size_t size,
uint8_t** dataPointer, uint8_t* copyHere) {
uint32_t poolId = glob::dataPool.PIDToDataPoolId(address);
uint8_t arrayIndex = glob::dataPool.PIDToArrayIndex(address);
@ -151,7 +151,7 @@ ReturnValue_t DataPoolAdmin::handleMemoryDump(uint32_t address, uint32_t size,
PoolVariableIF::VAR_READ);
status = rawSet.read();
if (status == RETURN_OK) {
uint32_t temp = 0;
size_t temp = 0;
status = variable.getEntryEndianSafe(ptrToCopy, &temp, size);
if (status != RETURN_OK) {
return RETURN_FAILED;
@ -261,7 +261,7 @@ ReturnValue_t DataPoolAdmin::handleParameterCommand(CommandMessage* command) {
//identical to ParameterHelper::sendParameter()
ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
const DataPoolParameterWrapper* wrapper) {
uint32_t serializedSize = wrapper->getSerializedSize();
size_t serializedSize = wrapper->getSerializedSize();
uint8_t *storeElement;
store_address_t address;
@ -275,7 +275,7 @@ ReturnValue_t DataPoolAdmin::sendParameter(MessageQueueId_t to, uint32_t id,
size_t storeElementSize = 0;
result = wrapper->serialize(&storeElement, &storeElementSize,
serializedSize, true);
serializedSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
storage->deleteData(address);

View File

@ -30,12 +30,12 @@ public:
MessageQueueId_t getCommandQueue() const;
ReturnValue_t handleMemoryLoad(uint32_t address, const uint8_t* data,
uint32_t size, uint8_t** dataPointer);
ReturnValue_t handleMemoryDump(uint32_t address, uint32_t size,
size_t size, uint8_t** dataPointer);
ReturnValue_t handleMemoryDump(uint32_t address, size_t size,
uint8_t** dataPointer, uint8_t* copyHere);
ReturnValue_t executeAction(ActionId_t actionId,
MessageQueueId_t commandedBy, const uint8_t* data, uint32_t size);
MessageQueueId_t commandedBy, const uint8_t* data, size_t size);
//not implemented as ParameterHelper is no used
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,

View File

@ -34,22 +34,22 @@ ReturnValue_t DataPoolParameterWrapper::set(uint8_t domainId,
}
ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) const {
size_t* size, size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result;
result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&columns, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -58,7 +58,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
GlobDataSet mySet;
PoolRawAccess raw(poolId, index, &mySet,PoolVariableIF::VAR_READ);
mySet.read();
result = raw.serialize(buffer,size,max_size,bigEndian);
result = raw.serialize(buffer,size,maxSize,streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK){
return result;
}
@ -68,7 +68,7 @@ ReturnValue_t DataPoolParameterWrapper::serialize(uint8_t** buffer,
//same as ParameterWrapper
size_t DataPoolParameterWrapper::getSerializedSize() const {
uint32_t serializedSize = 0;
size_t serializedSize = 0;
serializedSize += type.getSerializedSize();
serializedSize += sizeof(rows);
serializedSize += sizeof(columns);
@ -78,7 +78,7 @@ size_t DataPoolParameterWrapper::getSerializedSize() const {
}
ReturnValue_t DataPoolParameterWrapper::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
size_t* size, Endianness streamEndianness) {
return HasReturnvaluesIF::RETURN_FAILED;
}

View File

@ -12,12 +12,12 @@ public:
ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
size_t maxSize, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
Endianness streamEndianness) override;
ReturnValue_t copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex);

View File

@ -2,7 +2,9 @@
#include <framework/datapoolglob/GlobalDataSet.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
GlobDataSet::GlobDataSet(): DataSetBase() {}
GlobDataSet::GlobDataSet(): DataSetBase(
reinterpret_cast<PoolVariableIF**>(&registeredVariables),
DATA_SET_MAX_SIZE) {}
// Don't do anything with your variables, they are dead already!
// (Destructor is already called)

View File

@ -61,6 +61,10 @@ public:
*/
void setEntriesValid(bool valid);
//!< This definition sets the maximum number of variables to
//! register in one DataSet.
static const uint8_t DATA_SET_MAX_SIZE = 63;
private:
/**
* If the valid state of a dataset is always relevant to the whole
@ -85,6 +89,8 @@ private:
void handleAlreadyReadDatasetCommit();
ReturnValue_t handleUnreadDatasetCommit();
PoolVariableIF* registeredVariables[DATA_SET_MAX_SIZE];
};
#endif /* DATASET_H_ */

View File

@ -181,18 +181,20 @@ public:
}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
bigEndian);
const size_t max_size,
SerializeIF::Endianness streamEndianness) const override {
return SerializeAdapter::serialize(&value, buffer, size, max_size,
streamEndianness);
}
virtual size_t getSerializedSize() const {
return SerializeAdapter<T>::getSerializedSize(&value);
return SerializeAdapter::getSerializedSize(&value);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
SerializeIF::Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&value, buffer, size,
streamEndianness);
}
};

View File

@ -109,10 +109,10 @@ public:
const T &operator [](int i) const {return value[i];}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
size_t max_size, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
Endianness streamEndianness) override;
/**
* @brief This is a call to read the array's values

View File

@ -79,12 +79,13 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::commitWithoutLock() {
template<typename T, uint16_t vectorSize>
inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) const {
size_t* size, size_t max_size,
SerializeIF::Endianness streamEndianness) const {
uint16_t i;
ReturnValue_t result;
for (i = 0; i < vectorSize; i++) {
result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&(value[i]), buffer, size,
max_size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -94,17 +95,18 @@ inline ReturnValue_t GlobPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
template<typename T, uint16_t vectorSize>
inline size_t GlobPoolVector<T, vectorSize>::getSerializedSize() const {
return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
return vectorSize * SerializeAdapter::getSerializedSize(value);
}
template<typename T, uint16_t vectorSize>
inline ReturnValue_t GlobPoolVector<T, vectorSize>::deSerialize(
const uint8_t** buffer, size_t* size, bool bigEndian) {
const uint8_t** buffer, size_t* size,
SerializeIF::Endianness streamEndianness) {
uint16_t i;
ReturnValue_t result;
for (i = 0; i < vectorSize; i++) {
result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}

View File

@ -15,10 +15,9 @@ class PIDReader: public PoolVariableIF {
protected:
uint32_t parameterId;
uint8_t valid;
ReturnValue_t readWithoutLock() {
uint8_t arrayIndex = GlobalDataPool::PIDToArrayIndex(parameterId);
PoolEntry<T>* read_out = glob::dataPool.getData<T>(
PoolEntry<T> *read_out = glob::dataPool.getData<T>(
GlobalDataPool::PIDToDataPoolId(parameterId), arrayIndex);
if (read_out != NULL) {
valid = read_out->valid;
@ -48,7 +47,8 @@ protected:
* Empty ctor for List initialization
*/
PIDReader() :
parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) {
parameterId(PoolVariableIF::NO_PARAMETER), valid(
PoolVariableIF::INVALID), value(0) {
}
public:
@ -68,9 +68,9 @@ public:
* \param setWritable If this flag is set to true, changes in the value attribute can be
* written back to the data pool, otherwise not.
*/
PIDReader(uint32_t setParameterId, DataSetIF* dataSet) :
parameterId(setParameterId), valid(
PoolVariableIF::INVALID), value(0) {
PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
0) {
if (dataSet != NULL) {
dataSet->registerVariable(this);
}
@ -92,7 +92,7 @@ public:
/**
* Copy ctor to copy classes containing Pool Variables.
*/
PIDReader(const PIDReader& rhs) :
PIDReader(const PIDReader &rhs) :
parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
}
@ -139,24 +139,25 @@ public:
return value;
}
PIDReader<T> &operator=(T newValue) {
PIDReader<T>& operator=(T newValue) {
value = newValue;
return *this;
}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return SerializeAdapter<T>::serialize(&value, buffer, size, max_size,
bigEndian);
virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const override {
return SerializeAdapter::serialize(&value, buffer, size, maxSize,
streamEndianness);
}
virtual size_t getSerializedSize() const {
return SerializeAdapter<T>::getSerializedSize(&value);
virtual size_t getSerializedSize() const override {
return SerializeAdapter::getSerializedSize(&value);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) override {
return SerializeAdapter::deSerialize(&value, buffer, size,
streamEndianness);
}
};

View File

@ -1,7 +1,7 @@
#include <framework/datapoolglob/GlobalDataPool.h>
#include <framework/datapoolglob/PoolRawAccess.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/osal/Endiness.h>
#include <framework/serialize/EndianConverter.h>
#include <cstring>
@ -121,7 +121,7 @@ uint8_t* PoolRawAccess::getEntry() {
}
ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
uint32_t* writtenBytes, uint32_t max_size) {
size_t* writtenBytes, size_t max_size) {
uint8_t* data_ptr = getEntry();
// debug << "PoolRawAccess::getEntry: Array position: " <<
// index * size_of_type << " Size of T: " << (int)size_of_type <<
@ -130,35 +130,26 @@ ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer,
return DATA_POOL_ACCESS_FAILED;
if (typeSize > max_size)
return INCORRECT_SIZE;
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (uint8_t count = 0; count < typeSize; count++) {
buffer[count] = data_ptr[typeSize - count - 1];
}
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(buffer, data_ptr, typeSize);
#endif
EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
*writtenBytes = typeSize;
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
if (typeSize + *size <= max_size) {
if (bigEndian) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (uint8_t count = 0; count < typeSize; count++) {
(*buffer)[count] = value[typeSize - count - 1];
}
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(*buffer, value, typeSize);
#endif
} else {
size_t maxSize, Endianness streamEndianness) const {
if (typeSize + *size <= maxSize) {
switch(streamEndianness) {
case(Endianness::BIG):
EndianConverter::convertBigEndian(*buffer, value, typeSize);
break;
case(Endianness::LITTLE):
EndianConverter::convertLittleEndian(*buffer, value, typeSize);
break;
case(Endianness::MACHINE):
default:
memcpy(*buffer, value, typeSize);
break;
}
*size += typeSize;
(*buffer) += typeSize;
@ -173,11 +164,11 @@ Type PoolRawAccess::getType() {
return type;
}
uint8_t PoolRawAccess::getSizeOfType() {
size_t PoolRawAccess::getSizeOfType() {
return typeSize;
}
uint8_t PoolRawAccess::getArraySize(){
size_t PoolRawAccess::getArraySize(){
return arraySize;
}
@ -189,22 +180,14 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
return readWriteMode;
}
ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t* buffer,
uint32_t setSize) {
ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
size_t setSize) {
if (typeSize == setSize) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (uint8_t count = 0; count < typeSize; count++) {
value[count] = buffer[typeSize - count - 1];
}
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(value, buffer, typeSize);
#endif
EndianConverter::convertBigEndian(value, buffer, typeSize);
return HasReturnvaluesIF::RETURN_OK;
} else {
sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
<< (uint32_t) typeSize << ", Requested: " << setSize
sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: "
"Internal" << (uint32_t) typeSize << ", Requested: " << setSize
<< std::endl;
return INCORRECT_SIZE;
}
@ -221,7 +204,7 @@ void PoolRawAccess::setValid(bool valid) {
this->valid = valid;
}
uint16_t PoolRawAccess::getSizeTillEnd() const {
size_t PoolRawAccess::getSizeTillEnd() const {
return sizeTillEnd;
}
@ -230,25 +213,23 @@ size_t PoolRawAccess::getSerializedSize() const {
return typeSize;
}
ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
// TODO: Needs to be tested!!!
ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) {
if (*size >= typeSize) {
switch(streamEndianness) {
case(Endianness::BIG):
EndianConverter::convertBigEndian(value, *buffer, typeSize);
break;
case(Endianness::LITTLE):
EndianConverter::convertLittleEndian(value, *buffer, typeSize);
break;
case(Endianness::MACHINE):
default:
memcpy(value, *buffer, typeSize);
break;
}
*size -= typeSize;
if (bigEndian) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (uint8_t count = 0; count < typeSize; count++) {
value[count] = (*buffer)[typeSize - count - 1];
}
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(value, *buffer, typeSize);
#endif
}
else {
memcpy(value, *buffer, typeSize);
}
*buffer += typeSize;
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -57,8 +57,8 @@ public:
* @return - @c RETURN_OK if entry could be acquired
* - @c RETURN_FAILED else.
*/
ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size,
uint32_t max_size);
ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
size_t maxSize);
/**
* @brief Serialize raw pool entry into provided buffer directly
@ -69,8 +69,13 @@ public:
* @return - @c RETURN_OK if serialization was successfull
* - @c SerializeIF::BUFFER_TOO_SHORT if range check failed
*/
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) override;
/**
* With this method, the content can be set from a big endian buffer safely.
@ -80,7 +85,7 @@ public:
* - @c RETURN_FAILED on failure
*/
ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer,
uint32_t setSize);
size_t setSize);
/**
* @brief This operation returns the type of the entry currently stored.
*/
@ -88,12 +93,12 @@ public:
/**
* @brief This operation returns the size of the entry currently stored.
*/
uint8_t getSizeOfType();
size_t getSizeOfType();
/**
*
* @return the size of the datapool array
*/
uint8_t getArraySize();
size_t getArraySize();
/**
* @brief This operation returns the data pool id of the variable.
*/
@ -128,12 +133,7 @@ public:
/**
* Getter for the remaining size.
*/
uint16_t getSizeTillEnd() const;
size_t getSerializedSize() const;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
size_t getSizeTillEnd() const;
/**
* @brief This is a call to read the value from the global data pool.
@ -202,15 +202,15 @@ private:
/**
* @brief This value contains the size of the data pool entry type in bytes.
*/
uint8_t typeSize;
size_t typeSize;
/**
* The size of the DP array (single values return 1)
*/
uint8_t arraySize;
size_t arraySize;
/**
* The size (in bytes) from the selected entry till the end of this DataPool variable.
*/
uint16_t sizeTillEnd;
size_t sizeTillEnd;
/**
* @brief The information whether the class is read-write or read-only is stored here.
*/

View File

@ -1,5 +1,6 @@
#include <framework/datapoollocal/LocalDataPoolManager.h>
#include <framework/datapoollocal/LocalDataSet.h>
#include <framework/housekeeping/AcceptsHkPacketsIF.h>
#include <framework/ipc/MutexFactory.h>
#include <framework/ipc/MutexHelper.h>
#include <framework/ipc/QueueFactory.h>
@ -7,7 +8,7 @@
#include <array>
LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
uint32_t replyQueueDepth, bool appendValidityBuffer):
MessageQueueIF* queueToUse, bool appendValidityBuffer):
appendValidityBuffer(appendValidityBuffer) {
if(owner == nullptr) {
sif::error << "HkManager: Invalid supplied owner!" << std::endl;
@ -24,16 +25,45 @@ LocalDataPoolManager::LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
sif::error << "LocalDataPoolManager::LocalDataPoolManager: "
"Could not set IPC store." << std::endl;
}
hkQueue = QueueFactory::instance()->createMessageQueue(replyQueueDepth,
HousekeepingMessage::HK_MESSAGE_SIZE);
hkQueue = queueToUse;
}
ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse,
object_id_t hkDestination) {
if(queueToUse == nullptr) {
sif::error << "LocalDataPoolManager::initialize: Supplied queue "
"invalid!" << std::endl;
}
hkQueue = queueToUse;
if(hkDestination == objects::NO_OBJECT) {
return initializeHousekeepingPoolEntriesOnce();
}
AcceptsHkPacketsIF* hkReceiver =
objectManager->get<AcceptsHkPacketsIF>(hkDestination);
if(hkReceiver != nullptr) {
setHkPacketDestination(hkReceiver->getHkQueue());
}
else {
sif::warning << "LocalDataPoolManager::initialize: Could not retrieve"
" queue ID from HK destination object ID. " << std::flush;
sif::warning << "Make sure it exists and the object impements "
"AcceptsHkPacketsIF!" << std::endl;
}
return initializeHousekeepingPoolEntriesOnce();
}
void LocalDataPoolManager::setHkPacketDestination(
MessageQueueId_t hkDestination) {
this->hkDestination = hkDestination;
}
LocalDataPoolManager::~LocalDataPoolManager() {}
ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
if(not mapInitialized) {
ReturnValue_t result =
owner->initializePoolEntries(localDpMap);
ReturnValue_t result = owner->initializePoolEntries(localDpMap);
if(result == HasReturnvaluesIF::RETURN_OK) {
mapInitialized = true;
}
@ -80,16 +110,12 @@ MutexIF* LocalDataPoolManager::getMutexHandle() {
return mutex;
}
void LocalDataPoolManager::setHkPacketDestination(
MessageQueueId_t destinationQueueId) {
this->currentHkPacketDestination = destinationQueueId;
}
const OwnsLocalDataPoolIF* LocalDataPoolManager::getOwner() const {
return owner;
}
ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
MessageQueueId_t sendTo) {
LocalDataSet* dataSetToSerialize = dynamic_cast<LocalDataSet*>(
owner->getDataSetHandle(sid));
if(dataSetToSerialize == nullptr) {
@ -108,14 +134,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid) {
CommandMessage hkMessage;
HousekeepingMessage::setHkReportMessage(&hkMessage, sid, storeId);
if(hkQueue == nullptr) {
return QUEUE_NOT_SET;
return QUEUE_OR_DESTINATION_NOT_SET;
}
if(currentHkPacketDestination != MessageQueueIF::NO_QUEUE) {
result = hkQueue->sendMessage(currentHkPacketDestination, &hkMessage);
if(sendTo != MessageQueueIF::NO_QUEUE) {
result = hkQueue->sendMessage(sendTo, &hkMessage);
}
else {
result = hkQueue->sendToDefault(&hkMessage);
if(hkDestination == MessageQueueIF::NO_QUEUE) {
sif::warning << "LocalDataPoolManager::generateHousekeepingPacket:"
" Destination is not set properly!" << std::endl;
return QUEUE_OR_DESTINATION_NOT_SET;
}
else {
result = hkQueue->sendMessage(hkDestination, &hkMessage);
}
}
return result;
@ -141,7 +174,7 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
}
size_t size = 0;
result = dataSet->serializeLocalPoolIds(&storePtr, &size,
expectedSize, false);
expectedSize, SerializeIF::Endianness::BIG);
if(expectedSize != size) {
sif::error << "HousekeepingManager::generateSetStructurePacket: "
"Expected size is not equal to serialized size" << std::endl;
@ -149,6 +182,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
return result;
}
void LocalDataPoolManager::setMinimalSamplingFrequency(float frequencySeconds) {
}
ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
store_address_t *storeId, LocalDataSet* dataSet) {
size_t hkSize = dataSet->getSerializedSize();
@ -163,10 +199,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
if(appendValidityBuffer) {
result = dataSet->serializeWithValidityBuffer(&storePtr,
&size, hkSize, false);
&size, hkSize, SerializeIF::Endianness::MACHINE);
}
else {
result = dataSet->serialize(&storePtr, &size, hkSize, false);
result = dataSet->serialize(&storePtr, &size, hkSize,
SerializeIF::Endianness::MACHINE);
}
if(result != HasReturnvaluesIF::RETURN_OK) {
@ -177,4 +214,3 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
}

View File

@ -44,18 +44,45 @@ public:
static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
static constexpr ReturnValue_t QUEUE_NOT_SET = MAKE_RETURN_CODE(0x2);
static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
//static constexpr ReturnValue_t SET_NOT_FOUND = MAKE_RETURN_CODE(0x3);
LocalDataPoolManager(OwnsLocalDataPoolIF* owner,
uint32_t replyQueueDepth = 20, bool appendValidityBuffer = true);
/**
* This constructor is used by a class which wants to implement
* a personal local data pool. The queueToUse can be supplied if it
* is already known.
*
* initialize() has to be called in any case before using the object!
* @param owner
* @param queueToUse
* @param appendValidityBuffer
*/
LocalDataPoolManager(OwnsLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
bool appendValidityBuffer = true);
/**
* Initializes the map by calling the map initialization function of the
* owner abd assigns the queue to use.
* @param queueToUse
* @return
*/
ReturnValue_t initialize(MessageQueueIF* queueToUse,
object_id_t hkDestination);
/**
* This function is used to set the default HK packet destination.
* This destination will usually only be set once.
* @param hkDestination
*/
void setHkPacketDestination(MessageQueueId_t hkDestination);
virtual~ LocalDataPoolManager();
/* Copying forbidden */
LocalDataPoolManager(const LocalDataPoolManager &) = delete;
LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
ReturnValue_t generateHousekeepingPacket(sid_t sid);
/**
* Generate a housekeeping packet with a given SID.
* @param sid
* @return
*/
ReturnValue_t generateHousekeepingPacket(sid_t sid, MessageQueueId_t sendTo
= MessageQueueIF::NO_QUEUE);
ReturnValue_t generateSetStructurePacket(sid_t sid);
ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
@ -68,40 +95,43 @@ public:
*/
ReturnValue_t initializeHousekeepingPoolEntriesOnce();
//! Set the queue for HK packets, which are sent unrequested.
void setHkPacketDestination(MessageQueueId_t destinationQueueId);
const OwnsLocalDataPoolIF* getOwner() const;
ReturnValue_t printPoolEntry(lp_id_t localPoolId);
/* Copying forbidden */
LocalDataPoolManager(const LocalDataPoolManager &) = delete;
LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
private:
//! This is the map holding the actual data. Should only be initialized
//! once !
/** This is the map holding the actual data. Should only be initialized
* once ! */
bool mapInitialized = false;
//! This specifies whether a validity buffer is appended at the end
//! of generated housekeeping packets.
/** This specifies whether a validity buffer is appended at the end
* of generated housekeeping packets. */
bool appendValidityBuffer = true;
LocalDataPool localDpMap;
//! Every housekeeping data manager has a mutex to protect access
//! to it's data pool.
/** Every housekeeping data manager has a mutex to protect access
* to it's data pool. */
MutexIF * mutex = nullptr;
//! The class which actually owns the manager (and its datapool).
/** The class which actually owns the manager (and its datapool). */
OwnsLocalDataPoolIF* owner = nullptr;
//! Queue used for communication, for example commands.
//! Is also used to send messages.
/**
* @brief Queue used for communication, for example commands.
* Is also used to send messages. Can be set either in the constructor
* or in the initialize() function.
*/
MessageQueueIF* hkQueue = nullptr;
//! HK replies will always be a reply to the commander, but HK packet
//! can be sent to another destination by specifying this message queue
//! ID, for example to a dedicated housekeeping service implementation.
MessageQueueId_t currentHkPacketDestination = MessageQueueIF::NO_QUEUE;
/**
* HK replies will always be a reply to the commander, but HK packet
* can be sent to another destination by specifying this message queue
* ID, for example to a dedicated housekeeping service implementation.
*/
MessageQueueId_t hkDestination = MessageQueueIF::NO_QUEUE;
//! Global IPC store is used to store all packets.
/** Global IPC store is used to store all packets. */
StorageManagerIF* ipcStore = nullptr;
/**
* Get the pointer to the mutex. Can be used to lock the data pool

View File

@ -5,20 +5,30 @@
#include <cmath>
#include <cstring>
LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner): DataSetBase() {
LocalDataSet::LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
const size_t maxNumberOfVariables):
DataSetBase(poolVarList.data(), maxNumberOfVariables) {
poolVarList.reserve(maxNumberOfVariables);
poolVarList.resize(maxNumberOfVariables);
if(hkOwner == nullptr) {
sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
<< std::endl;
return;
}
hkManager = hkOwner->getHkManagerHandle();
}
LocalDataSet::LocalDataSet(object_id_t ownerId): DataSetBase() {
LocalDataSet::LocalDataSet(object_id_t ownerId,
const size_t maxNumberOfVariables):
DataSetBase(poolVarList.data(), maxNumberOfVariables) {
poolVarList.reserve(maxNumberOfVariables);
poolVarList.resize(maxNumberOfVariables);
OwnsLocalDataPoolIF* hkOwner = objectManager->get<OwnsLocalDataPoolIF>(
ownerId);
if(hkOwner == nullptr) {
sif::error << "LocalDataSet::LocalDataSet: Owner can't be nullptr!"
<< std::endl;
return;
}
hkManager = hkOwner->getHkManagerHandle();
}
@ -32,7 +42,8 @@ ReturnValue_t LocalDataSet::lockDataPool(uint32_t timeoutMs) {
}
ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
size_t *size, const size_t maxSize, bool bigEndian) const {
size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const {
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount)/8.0);
uint8_t validityMask[validityMaskSize];
@ -52,7 +63,7 @@ ReturnValue_t LocalDataSet::serializeWithValidityBuffer(uint8_t **buffer,
}
}
result = registeredVariables[count]->serialize(buffer, size, maxSize,
bigEndian);
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -69,11 +80,12 @@ ReturnValue_t LocalDataSet::unlockDataPool() {
}
ReturnValue_t LocalDataSet::serializeLocalPoolIds(uint8_t** buffer,
size_t* size, const size_t maxSize, bool bigEndian) const {
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const {
for (uint16_t count = 0; count < fillCount; count++) {
lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
auto result = AutoSerializeAdapter::serialize(&currentPoolId, buffer,
size, maxSize, bigEndian);
auto result = SerializeAdapter::serialize(&currentPoolId, buffer,
size, maxSize, streamEndianness);
if(result != HasReturnvaluesIF::RETURN_OK) {
sif::warning << "LocalDataSet::serializeLocalPoolIds: Serialization"
" error!" << std::endl;

View File

@ -5,6 +5,8 @@
#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
#include <framework/serialize/SerializeIF.h>
#include <vector>
class LocalDataPoolManager;
/**
@ -35,7 +37,8 @@ public:
* The constructor simply sets the fill_count to zero and sets
* the state to "uninitialized".
*/
LocalDataSet(OwnsLocalDataPoolIF* hkOwner);
LocalDataSet(OwnsLocalDataPoolIF *hkOwner,
const size_t maxNumberOfVariables);
/**
* @brief Constructor for users of local pool data. The passed pool
@ -43,7 +46,8 @@ public:
* The constructor simply sets the fill_count to zero and sets
* the state to "uninitialized".
*/
LocalDataSet(object_id_t ownerId);
LocalDataSet(object_id_t ownerId,
const size_t maxNumberOfVariables);
/**
* @brief The destructor automatically manages writing the valid
@ -68,10 +72,12 @@ public:
* @return
*/
ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer,
size_t* size, const size_t maxSize, bool bigEndian) const;
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const;
ReturnValue_t serializeLocalPoolIds(uint8_t** buffer,
size_t* size, const size_t maxSize, bool bigEndian) const;
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const;
protected:
private:
/**
@ -102,6 +108,8 @@ private:
* (most significant bit) to 7 (least significant bit)
*/
void bitSetter(uint8_t* byte, uint8_t position) const;
std::vector<PoolVariableIF*> poolVarList;
};
#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATASET_H_ */

View File

@ -84,11 +84,11 @@ public:
void setValid(bool validity) override;
uint8_t getValid() const;
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
SerializeIF::Endianness streamEndianness) override;
/**
* @brief This is a call to read the array's values

View File

@ -133,20 +133,20 @@ inline uint8_t LocalPoolVar<T>::getValid() const {
template<typename T>
inline ReturnValue_t LocalPoolVar<T>::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return AutoSerializeAdapter::serialize(&value,
buffer, size ,max_size, bigEndian);
const size_t max_size, SerializeIF::Endianness streamEndianness) const {
return SerializeAdapter::serialize(&value,
buffer, size ,max_size, streamEndianness);
}
template<typename T>
inline size_t LocalPoolVar<T>::getSerializedSize() const {
return AutoSerializeAdapter::getSerializedSize(&value);
return SerializeAdapter::getSerializedSize(&value);
}
template<typename T>
inline ReturnValue_t LocalPoolVar<T>::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
return AutoSerializeAdapter::deSerialize(&value, buffer, size, bigEndian);
size_t* size, SerializeIF::Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
}
template<typename T>

View File

@ -114,10 +114,11 @@ public:
const T &operator [](int i) const;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override;
const size_t maxSize,
SerializeIF::Endianness streamEndiannes) const override;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
SerializeIF::Endianness streamEndianness) override;
/**
* @brief This is a call to read the array's values

View File

@ -125,11 +125,12 @@ inline const T& LocalPoolVector<T, vectorSize>::operator [](int i) const {
template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) const {
size_t* size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const {
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
for (uint16_t i = 0; i < vectorSize; i++) {
result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&(value[i]), buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
break;
}
@ -139,16 +140,17 @@ inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(uint8_t** buffer,
template<typename T, uint16_t vectorSize>
inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
return vectorSize * SerializeAdapter<T>::getSerializedSize(value);
return vectorSize * SerializeAdapter::getSerializedSize(value);
}
template<typename T, uint16_t vectorSize>
inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
const uint8_t** buffer, size_t* size, bool bigEndian) {
const uint8_t** buffer, size_t* size,
SerializeIF::Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
for (uint16_t i = 0; i < vectorSize; i++) {
result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
break;
}

View File

@ -0,0 +1,6 @@
#include <framework/datapoollocal/StaticLocalDataSet.h>

View File

@ -0,0 +1,11 @@
#ifndef FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
#define FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_
#include <framework/datapool/DataSetBase.h>
class StaticLocalDataSet: public DataSetBase {
};
#endif /* FRAMEWORK_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */

View File

@ -1,15 +1,12 @@
/**
* @file AcceptsDeviceResponsesIF.h
* @brief This file defines the AcceptsDeviceResponsesIF class.
* @date 15.05.2013
* @author baetz
*/
#ifndef ACCEPTSDEVICERESPONSESIF_H_
#define ACCEPTSDEVICERESPONSESIF_H_
#ifndef FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
#define FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_
#include <framework/ipc/MessageQueueSenderIF.h>
/**
* This interface is used by the device handler to send a device response
* to the queue ID, which is returned in the implemented abstract method.
*/
class AcceptsDeviceResponsesIF {
public:
/**
@ -19,4 +16,4 @@ public:
virtual MessageQueueId_t getDeviceQueue() = 0;
};
#endif /* ACCEPTSDEVICERESPONSESIF_H_ */
#endif /* FRAMEWORK_DEVICEHANDLERS_ACCEPTSDEVICERESPONSESIF_H_ */

View File

@ -5,10 +5,11 @@
ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
object_id_t deviceCommunication, CookieIF * cookie,
uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
uint32_t parent, FailureIsolationBase* customFdir, size_t cmdQueueSize) :
object_id_t hkDestination, uint32_t thermalStatePoolId,
uint32_t thermalRequestPoolId, uint32_t parent,
FailureIsolationBase* customFdir, size_t cmdQueueSize) :
DeviceHandlerBase(setObjectId, deviceCommunication, cookie,
setDeviceSwitch, thermalStatePoolId,
hkDestination, setDeviceSwitch, thermalStatePoolId,
thermalRequestPoolId, (customFdir == NULL? &childHandlerFdir : customFdir),
cmdQueueSize),
parentId(parent), childHandlerFdir(setObjectId) {

View File

@ -8,9 +8,9 @@ class ChildHandlerBase: public DeviceHandlerBase {
public:
ChildHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
CookieIF * cookie, uint32_t maxDeviceReplyLen, uint8_t setDeviceSwitch,
uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
uint32_t parent, FailureIsolationBase* customFdir = nullptr,
size_t cmdQueueSize = 20);
object_id_t hkDestination, uint32_t thermalStatePoolId,
uint32_t thermalRequestPoolId, uint32_t parent,
FailureIsolationBase* customFdir = nullptr, size_t cmdQueueSize = 20);
virtual ~ChildHandlerBase();
virtual ReturnValue_t initialize();

View File

@ -22,21 +22,21 @@ object_id_t DeviceHandlerBase::defaultFDIRParentId = 0;
DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId,
object_id_t deviceCommunication, CookieIF * comCookie,
uint8_t setDeviceSwitch, uint32_t thermalStatePoolId,
uint32_t thermalRequestPoolId, FailureIsolationBase* fdirInstance,
size_t cmdQueueSize) :
uint8_t setDeviceSwitch, object_id_t hkDestination,
uint32_t thermalStatePoolId, uint32_t thermalRequestPoolId,
FailureIsolationBase* fdirInstance, size_t cmdQueueSize) :
SystemObject(setObjectId), mode(MODE_OFF), submode(SUBMODE_NONE),
wiretappingMode(OFF), storedRawData(StorageManagerIF::INVALID_ADDRESS),
deviceCommunicationId(deviceCommunication), comCookie(comCookie),
healthHelper(this,setObjectId), modeHelper(this), parameterHelper(this),
actionHelper(this, nullptr), hkManager(this),
actionHelper(this, nullptr), hkManager(this, nullptr),
deviceThermalStatePoolId(thermalStatePoolId),
deviceThermalRequestPoolId(thermalRequestPoolId),
childTransitionFailure(RETURN_OK), fdirInstance(fdirInstance),
hkSwitcher(this), defaultFDIRUsed(fdirInstance == nullptr),
switchOffWasReported(false), childTransitionDelay(5000),
transitionSourceMode(_MODE_POWER_DOWN), transitionSourceSubMode(
SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
switchOffWasReported(false), hkDestination(hkDestination),
childTransitionDelay(5000), transitionSourceMode(_MODE_POWER_DOWN),
transitionSourceSubMode(SUBMODE_NONE), deviceSwitch(setDeviceSwitch) {
commandQueue = QueueFactory::instance()->createMessageQueue(cmdQueueSize,
MessageQueueMessage::MAX_MESSAGE_SIZE);
insertInCommandMap(RAW_COMMAND_ID);
@ -128,8 +128,12 @@ ReturnValue_t DeviceHandlerBase::initialize() {
AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
AcceptsDeviceResponsesIF>(rawDataReceiverId);
if (rawReceiver == NULL) {
return RETURN_FAILED;
if (rawReceiver == nullptr) {
sif::error << "DeviceHandlerBase::initialize: Raw receiver object "
"ID set but no valid object found." << std::endl;
sif::error << "Make sure the raw receiver object is set up properly"
" and implements AcceptsDeviceResponsesIF" << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
}
defaultRawReceiver = rawReceiver->getDeviceQueue();
}
@ -173,7 +177,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
return result;
}
result = hkManager.initializeHousekeepingPoolEntriesOnce();
result = hkManager.initialize(commandQueue, hkDestination);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -315,6 +319,12 @@ void DeviceHandlerBase::doStateMachine() {
case _MODE_WAIT_OFF: {
uint32_t currentUptime;
Clock::getUptime(&currentUptime);
if(powerSwitcher == nullptr) {
setMode(MODE_OFF);
return;
}
if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT,
0);
@ -696,19 +706,23 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
if (info->delayCycles != 0) {
if (info->periodic != 0) {
if (info->periodic != false) {
info->delayCycles = info->maxDelayCycles;
} else {
}
else {
info->delayCycles = 0;
}
result = interpretDeviceReply(foundId, receivedData);
if (result != RETURN_OK) {
// Report failed interpretation to FDIR.
replyRawReplyIfnotWiretapped(receivedData, foundLen);
triggerEvent(DEVICE_INTERPRETING_REPLY_FAILED, result, foundId);
}
replyToReply(iter, result);
} else {
}
else {
// Other completion failure messages are created by timeout.
// Powering down the device might take some time during which periodic
// replies may still come in.
@ -719,7 +733,7 @@ void DeviceHandlerBase::handleReply(const uint8_t* receivedData,
}
ReturnValue_t DeviceHandlerBase::getStorageData(store_address_t storageAddress,
uint8_t * *data, uint32_t * len) {
uint8_t** data, uint32_t * len) {
size_t lenTmp;
if (IPCStore == nullptr) {

View File

@ -107,6 +107,7 @@ public:
*/
DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication,
CookieIF * comCookie, uint8_t setDeviceSwitch,
object_id_t hkDestination = objects::NO_OBJECT,
uint32_t thermalStatePoolId = PoolVariableIF::NO_PARAMETER,
uint32_t thermalRequestPoolId = PoolVariableIF::NO_PARAMETER,
FailureIsolationBase* fdirInstance = nullptr,
@ -652,11 +653,13 @@ protected:
size_t replyLen = 0; //!< Expected size of the reply.
//! if this is !=0, the delayCycles will not be reset to 0 but to
//! maxDelayCycles
bool periodic;
bool periodic = false;
//! The dataset used to access housekeeping data related to the
//! respective device reply. Will point to a dataset held by
//! the child handler (if one is specified)
DataSetIF* dataSet;
DataSetIF* dataSet = nullptr;
float collectionInterval = 0.0;
uint32_t intervalCounter = 0;
//! The command that expects this reply.
DeviceCommandMap::iterator command;
};
@ -1035,18 +1038,19 @@ private:
};
/**
* Info about the #cookie
*
* @brief Info about the #cookie
* Used to track the state of the communication
*/
CookieInfo cookieInfo;
/** the object used to set power switches*/
/** the object used to set power switches */
PowerSwitchIF *powerSwitcher = nullptr;
/** Cached for initialize() */
object_id_t hkDestination = objects::NO_OBJECT;
/**
* Used for timing out mode transitions.
*
* @brief Used for timing out mode transitions.
* Set when setMode() is called.
*/
uint32_t timeoutStart = 0;
@ -1057,11 +1061,12 @@ private:
uint32_t childTransitionDelay;
/**
* The mode the current transition originated from
* @brief The mode the current transition originated from
*
* This is private so the child can not change it and fuck up the timeouts
*
* IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!! (it is _MODE_POWER_DOWN during this modes)
* IMPORTANT: This is not valid during _MODE_SHUT_DOWN and _MODE_START_UP!!
* (it is _MODE_POWER_DOWN during this modes)
*
* is element of [MODE_ON, MODE_NORMAL, MODE_RAW]
*/

View File

@ -12,18 +12,18 @@ DeviceTmReportingWrapper::~DeviceTmReportingWrapper() {
}
ReturnValue_t DeviceTmReportingWrapper::serialize(uint8_t** buffer,
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);
size_t* size, size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&objectId,
buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<ActionId_t>::serialize(&actionId, buffer,
size, max_size, bigEndian);
result = SerializeAdapter::serialize(&actionId, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return data->serialize(buffer, size, max_size, bigEndian);
return data->serialize(buffer, size, maxSize, streamEndianness);
}
size_t DeviceTmReportingWrapper::getSerializedSize() const {
@ -31,16 +31,16 @@ size_t DeviceTmReportingWrapper::getSerializedSize() const {
}
ReturnValue_t DeviceTmReportingWrapper::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
ReturnValue_t result = SerializeAdapter<object_id_t>::deSerialize(&objectId,
buffer, size, bigEndian);
size_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&objectId,
buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<ActionId_t>::deSerialize(&actionId, buffer,
size, bigEndian);
result = SerializeAdapter::deSerialize(&actionId, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return data->deSerialize(buffer, size, bigEndian);
return data->deSerialize(buffer, size, streamEndianness);
}

View File

@ -12,12 +12,12 @@ public:
virtual ~DeviceTmReportingWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
size_t maxSize, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
Endianness streamEndianness) override;
private:
object_id_t objectId;
ActionId_t actionId;

View File

@ -12,15 +12,15 @@ public:
EventRangeMatcherBase(T from, T till, bool inverted) : rangeMatcher(from, till, inverted) { }
virtual ~EventRangeMatcherBase() { }
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return rangeMatcher.serialize(buffer, size, max_size, bigEndian);
size_t maxSize, Endianness streamEndianness) const {
return rangeMatcher.serialize(buffer, size, maxSize, streamEndianness);
}
size_t getSerializedSize() const {
return rangeMatcher.getSerializedSize();
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return rangeMatcher.deSerialize(buffer, size, bigEndian);
Endianness streamEndianness) {
return rangeMatcher.deSerialize(buffer, size, streamEndianness);
}
protected:
RangeMatcher<T> rangeMatcher;

View File

@ -35,8 +35,10 @@ ReturnValue_t FailureIsolationBase::initialize() {
return result;
}
owner = objectManager->get<HasHealthIF>(ownerId);
if (owner == NULL) {
return RETURN_FAILED;
if (owner == nullptr) {
sif::error << "FailureIsolationBase::intialize: Owner object "
"invalid. Make sure it implements HasHealthIF" << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
}
}
if (faultTreeParent != 0) {

View File

@ -59,7 +59,7 @@ uint8_t Type::getSize() const {
}
ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
size_t maxSize, Endianness streamEndianness) const {
uint8_t ptc;
uint8_t pfc;
ReturnValue_t result = getPtcPfc(&ptc, &pfc);
@ -67,14 +67,14 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&ptc, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&ptc, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&pfc, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&pfc, buffer, size, maxSize,
streamEndianness);
return result;
@ -82,21 +82,21 @@ ReturnValue_t Type::serialize(uint8_t** buffer, size_t* size,
size_t Type::getSerializedSize() const {
uint8_t dontcare = 0;
return 2 * SerializeAdapter<uint8_t>::getSerializedSize(&dontcare);
return 2 * SerializeAdapter::getSerializedSize(&dontcare);
}
ReturnValue_t Type::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
Endianness streamEndianness) {
uint8_t ptc;
uint8_t pfc;
ReturnValue_t result = SerializeAdapter<uint8_t>::deSerialize(&ptc, buffer,
size, bigEndian);
ReturnValue_t result = SerializeAdapter::deSerialize(&ptc, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::deSerialize(&pfc, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&pfc, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}

View File

@ -25,7 +25,7 @@ public:
Type(ActualType_t actualType);
Type(const Type& type);
Type(const Type &type);
Type& operator=(Type rhs);
@ -33,8 +33,8 @@ public:
operator ActualType_t() const;
bool operator==(const Type& rhs);
bool operator!=(const Type& rhs);
bool operator==(const Type &rhs);
bool operator!=(const Type &rhs);
uint8_t getSize() const;
@ -42,13 +42,13 @@ public:
static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) override;
private:
ActualType_t actualType;

View File

@ -1,104 +0,0 @@
#include <framework/globalfunctions/conversion.h>
#include <framework/osal/Endiness.h>
#include <cstring>
//SHOULDDO: This shall be optimized (later)!
void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF00) >> 8;
buffer[1] = (value & 0x00FF);
*size += 2;
}
void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF000000) >> 24;
buffer[1] = (value & 0x00FF0000) >> 16;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF);
*size +=4;
}
void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF00) >> 8;
buffer[1] = (value & 0x00FF);
*size += 2;
}
void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size ) {
buffer[0] = (value & 0xFF000000) >> 24;
buffer[1] = (value & 0x00FF0000) >> 16;
buffer[2] = (value & 0x0000FF00) >> 8;
buffer[3] = (value & 0x000000FF);
*size += 4;
}
//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size ) {
// buffer[0] = (value & 0xFF00000000000000) >> 56;
// buffer[1] = (value & 0x00FF000000000000) >> 48;
// buffer[2] = (value & 0x0000FF0000000000) >> 40;
// buffer[3] = (value & 0x000000FF00000000) >> 32;
// buffer[4] = (value & 0x00000000FF000000) >> 24;
// buffer[5] = (value & 0x0000000000FF0000) >> 16;
// buffer[6] = (value & 0x000000000000FF00) >> 8;
// buffer[7] = (value & 0x00000000000000FF);
// *size+=8;
//}
//
//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size ) {
// buffer[0] = (value & 0xFF00000000000000) >> 56;
// buffer[1] = (value & 0x00FF000000000000) >> 48;
// buffer[2] = (value & 0x0000FF0000000000) >> 40;
// buffer[3] = (value & 0x000000FF00000000) >> 32;
// buffer[4] = (value & 0x00000000FF000000) >> 24;
// buffer[5] = (value & 0x0000000000FF0000) >> 16;
// buffer[6] = (value & 0x000000000000FF00) >> 8;
// buffer[7] = (value & 0x00000000000000FF);
// *size+=8;
//}
void convertToByteStream( float in_value, uint8_t* buffer, uint32_t* size ) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
union float_union {
float value;
uint8_t chars[4];
};
float_union temp;
temp.value = in_value;
buffer[0] = temp.chars[3];
buffer[1] = temp.chars[2];
buffer[2] = temp.chars[1];
buffer[3] = temp.chars[0];
*size += 4;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(buffer, &in_value, sizeof(in_value));
*size += sizeof(in_value);
#endif
}
void convertToByteStream( double in_value, uint8_t* buffer, uint32_t* size ) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
union double_union {
double value;
uint8_t chars[8];
};
double_union temp;
temp.value = in_value;
buffer[0] = temp.chars[7];
buffer[1] = temp.chars[6];
buffer[2] = temp.chars[5];
buffer[3] = temp.chars[4];
buffer[4] = temp.chars[3];
buffer[5] = temp.chars[2];
buffer[6] = temp.chars[1];
buffer[7] = temp.chars[0];
*size += 8;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(buffer, &in_value, sizeof(in_value));
*size += sizeof(in_value);
#endif
}

View File

@ -1,24 +0,0 @@
#ifndef CONVERSION_H_
#define CONVERSION_H_
#include <stdint.h>
void convertToByteStream( uint16_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( uint32_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( int16_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( int32_t value, uint8_t* buffer, uint32_t* size );
//void convertToByteStream( uint64_t value, uint8_t* buffer, uint32_t* size );
//
//void convertToByteStream( int64_t value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( float value, uint8_t* buffer, uint32_t* size );
void convertToByteStream( double value, uint8_t* buffer, uint32_t* size );
#endif /* CONVERSION_H_ */

View File

@ -46,37 +46,37 @@ public:
}
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
size_t maxSize, SerializeIF::Endianness streamEndianness) const override {
iterator iter = this->begin();
uint8_t count = this->countRight(iter);
ReturnValue_t result = SerializeAdapter<uint8_t>::serialize(&count,
buffer, size, max_size, bigEndian);
ReturnValue_t result = SerializeAdapter::serialize(&count,
buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (iter == this->end()) {
return HasReturnvaluesIF::RETURN_OK;
}
result = iter->serialize(buffer, size, max_size, bigEndian);
result = iter->serialize(buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (maxDepth > 0) {
MatchTree<T> temp(iter.left(), maxDepth - 1);
result = temp.serialize(buffer, size, max_size, bigEndian);
result = temp.serialize(buffer, size, maxSize, streamEndianness);
}
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
iter = iter.right();
while (iter != this->end()) {
result = iter->serialize(buffer, size, max_size, bigEndian);
result = iter->serialize(buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (maxDepth > 0) {
MatchTree<T> temp(iter.left(), maxDepth - 1);
result = temp.serialize(buffer, size, max_size, bigEndian);
result = temp.serialize(buffer, size, maxSize, streamEndianness);
}
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
@ -86,7 +86,7 @@ public:
return result;
}
size_t getSerializedSize() const {
size_t getSerializedSize() const override {
//Analogous to serialize!
uint32_t size = 1; //One for count
iterator iter = this->begin();
@ -116,7 +116,7 @@ public:
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
SerializeIF::Endianness streamEndianness) override {
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -4,7 +4,6 @@
#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
#include <framework/serialize/SerializeAdapter.h>
template<typename T>
class RangeMatcher: public SerializeableMatcherIF<T> {
public:
@ -27,40 +26,40 @@ public:
}
}
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<T>::serialize(&lowerBound,
buffer, size, max_size, bigEndian);
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override {
ReturnValue_t result = SerializeAdapter::serialize(&lowerBound, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<T>::serialize(&upperBound, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&upperBound, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter<bool>::serialize(&inverted, buffer, size,
max_size, bigEndian);
return SerializeAdapter::serialize(&inverted, buffer, size, maxSize,
streamEndianness);
}
size_t getSerializedSize() const {
size_t getSerializedSize() const override {
return sizeof(lowerBound) + sizeof(upperBound) + sizeof(bool);
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<T>::deSerialize(&lowerBound,
buffer, size, bigEndian);
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
SerializeIF::Endianness streamEndianness) override {
ReturnValue_t result = SerializeAdapter::deSerialize(&lowerBound,
buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<T>::deSerialize(&upperBound, buffer,
size, bigEndian);
result = SerializeAdapter::deSerialize(&upperBound, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter<bool>::deSerialize(&inverted, buffer,
size, bigEndian);
return SerializeAdapter::deSerialize(&inverted, buffer, size,
streamEndianness);
}
protected:
bool doMatch(T input) {

View File

@ -90,3 +90,10 @@ double timevalOperations::toDouble(const timeval timeval) {
double result = timeval.tv_sec * 1000000. + timeval.tv_usec;
return result / 1000000.;
}
timeval timevalOperations::toTimeval(const double seconds) {
timeval tval;
tval.tv_sec = seconds;
tval.tv_usec = seconds *(double) 1e6 - (tval.tv_sec *1e6);
return tval;
}

View File

@ -41,6 +41,7 @@ namespace timevalOperations {
* @return seconds
*/
double toDouble(const timeval timeval);
timeval toTimeval(const double seconds);
}
#endif /* TIMEVALOPERATIONS_H_ */

View File

@ -63,21 +63,21 @@ 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::BLOCKING);
size_t size = 0;
uint16_t count = healthMap.size();
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
&pointer, &size, maxSize, true);
ReturnValue_t result = SerializeAdapter::serialize(&count,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
HealthMap::iterator iter;
for (iter = healthMap.begin();
iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
++iter) {
result = SerializeAdapter<object_id_t>::serialize(&iter->first,
&pointer, &size, maxSize, true);
result = SerializeAdapter::serialize(&iter->first,
&pointer, &size, maxSize, SerializeIF::Endianness::BIG);
uint8_t health = iter->second;
result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size,
maxSize, true);
result = SerializeAdapter::serialize(&health, &pointer, &size,
maxSize, SerializeIF::Endianness::BIG);
}
mutex->unlockMutex();
}

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;

View File

@ -19,7 +19,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;

View File

@ -0,0 +1,11 @@
#ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
#define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
#include <framework/ipc/MessageQueueMessageIF.h>
class AcceptsHkPacketsIF {
public:
virtual~ AcceptsHkPacketsIF() {};
virtual MessageQueueId_t getHkQueue() const = 0;
};
#endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */

View File

@ -2,7 +2,7 @@
#include <framework/memory/MemoryHelper.h>
#include <framework/memory/MemoryMessage.h>
#include <framework/objectmanager/ObjectManagerIF.h>
#include <framework/serialize/EndianSwapper.h>
#include <framework/serialize/EndianConverter.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
@ -44,7 +44,7 @@ void MemoryHelper::completeLoad(ReturnValue_t errorCode,
memcpy(copyHere, dataToCopy, size);
break;
case HasMemoryIF::POINTS_TO_VARIABLE:
EndianSwapper::swap(copyHere, dataToCopy, size);
EndianConverter::convertBigEndian(copyHere, dataToCopy, size);
break;
case HasMemoryIF::ACTIVITY_COMPLETED:
case RETURN_OK:
@ -77,7 +77,7 @@ void MemoryHelper::completeDump(ReturnValue_t errorCode,
case HasMemoryIF::POINTS_TO_VARIABLE:
//"data" must be valid pointer!
if (errorCode == HasMemoryIF::POINTS_TO_VARIABLE) {
EndianSwapper::swap(reservedSpaceInIPC, dataToCopy, size);
EndianConverter::convertBigEndian(reservedSpaceInIPC, dataToCopy, size);
} else {
memcpy(reservedSpaceInIPC, dataToCopy, size);
}
@ -127,7 +127,7 @@ void MemoryHelper::swapMatrixCopy(uint8_t* out, const uint8_t *in,
}
while (totalSize > 0){
EndianSwapper::swap(out,in,datatypeSize);
EndianConverter::convertBigEndian(out,in,datatypeSize);
out += datatypeSize;
in += datatypeSize;
totalSize -= datatypeSize;

View File

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

View File

@ -17,6 +17,10 @@ QueueMapManager* QueueMapManager::instance() {
ReturnValue_t QueueMapManager::addMessageQueue(
MessageQueueIF* queueToInsert, MessageQueueId_t* id) {
// Not thread-safe, but it is assumed all message queues are created
// at software initialization now. If this is to be made thread-safe in
// the future, it propably would be sufficient to lock the increment
// operation here
uint32_t currentId = queueCounter++;
auto returnPair = queueMap.emplace(currentId, queueToInsert);
if(not returnPair.second) {
@ -28,7 +32,6 @@ ReturnValue_t QueueMapManager::addMessageQueue(
if (id != nullptr) {
*id = currentId;
}
mapLock = MutexFactory::instance()->createMutex();
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -36,7 +36,7 @@ public:
private:
//! External instantiation is forbidden.
QueueMapManager();
std::atomic<uint32_t> queueCounter = 1;
uint32_t queueCounter = 1;
MutexIF* mapLock;
QueueMap queueMap;
static QueueMapManager* mqManagerInstance;

View File

@ -47,7 +47,7 @@ MessageQueue::~MessageQueue() {
status = mq_unlink(name);
if(status != 0){
sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
<< strerror(errno) <<std::endl;
<< strerror(errno) << std::endl;
}
}
@ -62,22 +62,27 @@ ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
// Just an additional helpful printout :-)
if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
// See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
// This happens if the msg_max value is not large enough
// It is ignored if the executable is run in privileged mode.
// Run the unlockRealtime script or grant the mode manually by using:
// sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
/*
See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
This happens if the msg_max value is not large enough
It is ignored if the executable is run in privileged mode.
Run the unlockRealtime script or grant the mode manually by using:
sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
// Persistent solution for session:
// echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
Persistent solution for session:
echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
// Permanent solution:
// sudo nano /etc/sysctl.conf
// Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
// Apply changes with: sudo sysctl -p
Permanent solution:
sudo nano /etc/sysctl.conf
Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
Apply changes with: sudo sysctl -p
*/
sif::error << "MessageQueue::MessageQueue: Default MQ size "
<< defaultMqMaxMsg << " is too small for requested size "
<< messageDepth << std::endl;
sif::error << "This error can be fixed by setting the maximum "
"allowed message size higher!" << std::endl;
}
break;
}

View File

@ -149,8 +149,10 @@ void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
if(status != 0){
sif::error << "Posix Thread attribute setStack failed with: " <<
strerror(status) << std::endl;
sif::error << "PosixThread::createTask: pthread_attr_setstack "
" failed with: " << strerror(status) << std::endl;
sif::error << "Make sure the specified stack size is valid and is "
"larger than the minimum allowed stack size." << std::endl;
}
status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);

View File

@ -0,0 +1,79 @@
#include <framework/osal/linux/TcUnixUdpPollingTask.h>
TcSocketPollingTask::TcSocketPollingTask(object_id_t objectId,
object_id_t tmtcUnixUdpBridge, size_t frameSize,
double timeoutSeconds): SystemObject(objectId),
tmtcBridgeId(tmtcUnixUdpBridge) {
if(frameSize > 0) {
this->frameSize = frameSize;
}
else {
this->frameSize = DEFAULT_MAX_FRAME_SIZE;
}
// Set up reception buffer with specified frame size.
// For now, it is assumed that only one frame is held in the buffer!
receptionBuffer.reserve(this->frameSize);
receptionBuffer.resize(this->frameSize);
if(timeoutSeconds == -1) {
receptionTimeout = DEFAULT_TIMEOUT;
}
else {
receptionTimeout = timevalOperations::toTimeval(timeoutSeconds);
}
// Set receive timeout.
int result = setsockopt(serverUdpSocket, SOL_SOCKET, SO_RCVTIMEO,
&receptionTimeout, sizeof(receptionTimeout));
if(result == -1) {
sif::error << "TcSocketPollingTask::TcSocketPollingTask: Setting receive"
"timeout failed with " << strerror(errno) << std::endl;
return;
}
}
TcSocketPollingTask::~TcSocketPollingTask() {
}
ReturnValue_t TcSocketPollingTask::performOperation(uint8_t opCode) {
// Poll for new data permanently. The call will block until the specified
// length of bytes has been received or a timeout occured.
while(1) {
//! Sender Address is cached here.
struct sockaddr_in senderAddress;
socklen_t senderSockLen = 0;
ssize_t bytesReceived = recvfrom(serverUdpSocket,
receptionBuffer.data(), frameSize, receptionFlags,
reinterpret_cast<sockaddr*>(&senderAddress), &senderSockLen);
if(bytesReceived < 0) {
//handle error
sif::error << "TcSocketPollingTask::performOperation: recvfrom "
"failed with " << strerror(errno) << std::endl;
continue;
}
sif::debug << "TcSocketPollingTask::performOperation: " << bytesReceived
<< " bytes received" << std::endl;
ReturnValue_t result = handleSuccessfullTcRead();
tmtcBridge->checkAndSetClientAddress(senderAddress);
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t TcSocketPollingTask::initialize() {
tmtcBridge = objectManager->get<TmTcUnixUdpBridge>(tmtcBridgeId);
if(tmtcBridge == nullptr) {
sif::error << "TcSocketPollingTask::TcSocketPollingTask: Invalid"
" TMTC bridge object!" << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
}
serverUdpSocket = tmtcBridge->serverSocket;
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t TcSocketPollingTask::handleSuccessfullTcRead() {
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -0,0 +1,54 @@
#ifndef FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
#define FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_
#include <framework/objectmanager/SystemObject.h>
#include <framework/osal/linux/TmTcUnixUdpBridge.h>
#include <framework/tasks/ExecutableObjectIF.h>
#include <sys/socket.h>
#include <vector>
/**
* @brief This class can be used to implement the polling of a Unix socket,
* using UDP for now.
* @details
* The task will be blocked while the specified number of bytes has not been
* received, so TC reception is handled inside a separate task.
* This class caches the IP address of the sender. It is assumed there
* is only one sender for now.
*/
class TcSocketPollingTask: public SystemObject,
public ExecutableObjectIF {
friend class TmTcUnixUdpBridge;
public:
static constexpr size_t DEFAULT_MAX_FRAME_SIZE = 2048;
//! 0.5 default milliseconds timeout for now.
static constexpr timeval DEFAULT_TIMEOUT = {.tv_sec = 0, .tv_usec = 500};
TcSocketPollingTask(object_id_t objectId, object_id_t tmtcUnixUdpBridge,
size_t frameSize = 0, double timeoutSeconds = -1);
virtual~ TcSocketPollingTask();
virtual ReturnValue_t performOperation(uint8_t opCode) override;
virtual ReturnValue_t initialize() override;
private:
//! TMTC bridge is cached.
object_id_t tmtcBridgeId = objects::NO_OBJECT;
TmTcUnixUdpBridge* tmtcBridge = nullptr;
//! Reception flags: https://linux.die.net/man/2/recvfrom.
int receptionFlags = 0;
//! Server socket, which is member of TMTC bridge and is assigned in
//! constructor
int serverUdpSocket = 0;
std::vector<uint8_t> receptionBuffer;
size_t frameSize = 0;
timeval receptionTimeout;
ReturnValue_t handleSuccessfullTcRead();
};
#endif /* FRAMEWORK_OSAL_LINUX_TCSOCKETPOLLINGTASK_H_ */

View File

@ -0,0 +1,140 @@
#include <framework/osal/linux/TmTcUnixUdpBridge.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <errno.h>
#include <framework/ipc/MutexHelper.h>
TmTcUnixUdpBridge::TmTcUnixUdpBridge(object_id_t objectId,
object_id_t ccsdsPacketDistributor, uint16_t serverPort,
uint16_t clientPort):
TmTcBridge(objectId, ccsdsPacketDistributor) {
mutex = MutexFactory::instance()->createMutex();
uint16_t setServerPort = DEFAULT_UDP_SERVER_PORT;
if(serverPort != 0xFFFF) {
setServerPort = serverPort;
}
uint16_t setClientPort = DEFAULT_UDP_CLIENT_PORT;
if(clientPort != 0xFFFF) {
setClientPort = clientPort;
}
// Set up UDP socket: https://man7.org/linux/man-pages/man7/ip.7.html
serverSocket = socket(AF_INET, SOCK_DGRAM, 0);
if(socket < 0) {
sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not open"
" UDP socket!" << std::endl;
// check errno here.
handleSocketError();
return;
}
serverAddress.sin_family = AF_INET;
// Accept packets from any interface.
serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddress.sin_port = htons(setServerPort);
setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &serverSocketOptions,
sizeof(serverSocketOptions));
serverSocketLen = sizeof(serverAddress);
int result = bind(serverSocket,
reinterpret_cast<struct sockaddr*>(&serverAddress),
serverSocketLen);
if(result == -1) {
sif::error << "TmTcUnixUdpBridge::TmTcUnixUdpBridge: Could not bind "
"local port " << setServerPort << " to server socket!"
<< std::endl;
// check errno here.
handleBindError();
return;
}
}
TmTcUnixUdpBridge::~TmTcUnixUdpBridge() {
}
ReturnValue_t TmTcUnixUdpBridge::sendTm(const uint8_t *data, size_t dataLen) {
int flags = 0;
ssize_t result = send(serverSocket, data, dataLen, flags);
if(result < 0) {
//handle error
sif::error << "TmTcUnixUdpBridge::sendTm: Send operation failed "
"with error " << strerror(errno) << std::endl;
}
return HasReturnvaluesIF::RETURN_OK;
}
void TmTcUnixUdpBridge::handleSocketError() {
// See: https://man7.org/linux/man-pages/man2/socket.2.html
switch(errno) {
case(EACCES):
case(EINVAL):
case(EMFILE):
case(ENFILE):
case(EAFNOSUPPORT):
case(ENOBUFS):
case(ENOMEM):
case(EPROTONOSUPPORT):
sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
<< " with " << strerror(errno) << std::endl;
break;
default:
sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
<< std::endl;
break;
}
}
void TmTcUnixUdpBridge::setTimeout(float timeoutSeconds) {
}
void TmTcUnixUdpBridge::checkAndSetClientAddress(sockaddr_in newAddress) {
MutexHelper lock(mutex, 10);
// Set new IP address if it has changed.
if(clientAddress.sin_addr.s_addr != newAddress.sin_addr.s_addr) {
clientAddress.sin_addr.s_addr = newAddress.sin_addr.s_addr;
}
}
void TmTcUnixUdpBridge::handleBindError() {
// See: https://man7.org/linux/man-pages/man2/bind.2.html
switch(errno) {
case(EACCES):
/*
Ephermeral ports can be shown with following command:
sysctl -A | grep ip_local_port_range
*/
sif::error << "TmTcUnixBridge::TmTcUnixBridge: Port access issue."
"Ports 1-1024 are reserved on UNIX systems and require root "
"rights while ephermeral ports should not be used as well."
<< std::endl;
break;
case(EADDRINUSE):
case(EBADF):
case(EINVAL):
case(ENOTSOCK):
case(EADDRNOTAVAIL):
case(EFAULT):
case(ELOOP):
case(ENAMETOOLONG):
case(ENOENT):
case(ENOMEM):
case(ENOTDIR):
case(EROFS):
sif::error << "TmTcUnixBridge::TmTcUnixBridge: Socket creation failed"
<< " with " << strerror(errno) << std::endl;
break;
default:
sif::error << "TmTcUnixBridge::TmTcUnixBridge: Unknown error"
<< std::endl;
break;
}
}
ReturnValue_t TmTcUnixUdpBridge::receiveTc(uint8_t **recvBuffer, size_t *size) {
// TC reception handled by separate polling task because it is blocking.
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -0,0 +1,48 @@
#ifndef FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
#define FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_
#include <framework/tmtcservices/TmTcBridge.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/udp.h>
class TmTcUnixUdpBridge: public TmTcBridge {
friend class TcSocketPollingTask;
public:
// The ports chosen here should not be used by any other process.
// List of used ports on Linux: /etc/services
static constexpr uint16_t DEFAULT_UDP_SERVER_PORT = 7301;
static constexpr uint16_t DEFAULT_UDP_CLIENT_PORT = 7302;
TmTcUnixUdpBridge(object_id_t objectId, object_id_t ccsdsPacketDistributor,
uint16_t serverPort = 0xFFFF,uint16_t clientPort = 0xFFFF);
virtual~ TmTcUnixUdpBridge();
void setTimeout(float timeoutSeconds);
void checkAndSetClientAddress(sockaddr_in clientAddress);
protected:
virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer,
size_t * size) override;
virtual ReturnValue_t sendTm(const uint8_t * data, size_t dataLen) override;
private:
int serverSocket = 0;
const int serverSocketOptions = 0;
struct sockaddr_in clientAddress;
socklen_t clientSocketLen = 0;
struct sockaddr_in serverAddress;
socklen_t serverSocketLen = 0;
//! Access to the client address is mutex protected as it is set
//! by another task.
MutexIF* mutex;
void handleSocketError();
void handleBindError();
};
#endif /* FRAMEWORK_OSAL_LINUX_TMTCUNIXUDPBRIDGE_H_ */

View File

@ -89,15 +89,15 @@ void CpuUsage::clear() {
threadData.clear();
}
ReturnValue_t CpuUsage::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<float>::serialize(
&timeSinceLastReset, buffer, size, max_size, bigEndian);
ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(
&timeSinceLastReset, buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerialArrayListAdapter<ThreadData>::serialize(&threadData, buffer,
size, max_size, bigEndian);
size, maxSize, streamEndianness);
}
uint32_t CpuUsage::getSerializedSize() const {
@ -109,37 +109,37 @@ uint32_t CpuUsage::getSerializedSize() const {
return size;
}
ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<float>::deSerialize(
&timeSinceLastReset, buffer, size, bigEndian);
ReturnValue_t CpuUsage::deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(
&timeSinceLastReset, buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerialArrayListAdapter<ThreadData>::deSerialize(&threadData, buffer,
size, bigEndian);
size, streamEndianness);
}
ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&id, buffer,
size, max_size, bigEndian);
ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&id, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
if (*size + MAX_LENGTH_OF_THREAD_NAME > max_size) {
if (*size + MAX_LENGTH_OF_THREAD_NAME > maxSize) {
return BUFFER_TOO_SHORT;
}
memcpy(*buffer, name, MAX_LENGTH_OF_THREAD_NAME);
*size += MAX_LENGTH_OF_THREAD_NAME;
*buffer += MAX_LENGTH_OF_THREAD_NAME;
result = SerializeAdapter<float>::serialize(&timeRunning,
buffer, size, max_size, bigEndian);
result = SerializeAdapter::serialize(&timeRunning,
buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<float>::serialize(&percentUsage,
buffer, size, max_size, bigEndian);
result = SerializeAdapter::serialize(&percentUsage,
buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -158,9 +158,9 @@ uint32_t CpuUsage::ThreadData::getSerializedSize() const {
}
ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) {
ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&id, buffer,
size, bigEndian);
int32_t* size, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&id, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -169,13 +169,13 @@ ReturnValue_t CpuUsage::ThreadData::deSerialize(const uint8_t** buffer,
}
memcpy(name, *buffer, MAX_LENGTH_OF_THREAD_NAME);
*buffer -= MAX_LENGTH_OF_THREAD_NAME;
result = SerializeAdapter<float>::deSerialize(&timeRunning,
buffer, size, bigEndian);
result = SerializeAdapter::deSerialize(&timeRunning,
buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<float>::deSerialize(&percentUsage,
buffer, size, bigEndian);
result = SerializeAdapter::deSerialize(&percentUsage,
buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}

View File

@ -18,13 +18,13 @@ public:
float timeRunning;
float percentUsage;
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
};
CpuUsage();
@ -41,13 +41,13 @@ public:
void clear();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const override;
virtual uint32_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
};
#endif /* CPUUSAGE_H_ */

View File

@ -81,7 +81,7 @@ ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
const ParameterWrapper* description) {
uint32_t serializedSize = description->getSerializedSize();
size_t serializedSize = description->getSerializedSize();
uint8_t *storeElement;
store_address_t address;
@ -95,7 +95,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
size_t storeElementSize = 0;
result = description->serialize(&storeElement, &storeElementSize,
serializedSize, true);
serializedSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
storage->deleteData(address);

View File

@ -6,13 +6,13 @@ ParameterWrapper::ParameterWrapper() :
}
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
void* data) :
void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data(
data), readonlyData(data) {
}
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
const void* data) :
const void *data) :
pointsToStream(false), type(type), rows(rows), columns(columns), data(
NULL), readonlyData(data) {
}
@ -20,23 +20,23 @@ ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
ParameterWrapper::~ParameterWrapper() {
}
ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result;
result = SerializeAdapter<Type>::serialize(&type, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&columns, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&rows, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -47,28 +47,33 @@ ReturnValue_t ParameterWrapper::serialize(uint8_t** buffer, size_t* size,
}
switch (type) {
case Type::UINT8_T:
result = serializeData<uint8_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint8_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT8_T:
result = serializeData<int8_t>(buffer, size, max_size, bigEndian);
result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
break;
case Type::UINT16_T:
result = serializeData<uint16_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint16_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT16_T:
result = serializeData<int16_t>(buffer, size, max_size, bigEndian);
result = serializeData<int16_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::UINT32_T:
result = serializeData<uint32_t>(buffer, size, max_size, bigEndian);
result = serializeData<uint32_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::INT32_T:
result = serializeData<int32_t>(buffer, size, max_size, bigEndian);
result = serializeData<int32_t>(buffer, size, maxSize,
streamEndianness);
break;
case Type::FLOAT:
result = serializeData<float>(buffer, size, max_size, bigEndian);
result = serializeData<float>(buffer, size, maxSize, streamEndianness);
break;
case Type::DOUBLE:
result = serializeData<double>(buffer, size, max_size, bigEndian);
result = serializeData<double>(buffer, size, maxSize, streamEndianness);
break;
default:
result = UNKNOW_DATATYPE;
@ -88,14 +93,14 @@ size_t ParameterWrapper::getSerializedSize() const {
}
template<typename T>
ReturnValue_t ParameterWrapper::serializeData(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const {
const T *element = (const T*) readonlyData;
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
uint16_t dataSize = columns * rows;
while (dataSize != 0) {
result = SerializeAdapter<T>::serialize(element, buffer, size, max_size,
bigEndian);
result = SerializeAdapter::serialize(element, buffer, size, maxSize,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -111,7 +116,7 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
uint8_t fromColumns) {
//treat from as a continuous Stream as we copy all of it
const uint8_t *fromAsStream = (const uint8_t *) from;
const uint8_t *fromAsStream = (const uint8_t*) from;
size_t streamSize = fromRows * fromColumns * sizeof(T);
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@ -119,13 +124,13 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
//get the start element of this row in data
T *dataWithDataType = ((T *) data)
T *dataWithDataType = ((T*) data)
+ (((startingRow + fromRow) * columns) + startingColumn);
for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
result = SerializeAdapter<T>::deSerialize(
result = SerializeAdapter::deSerialize(
dataWithDataType + fromColumn, &fromAsStream, &streamSize,
true);
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -136,13 +141,15 @@ ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
}
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
return deSerialize(buffer, size, bigEndian, 0);
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
size_t *size, Endianness streamEndianness) {
return deSerialize(buffer, size, streamEndianness, 0);
}
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian, uint16_t startWritingAtIndex) {
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
size_t *size, Endianness streamEndianness,
uint16_t startWritingAtIndex) {
ParameterWrapper streamDescription;
ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
@ -153,23 +160,21 @@ ReturnValue_t ParameterWrapper::deSerialize(const uint8_t** buffer,
return copyFrom(&streamDescription, startWritingAtIndex);
}
ReturnValue_t ParameterWrapper::set(const uint8_t* stream, size_t streamSize,
ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream, size_t *remainingSize) {
// TODO: Replaced ssize_t for remainingSize and streamSize
// is the logic here correct?
ReturnValue_t result = SerializeAdapter<Type>::deSerialize(&type, &stream,
&streamSize, true);
ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
&streamSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::deSerialize(&columns, &stream,
&streamSize, true);
result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::deSerialize(&rows, &stream, &streamSize,
true);
result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
@ -196,7 +201,7 @@ ReturnValue_t ParameterWrapper::set(const uint8_t* stream, size_t streamSize,
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex) {
if (data == NULL) {
return READONLY;
@ -263,7 +268,7 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper* from,
}
} else {
//need a type to do arithmetic
uint8_t *toDataWithType = (uint8_t *) data;
uint8_t *toDataWithType = (uint8_t*) data;
for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
memcpy(
toDataWithType

View File

@ -26,15 +26,15 @@ public:
virtual ~ParameterWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
size_t maxSize, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
Endianness streamEndianness) override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian, uint16_t startWritingAtIndex = 0);
Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
template<typename T>
ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const {
@ -54,7 +54,7 @@ public:
const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
streamWithtype += (row * columns + column) * type.getSize();
int32_t size = type.getSize();
return SerializeAdapter<T>::deSerialize(value, &streamWithtype,
return SerializeAdapter::deSerialize(value, &streamWithtype,
&size, true);
} else {
const T *dataWithType = (const T *) readonlyData;
@ -129,7 +129,7 @@ private:
template<typename T>
ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
size_t maxSize, Endianness streamEndianness) const;
template<typename T>
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,

View File

@ -87,11 +87,11 @@ ReturnValue_t Fuse::check() {
}
ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
result = (*iter)->serialize(buffer, size, max_size, bigEndian);
result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
if (result != RETURN_OK) {
return result;
}
@ -99,8 +99,8 @@ ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
return RETURN_OK;
}
uint32_t Fuse::getSerializedSize() const {
size_t size = 0;
size_t Fuse::getSerializedSize() const {
uint32_t size = 0;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
size += (*iter)->getSerializedSize();
@ -109,11 +109,11 @@ uint32_t Fuse::getSerializedSize() const {
}
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
result = (*iter)->deSerialize(buffer, size, bigEndian);
result = (*iter)->deSerialize(buffer, size, streamEndianness);
if (result != RETURN_OK) {
return result;
}

View File

@ -12,14 +12,15 @@
#include <framework/parameters/ParameterHelper.h>
#include <list>
namespace Factory{
namespace Factory {
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
@ -41,7 +42,7 @@ public:
Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount = 2);
virtual ~Fuse();
void addDevice(PowerComponentIF* set);
void addDevice(PowerComponentIF *set);
float getPower();
bool isPowerValid();
@ -50,11 +51,11 @@ public:
uint8_t getFuseId() const;
ReturnValue_t initialize();
DeviceList devices;
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
uint32_t getSerializedSize() const;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
SerializeIF::Endianness streamEndianness) override;
void setAllMonitorsToUnchecked();
ReturnValue_t performOperation(uint8_t opCode);
MessageQueueId_t getCommandQueue() const;
@ -69,7 +70,7 @@ public:
private:
uint8_t oldFuseState;
uint8_t fuseId;
PowerSwitchIF* powerIF; //could be static in our case.
PowerSwitchIF *powerIF; //could be static in our case.
AbsLimitMonitor<float> currentLimit;
class PowerMonitor: public MonitorReporter<float> {
public:
@ -93,7 +94,7 @@ private:
ParameterHelper parameterHelper;
HealthHelper healthHelper;
static object_id_t powerSwitchId;
void calculatePowerLimits(float* low, float* high);
void calculatePowerLimits(float *low, float *high);
void calculateFusePower();
void checkFuseState();
void reportEvents(Event event);

View File

@ -18,14 +18,14 @@ PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, f
}
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);
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter<float>::serialize(&max, buffer, size, max_size,
bigEndian);
return SerializeAdapter::serialize(&max, buffer, size, maxSize,
streamEndianness);
}
size_t PowerComponent::getSerializedSize() const {
@ -57,13 +57,13 @@ float PowerComponent::getMax() {
}
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<float>::deSerialize(&min, buffer,
size, bigEndian);
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter<float>::deSerialize(&max, buffer, size, bigEndian);
return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
}
ReturnValue_t PowerComponent::getParameter(uint8_t domainId,

View File

@ -20,12 +20,12 @@ public:
float getMax();
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const;
size_t maxSize, Endianness streamEndianness) const override;
size_t getSerializedSize() const;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian);
Endianness streamEndianness) override;
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,

View File

@ -64,6 +64,7 @@ enum {
LOCAL_POOL_OWNER_IF, //LPIF 58
POOL_VARIABLE_IF, //PVA 59
HOUSEKEEPING_MANAGER, //HKM 60
PUS_PARSER, //PUSP 61
FW_CLASS_ID_COUNT //is actually count + 1 !
};

View File

@ -12,8 +12,7 @@ typedef uint16_t ReturnValue_t;
class HasReturnvaluesIF {
public:
static const ReturnValue_t RETURN_OK = 0;
//! This will be the all-ones value irrespective of used unsigned datatype.
static const ReturnValue_t RETURN_FAILED = -1;
static const ReturnValue_t RETURN_FAILED = 1;
virtual ~HasReturnvaluesIF() {}
static ReturnValue_t makeReturnCode(uint8_t interfaceId, uint8_t number) {
@ -21,4 +20,4 @@ public:
}
};
#endif /* HASRETURNVALUESIF_H_ */
#endif /* FRAMEWORK_RETURNVALUES_HASRETURNVALUESIF_H_ */

124
serialize/EndianConverter.h Normal file
View File

@ -0,0 +1,124 @@
#ifndef ENDIANSWAPPER_H_
#define ENDIANSWAPPER_H_
#include <framework/osal/Endiness.h>
#include <cstring>
#include <iostream>
/**
* Helper class to convert variables or bitstreams between machine
* endian and either big or little endian.
* Machine endian is the endianness used by the machine running the
* program and is one of big or little endian. As this is portable
* code, it is not known at coding time which it is. At compile time
* it is however, which is why this is implemented using compiler
* macros and translates to a copy operation at runtime.
*
* This changes the layout of multi-byte variables in the machine's
* memory. In most cases, you should not need to use this class.
* Probably what you are looking for is the SerializeAdapter.
* If you still decide you need this class, please read and understand
* the code first.
*
* The order of the individual bytes of the multi-byte variable is
* reversed, the byte at the highest address is moved to the lowest
* address and vice versa, same for the bytes in between.
*
* Note that the conversion is also its inversion, that is converting
* from machine to a specified endianness is the same operation as
* converting from specified to machine (I looked it up, mathematicians
* would call it an involution):
*
* X == convertBigEndian(convertBigEndian(X))
*
* Thus, there is only one function supplied to do the conversion.
*/
class EndianConverter {
private:
EndianConverter() {};
public:
/**
* Convert a typed variable between big endian and machine endian.
* Intended for plain old datatypes.
*/
template<typename T>
static T convertBigEndian(T in) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
T tmp;
uint8_t *pointerOut = (uint8_t*) &tmp;
uint8_t *pointerIn = (uint8_t*) &in;
for (size_t count = 0; count < sizeof(T); count++) {
pointerOut[sizeof(T) - count - 1] = pointerIn[count];
}
return tmp;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
return in;
#else
#error Unknown Byte Order
#endif
}
/**
* convert a bytestream representing a single variable between big endian
* and machine endian.
*/
static void convertBigEndian(uint8_t *out, const uint8_t *in,
size_t size) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (size_t count = 0; count < size; count++) {
out[size - count - 1] = in[count];
}
return;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(out, in, size);
return;
#endif
}
/**
* Convert a typed variable between little endian and machine endian.
* Intended for plain old datatypes.
*/
template<typename T>
static T convertLittleEndian(T in) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
T tmp;
uint8_t *pointerOut = (uint8_t *) &tmp;
uint8_t *pointerIn = (uint8_t *) &in;
for (size_t count = 0; count < sizeof(T); count++) {
pointerOut[sizeof(T) - count - 1] = pointerIn[count];
}
return tmp;
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
return in;
#else
#error Unknown Byte Order
#endif
}
/**
* convert a bytestream representing a single variable between little endian
* and machine endian.
*/
static void convertLittleEndian(uint8_t *out, const uint8_t *in,
size_t size) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
for (size_t count = 0; count < size; count++) {
out[size - count - 1] = in[count];
}
return;
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
memcpy(out, in, size);
return;
#endif
}
};
#endif /* ENDIANSWAPPER_H_ */

View File

@ -1,90 +0,0 @@
#ifndef ENDIANSWAPPER_H_
#define ENDIANSWAPPER_H_
#include <framework/osal/Endiness.h>
#include <cstring>
#include <iostream>
/**
* @brief Can be used to swap endianness of data
* into big endian
*/
class EndianSwapper {
private:
EndianSwapper() {};
public:
/**
* Swap the endianness of a variable with arbitrary type
* @tparam T Type of variable
* @param in variable
* @return Variable with swapped endianness
*/
template<typename T>
static T swap(T in) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
T tmp;
uint8_t *pointerOut = (uint8_t *) &tmp;
uint8_t *pointerIn = (uint8_t *) &in;
for (uint8_t count = 0; count < sizeof(T); count++) {
pointerOut[sizeof(T) - count - 1] = pointerIn[count];
}
return tmp;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
return in;
#else
#error Unknown Byte Order
#endif
}
/**
* Swap the endianness of a buffer.
* @param out
* @param in
* @param size
*/
static void swap(uint8_t* out, const uint8_t* in, size_t size) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
for (uint8_t count = 0; count < size; count++) {
out[size - count - 1] = in[count];
}
return;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(out, in, size);
return;
#endif
}
/**
* Swap endianness of buffer entries
* Template argument specifies buffer type. The number of entries
* (not the buffer size!) must be supplied
* @param out
* @param in
* @param size Number of buffer entries (not size of buffer in bytes!)
*/
template<typename T>
static void swap(T * out, const T * in, uint32_t entries) {
#ifndef BYTE_ORDER_SYSTEM
#error BYTE_ORDER_SYSTEM not defined
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN
const uint8_t * in_buffer = reinterpret_cast<const uint8_t *>(in);
uint8_t * out_buffer = reinterpret_cast<uint8_t *>(out);
for (uint8_t count = 0; count < entries; count++) {
for(uint8_t i = 0; i < sizeof(T);i++) {
out_buffer[sizeof(T)* (count + 1) - i - 1] =
in_buffer[count * sizeof(T) + i];
}
}
return;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN
memcpy(out, in, size*sizeof(T));
return;
#endif
}
};
#endif /* ENDIANSWAPPER_H_ */

View File

@ -22,26 +22,24 @@ public:
}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return serialize(adaptee, buffer, size, max_size, bigEndian);
size_t maxSize, Endianness streamEndianness) const {
return serialize(adaptee, buffer, size, maxSize, streamEndianness);
}
static ReturnValue_t serialize(const ArrayList<T, count_t>* list,
uint8_t** buffer, size_t* size, const size_t max_size,
bool bigEndian) {
// Serialize length field first
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size,
buffer, size, max_size, bigEndian);
static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::serialize(&list->size,
buffer, size, maxSize, streamEndianness);
count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
maxSize, streamEndianness);
++i;
}
return result;
}
virtual size_t getSerializedSize() const override {
virtual size_t getSerializedSize() const {
return getSerializedSize(adaptee);
}
@ -50,34 +48,31 @@ public:
count_t i = 0;
for (i = 0; i < list->size; ++i) {
printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]);
printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
}
return printSize;
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return deSerialize(adaptee, buffer, size, bigEndian);
Endianness streamEndianness) {
return deSerialize(adaptee, buffer, size, streamEndianness);
}
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list,
const uint8_t** buffer, size_t* size, bool bigEndian) {
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
count_t tempSize = 0;
ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
buffer, size, bigEndian);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
buffer, size, streamEndianness);
if (tempSize > list->maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS;
}
list->size = tempSize;
count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter<T>::deSerialize(
result = SerializeAdapter::deSerialize(
&list->front()[i], buffer, size,
bigEndian);
streamEndianness);
++i;
}
return result;

View File

@ -20,54 +20,54 @@ template<typename count_t>
SerialBufferAdapter<count_t>::~SerialBufferAdapter() {
}
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer_,
size_t* size_, const size_t max_size, bool bigEndian) const {
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(
serializedLength += SerializeAdapter::getSerializedSize(
&bufferLength);
}
if (*size_ + serializedLength > max_size) {
if (*size + serializedLength > maxSize) {
return BUFFER_TOO_SHORT;
} else {
if (serializeLength) {
AutoSerializeAdapter::serialize(&bufferLength, buffer_, size_,
max_size, bigEndian);
SerializeAdapter::serialize(&bufferLength, buffer, size,
maxSize, streamEndianness);
}
if (constBuffer != nullptr) {
memcpy(*buffer_, this->constBuffer, bufferLength);
memcpy(*buffer, this->constBuffer, bufferLength);
}
else if (buffer != nullptr) {
// This will propably be never reached, constBuffer should always be
// set if non-const buffer is set.
memcpy(*buffer_, this->buffer, bufferLength);
memcpy(*buffer, this->buffer, bufferLength);
}
else {
return HasReturnvaluesIF::RETURN_FAILED;
}
*size_ += bufferLength;
(*buffer_) += bufferLength;
*size += bufferLength;
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
}
}
template<typename count_t>
size_t SerialBufferAdapter<count_t>::getSerializedSize() const {
template<typename T>
size_t SerialBufferAdapter<T>::getSerializedSize() const {
if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
} else {
return bufferLength;
}
}
template<typename count_t>
ReturnValue_t SerialBufferAdapter<count_t>::deSerialize(const uint8_t** buffer,
size_t* size, bool bigEndian) {
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
size_t* size, Endianness streamEndianness) {
//TODO Ignores Endian flag!
if (buffer != nullptr) {
if(serializeLength) {
count_t serializedSize = AutoSerializeAdapter::getSerializedSize(
if (buffer != NULL) {
if(serializeLength){
T serializedSize = SerializeAdapter::getSerializedSize(
&bufferLength);
if(bufferLength + serializedSize <= *size) {
*buffer += serializedSize;

View File

@ -45,10 +45,10 @@ public:
virtual ~SerialBufferAdapter();
virtual ReturnValue_t serialize(uint8_t** buffer_, size_t* size,
const size_t max_size, bool bigEndian) const override;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const override;
virtual size_t getSerializedSize() const;
virtual size_t getSerializedSize() const override;
/**
* @brief This function deserializes a buffer into the member buffer.
@ -63,7 +63,7 @@ public:
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override;
Endianness streamEndianness) override;
uint8_t * getBuffer();
const uint8_t * getConstBuffer();

View File

@ -39,32 +39,25 @@ public:
*/
template<typename... Args>
SerialFixedArrayListAdapter(Args... args) :
FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(std::forward<Args>(args)...)
{}
FixedArrayList<BUFFER_TYPE, MAX_SIZE, count_t>(
std::forward<Args>(args)...){}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::serialize(this,
buffer, size, max_size, bigEndian);
buffer, size, maxSize, streamEndianness);
}
size_t getSerializedSize() const {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::
getSerializedSize(this);
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::getSerializedSize(this);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
return SerialArrayListAdapter<BUFFER_TYPE, count_t>::deSerialize(this,
buffer, size, bigEndian);
buffer, size, streamEndianness);
}
void swapArrayListEndianness() {
SerialArrayListAdapter<BUFFER_TYPE, count_t>::
swapArrayListEndianness(this);
}
};
#endif /* SERIALFIXEDARRAYLISTADAPTER_H_ */

View File

@ -67,44 +67,32 @@ public:
SinglyLinkedList<T>(), printCount(printCount) {
}
/**
* Serialize object implementing this adapter into the supplied buffer
* and calculate the serialized size
* @param buffer [out] Object is serialized into this buffer.
* Note that the buffer pointer *buffer is incremented automatically
* inside the respective serialize functions
* @param size [out] Calculated serialized size. Don't forget to set to 0.
* @param max_size
* @param bigEndian Specify endianness
* @return
*/
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override{
size_t maxSize, Endianness streamEndianness) const override {
if (printCount) {
count_t mySize = SinglyLinkedList<T>::getSize();
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize,
buffer, size, max_size, bigEndian);
ReturnValue_t result = SerializeAdapter::serialize(&mySize,
buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
return serialize(SinglyLinkedList<T>::start, buffer, size, max_size,
bigEndian);
return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
streamEndianness);
}
static ReturnValue_t serialize(const LinkedElement<T>* element,
uint8_t** buffer, size_t* size, const size_t max_size,
bool bigEndian) {
uint8_t** buffer, size_t* size, size_t maxSize,
Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
result = element->value->serialize(buffer, size, max_size,
bigEndian);
result = element->value->serialize(buffer, size, maxSize,
streamEndianness);
element = element->getNext();
}
return result;
}
virtual size_t getSerializedSize() const override {
if (printCount) {
return SerialLinkedListAdapter<T>::getSerializedSize()
@ -114,8 +102,8 @@ public:
}
}
static uint32_t getSerializedSize(const LinkedElement<T> *element) {
uint32_t size = 0;
static size_t getSerializedSize(const LinkedElement<T> *element) {
size_t size = 0;
while (element != NULL) {
size += element->value->getSerializedSize();
element = element->getNext();
@ -124,24 +112,16 @@ public:
}
/**
* Deserialize supplied buffer with supplied size into object
* implementing this adapter.
* @param buffer
* @param size Decremented in respective deSerialize functions automatically
* @param bigEndian Specify endianness
* @return
*/
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian);
Endianness streamEndianness) override {
return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
}
static ReturnValue_t deSerialize(LinkedElement<T>* element,
const uint8_t** buffer, size_t* size, bool bigEndian) {
const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
result = element->value->deSerialize(buffer, size, bigEndian);
result = element->value->deSerialize(buffer, size, streamEndianness);
element = element->getNext();
}
return result;

View File

@ -1,9 +1,10 @@
#ifndef SERIALIZEADAPTER_H_
#define SERIALIZEADAPTER_H_
#include <framework/container/IsDerivedFrom.h>
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/serialize/EndianConverter.h>
#include <framework/serialize/SerializeIF.h>
#include <framework/serialize/SerializeAdapterInternal.h>
#include <type_traits>
/**
@ -62,61 +63,113 @@
* @ingroup serialize
*/
// No type specification necessary here.
class AutoSerializeAdapter {
public:
/**
* Serialize object into buffer.
* @tparam T Type of object.
* @param object Object to serialize
* @param buffer
* Serialize into this buffer, pointer to pointer has to be passed,
* *buffer will be incremented automatically.
* @param size [out]
* Update passed size value, will be incremented by serialized size
* @param max_size
* Maximum size for range checking
* @param bigEndian
* Set to true if host-to-network conversion or vice-versa is needed
* @return
*/
template<typename T>
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, max_size, bigEndian);
}
template<typename T>
static size_t getSerializedSize(const T* object) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.getSerializedSize(object);
}
template<typename T>
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
size_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}
};
template<typename T>
class SerializeAdapter {
public:
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, max_size, bigEndian);
template<typename T>
static ReturnValue_t serialize(const T *object, uint8_t **buffer,
size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, maxSize,
streamEndianness);
}
static uint32_t getSerializedSize(const T* object) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
template<typename T>
static uint32_t getSerializedSize(const T *object) {
InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.getSerializedSize(object);
}
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
size_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
template<typename T>
static ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
size_t *size, SerializeIF::Endianness streamEndianness) {
InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, streamEndianness);
}
private:
template<typename T, int>
class InternalSerializeAdapter {
public:
static ReturnValue_t serialize(const T *object, uint8_t **buffer,
size_t *size, size_t max_size, SerializeIF::Endianness streamEndianness) {
size_t ignoredSize = 0;
if (size == NULL) {
size = &ignoredSize;
}
//TODO check integer overflow of *size
if (sizeof(T) + *size <= max_size) {
T tmp;
switch (streamEndianness) {
case SerializeIF::Endianness::BIG:
tmp = EndianConverter::convertBigEndian<T>(*object);
break;
case SerializeIF::Endianness::LITTLE:
tmp = EndianConverter::convertLittleEndian<T>(*object);
break;
default:
case SerializeIF::Endianness::MACHINE:
tmp = *object;
break;
}
memcpy(*buffer, &tmp, sizeof(T));
*size += sizeof(T);
(*buffer) += sizeof(T);
return HasReturnvaluesIF::RETURN_OK;
} else {
return SerializeIF::BUFFER_TOO_SHORT;
}
}
ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
size_t *size, SerializeIF::Endianness streamEndianness) {
T tmp;
if (*size >= sizeof(T)) {
*size -= sizeof(T);
memcpy(&tmp, *buffer, sizeof(T));
switch (streamEndianness) {
case SerializeIF::Endianness::BIG:
*object = EndianConverter::convertBigEndian<T>(tmp);
break;
case SerializeIF::Endianness::LITTLE:
*object = EndianConverter::convertLittleEndian<T>(tmp);
break;
default:
case SerializeIF::Endianness::MACHINE:
*object = tmp;
break;
}
*buffer += sizeof(T);
return HasReturnvaluesIF::RETURN_OK;
} else {
return SerializeIF::STREAM_TOO_SHORT;
}
}
uint32_t getSerializedSize(const T *object) {
return sizeof(T);
}
};
template<typename T>
class InternalSerializeAdapter<T, 1> {
public:
ReturnValue_t serialize(const T *object, uint8_t **buffer,
size_t *size, size_t max_size,
SerializeIF::Endianness streamEndianness) const {
size_t ignoredSize = 0;
if (size == NULL) {
size = &ignoredSize;
}
return object->serialize(buffer, size, max_size, streamEndianness);
}
uint32_t getSerializedSize(const T *object) const {
return object->getSerializedSize();
}
ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
size_t *size, SerializeIF::Endianness streamEndianness) {
return object->deSerialize(buffer, size, streamEndianness);
}
};
};
#endif /* SERIALIZEADAPTER_H_ */

View File

@ -1,118 +0,0 @@
/**
* @file SerializeAdapterInternal.h
*
* @date 13.04.2020
* @author R. Mueller
*/
#ifndef FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
#define FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/container/IsDerivedFrom.h>
#include <framework/serialize/EndianSwapper.h>
/**
* This template specialization will be chosen for fundamental types or
* anything else not implementing SerializeIF, based on partial
* template specialization.
* @tparam T
* @tparam
*/
template<typename T, int>
class SerializeAdapter_ {
public:
/**
*
* @param object
* @param buffer
* @param size
* @param max_size
* @param bigEndian
* @return
*/
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
size_t* size, const size_t max_size, bool bigEndian) {
// function eventuelly serializes structs here.
// does this work on every architecture?
// static_assert(std::is_fundamental<T>::value);
size_t ignoredSize = 0;
if (size == nullptr) {
size = &ignoredSize;
}
if (sizeof(T) + *size <= max_size) {
T tmp;
if (bigEndian) {
tmp = EndianSwapper::swap<T>(*object);
} else {
tmp = *object;
}
memcpy(*buffer, &tmp, sizeof(T));
*size += sizeof(T);
(*buffer) += sizeof(T);
return HasReturnvaluesIF::RETURN_OK;
} else {
return SerializeIF::BUFFER_TOO_SHORT;
}
}
/**
* Deserialize buffer into object
* @param object [out] Object to be deserialized with buffer data
* @param buffer contains the data. Non-Const pointer to non-const
* pointer to const data.
* @param size Size to deSerialize. wil be decremented by sizeof(T)
* @param bigEndian Specify endianness
* @return
*/
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
bool bigEndian) {
T tmp;
if (*size >= sizeof(T)) {
*size -= sizeof(T);
memcpy(&tmp, *buffer, sizeof(T));
if (bigEndian) {
*object = EndianSwapper::swap<T>(tmp);
} else {
*object = tmp;
}
*buffer += sizeof(T);
return HasReturnvaluesIF::RETURN_OK;
} else {
return SerializeIF::STREAM_TOO_SHORT;
}
}
size_t getSerializedSize(const T * object) {
return sizeof(T);
}
};
/**
* This template specialization will be chosen for class derived from
* SerializeIF, based on partial template specialization.
* @tparam T
* @tparam
*/
template<typename T>
class SerializeAdapter_<T, true> {
public:
ReturnValue_t serialize(const T* object, uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
size_t ignoredSize = 0;
if (size == NULL) {
size = &ignoredSize;
}
return object->serialize(buffer, size, max_size, bigEndian);
}
size_t getSerializedSize(const T* object) const {
return object->getSerializedSize();
}
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, size_t* size,
bool bigEndian) {
return object->deSerialize(buffer, size, bigEndian);
}
};
#endif /* FRAMEWORK_SERIALIZE_SERIALIZEADAPTERINTERNAL_H_ */

View File

@ -17,49 +17,44 @@
* @ingroup serialize
*/
template<typename T>
class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
public:
/**
* Arguments are forwarded to the element datatype constructor
* @param args
*/
template<typename... Args>
SerializeElement(Args... args):
LinkedElement<SerializeIF>(this),
entry(std::forward<Args>(args)...) {}
SerializeElement() : LinkedElement<SerializeIF>(this) {}
template<typename ... Args>
SerializeElement(Args ... args) :
LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
}
SerializeElement() :
LinkedElement<SerializeIF>(this) {
}
T entry;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const override {
return SerializeAdapter<T>::serialize(&entry, buffer, size,
max_size, bigEndian);
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
Endianness streamEndianness) const override {
return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
streamEndianness);
}
size_t getSerializedSize() const {
return SerializeAdapter<T>::getSerializedSize(&entry);
size_t getSerializedSize() const override {
return SerializeAdapter::getSerializedSize(&entry);
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) override {
return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian);
virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) override {
return SerializeAdapter::deSerialize(&entry, buffer, size,
streamEndianness);
}
operator T() {
return entry;
}
SerializeElement<T> &operator=(T newValue) {
SerializeElement<T>& operator=(T newValue) {
entry = newValue;
return *this;
}
T *operator->() {
T* operator->() {
return &entry;
}
};
#endif /* SERIALIZEELEMENT_H_ */

View File

@ -33,6 +33,10 @@
*/
class SerializeIF {
public:
enum class Endianness : uint8_t {
BIG, LITTLE, MACHINE
};
static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF;
static const ReturnValue_t BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
@ -41,13 +45,13 @@ public:
virtual ~SerializeIF() {
}
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const = 0;
virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
size_t maxSize, Endianness streamEndianness) const = 0;
virtual size_t getSerializedSize() const = 0;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) = 0;
virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
Endianness streamEndianness) = 0;
};

View File

@ -75,7 +75,8 @@ void Subsystem::performChildOperation() {
if (isInTransition) {
if (commandsOutstanding <= 0) { //all children of the current table were commanded and replied
if (currentSequenceIterator.value == NULL) { //we're through with this sequence
if (checkStateAgainstTable(currentTargetTable, targetSubmode) == RETURN_OK) {
if (checkStateAgainstTable(currentTargetTable, targetSubmode)
== RETURN_OK) {
setMode(targetMode, targetSubmode);
isInTransition = false;
return;
@ -86,7 +87,8 @@ void Subsystem::performChildOperation() {
}
}
if (currentSequenceIterator->checkSuccess()) {
if (checkStateAgainstTable(getCurrentTable(), targetSubmode) != RETURN_OK) {
if (checkStateAgainstTable(getCurrentTable(), targetSubmode)
!= RETURN_OK) {
transitionFailed(TABLE_CHECK_FAILED,
currentSequenceIterator->getTableId());
return;
@ -117,7 +119,8 @@ void Subsystem::performChildOperation() {
childrenChangedHealth = false;
startTransition(mode, submode);
} else if (childrenChangedMode) {
if (checkStateAgainstTable(currentTargetTable, submode) != RETURN_OK) {
if (checkStateAgainstTable(currentTargetTable, submode)
!= RETURN_OK) {
triggerEvent(CANT_KEEP_MODE, mode, submode);
cantKeepMode();
}
@ -147,7 +150,7 @@ HybridIterator<ModeListEntry> Subsystem::getTable(Mode_t id) {
}
}
ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
ReturnValue_t Subsystem::handleCommandMessage(CommandMessage *message) {
ReturnValue_t result;
switch (message->getCommand()) {
case HealthMessage::HEALTH_INFO: {
@ -169,11 +172,12 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
if (result == RETURN_OK) {
Mode_t fallbackId;
size_t size = sizeRead;
result = SerializeAdapter<Mode_t>::deSerialize(&fallbackId,
&pointer, &size, true);
result = SerializeAdapter::deSerialize(&fallbackId, &pointer, &size,
SerializeIF::Endianness::BIG);
if (result == RETURN_OK) {
result = SerialArrayListAdapter<ModeListEntry>::deSerialize(
&sequence, &pointer, &size, true);
&sequence, &pointer, &size,
SerializeIF::Endianness::BIG);
if (result == RETURN_OK) {
result = addSequence(&sequence,
ModeSequenceMessage::getSequenceId(message),
@ -195,7 +199,7 @@ ReturnValue_t Subsystem::handleCommandMessage(CommandMessage* message) {
if (result == RETURN_OK) {
size_t size = sizeRead;
result = SerialArrayListAdapter<ModeListEntry>::deSerialize(&table,
&pointer, &size, true);
&pointer, &size, SerializeIF::Endianness::BIG);
if (result == RETURN_OK) {
result = addTable(&table,
ModeSequenceMessage::getSequenceId(message));
@ -339,7 +343,7 @@ void Subsystem::replyToCommand(ReturnValue_t status, uint32_t parameter) {
}
}
ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry>* sequence,
ReturnValue_t Subsystem::addSequence(ArrayList<ModeListEntry> *sequence,
Mode_t id, Mode_t fallbackSequence, bool inStore, bool preInit) {
ReturnValue_t result;
@ -507,7 +511,7 @@ MessageQueueId_t Subsystem::getSequenceCommandQueue() const {
}
ReturnValue_t Subsystem::checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t* msToReachTheMode) {
uint32_t *msToReachTheMode) {
//Need to accept all submodes to be able to inherit submodes
// if (submode != SUBMODE_NONE) {
// return INVALID_SUBMODE;
@ -599,7 +603,7 @@ void Subsystem::transitionFailed(ReturnValue_t failureCode,
}
void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
SerializeIF** elements, uint8_t count) {
SerializeIF **elements, uint8_t count) {
ReturnValue_t result;
size_t maxSize = 0;
for (uint8_t i = 0; i < count; i++) {
@ -615,7 +619,8 @@ void Subsystem::sendSerializablesAsCommandMessage(Command_t command,
return;
}
for (uint8_t i = 0; i < count; i++) {
elements[i]->serialize(&storeBuffer, &size, maxSize, true);
elements[i]->serialize(&storeBuffer, &size, maxSize,
SerializeIF::Endianness::BIG);
}
CommandMessage reply;
ModeSequenceMessage::setModeSequenceMessage(&reply, command, address);

View File

@ -19,31 +19,31 @@ public:
uint8_t value4;
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result;
result = SerializeAdapter<uint32_t>::serialize(&value1, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&value1, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint32_t>::serialize(&value2, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&value2, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&value3, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&value3, buffer, size,
maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::serialize(&value4, buffer, size,
max_size, bigEndian);
result = SerializeAdapter::serialize(&value4, buffer, size,
maxSize, streamEndianness);
return result;
@ -54,29 +54,29 @@ public:
}
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
Endianness streamEndianness) {
ReturnValue_t result;
result = SerializeAdapter<uint32_t>::deSerialize(&value1, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&value1, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint32_t>::deSerialize(&value2, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&value2, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::deSerialize(&value3, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&value3, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = SerializeAdapter<uint8_t>::deSerialize(&value4, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&value4, buffer, size,
streamEndianness);
return result;
}

View File

@ -45,14 +45,14 @@ ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
return MonitoringIF::INVALID_SIZE;
}
size_t readSize = size;
SerializeAdapter<float>::deSerialize(&nopParameters.lowerNopLimit, &data,
&readSize, true);
SerializeAdapter<float>::deSerialize(&parameters.lowerOpLimit, &data,
&readSize, true);
SerializeAdapter<float>::deSerialize(&parameters.upperOpLimit, &data,
&readSize, true);
SerializeAdapter<float>::deSerialize(&nopParameters.upperNopLimit, &data,
&readSize, true);
SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
&readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&parameters.lowerOpLimit, &data,
&readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&parameters.upperOpLimit, &data,
&readSize, SerializeIF::Endianness::BIG);
SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
&readSize, SerializeIF::Endianness::BIG);
return HasReturnvaluesIF::RETURN_OK;
}

View File

@ -33,14 +33,14 @@ public:
uint16_t apid;
uint16_t ssc;
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid,
buffer, size, max_size, bigEndian);
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<uint16_t>::serialize(&ssc, buffer, size,
max_size, bigEndian);
return SerializeAdapter::serialize(&ssc, buffer, size,
maxSize, streamEndianness);
}
@ -49,14 +49,14 @@ public:
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid,
buffer, size, bigEndian);
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size,
bigEndian);
return SerializeAdapter::deSerialize(&ssc, buffer, size,
streamEndianness);
}
};
@ -219,38 +219,38 @@ public:
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian);
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian);
result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){
return result;
}
result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian);
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,max_size,bigEndian);
return adapter.serialize(buffer,size,maxSize,streamEndianness);
}
size_t getSerializedSize() const {
uint32_t size = 0;
size += AutoSerializeAdapter::getSerializedSize(&apid);
size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount);
size += AutoSerializeAdapter::getSerializedSize(&serviceType);
size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype);
size += AutoSerializeAdapter::getSerializedSize(&subCounter);
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;
@ -258,34 +258,34 @@ public:
};
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer,
size, bigEndian);
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
size, bigEndian);
result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size,
bigEndian);
result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer,
size, bigEndian);
result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size,
bigEndian);
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,bigEndian);
return adapter.deSerialize(buffer,size,streamEndianness);
}
private:

View File

@ -23,17 +23,15 @@ public:
}
}
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const size_t max_size, bool bigEndian) const {
return SerializeAdapter<uint16_t>::serialize(&apid, buffer,
size, max_size, bigEndian);
size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&apid, buffer, size, maxSize, streamEndianness);
}
size_t getSerializedSize() const {
return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
return SerializeAdapter::getSerializedSize(&apid);
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer,
size, bigEndian);
Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&apid, buffer, size, streamEndianness);
}
};

View File

@ -23,17 +23,15 @@ public:
}
}
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);
size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
}
size_t getSerializedSize() const {
return SerializeAdapter<uint8_t>::getSerializedSize(&service);
return SerializeAdapter::getSerializedSize(&service);
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<uint8_t>::deSerialize(&service, buffer,
size, bigEndian);
Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
}
};

View File

@ -21,17 +21,15 @@ public:
}
}
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);
size_t maxSize, Endianness streamEndianness) const {
return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
}
size_t getSerializedSize() const {
return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
return SerializeAdapter::getSerializedSize(&subService);
}
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) {
return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer,
size, bigEndian);
Endianness streamEndianness) {
return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
}
private:
uint8_t subService;

View File

@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
}
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data,
uint32_t size, const uint8_t* headerData, uint32_t headerSize) :
uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) {
return;
}
uint8_t* pData = NULL;
uint8_t *pData = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
@ -35,8 +35,8 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
}
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content,
SerializeIF* header) :
uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
SerializeIF *header) :
TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) {
@ -49,7 +49,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
if (header != NULL) {
sourceDataSize += header->getSerializedSize();
}
uint8_t* p_data = NULL;
uint8_t *p_data = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
if (returnValue != store->RETURN_OK) {
@ -57,13 +57,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
}
setData(p_data);
initializeTmPacket(apid, service, subservice, packetSubcounter);
uint8_t* putDataHere = getSourceData();
uint8_t *putDataHere = getSourceData();
size_t size = 0;
if (header != NULL) {
header->serialize(&putDataHere, &size, sourceDataSize, true);
header->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
}
if (content != NULL) {
content->serialize(&putDataHere, &size, sourceDataSize, true);
content->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
}
setPacketDataLength(
sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@ -81,7 +83,7 @@ void TmPacketStored::deletePacket() {
void TmPacketStored::setStoreAddress(store_address_t setAddress) {
storeAddress = setAddress;
const uint8_t* temp_data = NULL;
const uint8_t *temp_data = NULL;
size_t temp_size;
if (!checkAndSetStore()) {
return;
@ -107,8 +109,8 @@ bool TmPacketStored::checkAndSetStore() {
return true;
}
StorageManagerIF* TmPacketStored::store = NULL;
InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL;
StorageManagerIF *TmPacketStored::store = NULL;
InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
MessageQueueId_t sentFrom, bool doErrorReporting) {

View File

@ -268,8 +268,8 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
uint8_t buffer[sizeof(object_id_t)];
uint8_t* pBuffer = buffer;
size_t size = 0;
SerializeAdapter<object_id_t>::serialize(&objectId, &pBuffer, &size,
sizeof(object_id_t), true);
SerializeAdapter::serialize(&objectId, &pBuffer, &size,
sizeof(object_id_t), SerializeIF::Endianness::BIG);
TmPacketStored tmPacketStored(this->apid, this->service, subservice,
this->tmPacketCounter, data, dataLen, buffer, size);
ReturnValue_t result = tmPacketStored.sendPacket(

View File

@ -10,7 +10,7 @@
#include <framework/tmtcservices/VerificationReporter.h>
#include <framework/ipc/CommandMessage.h>
#include <framework/container/FixedMap.h>
#include <framework/container/FIFO.h>
#include <framework/container/StaticFIFO.h>
#include <framework/serialize/SerializeIF.h>
class TcPacketStored;
@ -89,7 +89,7 @@ public:
*/
virtual MessageQueueId_t getCommandQueue();
virtual ReturnValue_t initialize();
virtual ReturnValue_t initialize() override;
/**
* Implementation of ExecutableObjectIF function
@ -199,7 +199,7 @@ protected:
uint32_t state;
Command_t command;
object_id_t objectId;
FIFO<store_address_t, 3> fifo;
fsfw::StaticFIFO<store_address_t, 3> fifo;
};
using CommandMapIter = FixedMap<MessageQueueId_t,

115
tmtcservices/PusParser.cpp Normal file
View File

@ -0,0 +1,115 @@
#include <framework/tmtcservices/PusParser.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
PusParser::PusParser(uint16_t maxExpectedPusPackets,
bool storeSplitPackets): indexSizePairFIFO(maxExpectedPusPackets) {
}
ReturnValue_t PusParser::parsePusPackets(const uint8_t *frame,
size_t frameSize) {
if(frame == nullptr) {
sif::error << "PusParser::parsePusPackets: Frame pointers in invalid!"
<< std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
if(indexSizePairFIFO.full()) {
sif::error << "PusParser::parsePusPackets: FIFO is full!" << std::endl;
return HasReturnvaluesIF::RETURN_FAILED;
}
size_t lengthField = frame[4] << 8 | frame[5];
if(lengthField == 0) {
return NO_PACKET_FOUND;
}
size_t packetSize = lengthField + 7;
// Size of a pus packet is the value in the packet length field plus 7.
if(packetSize > frameSize)
{
if(storeSplitPackets)
{
indexSizePairFIFO.insert(indexSizePair(0, frameSize));
}
else
{
sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
"larger than remaining frame," << std::endl;
sif::debug << "Throwing away packet. Detected packet size: "
<< packetSize << std::endl;
}
return SPLIT_PACKET;
}
else
{
indexSizePairFIFO.insert(indexSizePair(0, packetSize));
if(packetSize == frameSize) {
return HasReturnvaluesIF::RETURN_OK;
}
}
// packet size is smaller than frame size, parse for more packets.
return readMultiplePackets(frame, frameSize, packetSize);
}
ReturnValue_t PusParser::readMultiplePackets(const uint8_t *frame,
size_t frameSize, size_t startIndex) {
while (startIndex < frameSize) {
ReturnValue_t result = readNextPacket(frame, frameSize, startIndex);
if(result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
}
return HasReturnvaluesIF::RETURN_OK;
}
fsfw::FIFO<PusParser::indexSizePair>* PusParser::fifo(){
return &indexSizePairFIFO;
}
PusParser::indexSizePair PusParser::getNextFifoPair() {
indexSizePair nextIndexSizePair;
indexSizePairFIFO.retrieve(&nextIndexSizePair);
return nextIndexSizePair;
}
ReturnValue_t PusParser::readNextPacket(const uint8_t *frame,
size_t frameSize, size_t& currentIndex) {
// sif::debug << startIndex << std::endl;
uint16_t lengthField = frame[currentIndex + 4] << 8 |
frame[currentIndex + 5];
if(lengthField == 0) {
// It is assumed that no packet follows.
currentIndex = frameSize;
return HasReturnvaluesIF::RETURN_OK;
}
size_t nextPacketSize = lengthField + 7;
size_t remainingSize = frameSize - currentIndex;
if(nextPacketSize > remainingSize)
{
if(storeSplitPackets)
{
indexSizePairFIFO.insert(indexSizePair(currentIndex, remainingSize));
}
else
{
sif::debug << "TcSerialPollingTask::readNextPacket: Next packet "
"larger than remaining frame," << std::endl;
sif::debug << "Throwing away packet. Detected packet size: "
<< nextPacketSize << std::endl;
}
return SPLIT_PACKET;
}
ReturnValue_t result = indexSizePairFIFO.insert(indexSizePair(currentIndex,
nextPacketSize));
if (result != HasReturnvaluesIF::RETURN_OK) {
// FIFO full.
sif::debug << "PusParser: Issue inserting into start index size "
"FIFO, it is full!" << std::endl;
}
currentIndex += nextPacketSize;
return result;
}

82
tmtcservices/PusParser.h Normal file
View File

@ -0,0 +1,82 @@
#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
#include <framework/container/FIFO.h>
#include <utility>
#include <cstdint>
/**
* @brief This small helper class scans a given buffer for PUS packets.
* Can be used if PUS packets are serialized in a tightly packed frame.
* @details
* The parser uses the payload length field of PUS packets to find
* the respective PUS packet sizes.
*
* The parser parses a buffer by taking a pointer and the maximum size to scan.
* If PUS packets are found, they are stored in a FIFO which stores pairs
* consisting of the index in the buffer and the respective packet sizes.
*
* If the parser detects split packets (which means that the size of the
* next packet is larger than the remaining size to scan), it can either
* store that split packet or throw away the packet.
*/
class PusParser {
public:
//! The first entry is the index inside the buffer while the second index
//! is the size of the PUS packet starting at that index.
using indexSizePair = std::pair<size_t, size_t>;
static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
/**
* Parser constructor.
* @param maxExpectedPusPackets
* Maximum expected number of PUS packets. A good estimate is to divide
* the frame size by the minimum size of a PUS packet (12 bytes)
* @param storeSplitPackets
* Specifies whether split packets are also stored inside the FIFO,
* with the size being the remaining frame size.
*/
PusParser(uint16_t maxExpectedPusPackets, bool storeSplitPackets);
/**
* Parse a given frame for PUS packets
* @param frame
* @param frameSize
* @return -@c NO_PACKET_FOUND if no packet was found.
*/
ReturnValue_t parsePusPackets(const uint8_t* frame, size_t frameSize);
/**
* Accessor function to get a reference to the internal FIFO which
* stores pairs of indexi and packet sizes. This FIFO is filled
* by the parsePusPackets() function.
* @return
*/
fsfw::FIFO<indexSizePair>* fifo();
/**
* Retrieve the next index and packet size pair from the FIFO.
* This also removed it from the FIFO. Please note that if the FIFO
* is empty, an empty pair will be returned.
* @return
*/
indexSizePair getNextFifoPair();
private:
//! A FIFO is used to store information about multiple PUS packets
//! inside the receive buffer. The maximum number of entries is defined
//! by the first constructor argument.
fsfw::FIFO<indexSizePair> indexSizePairFIFO;
bool storeSplitPackets = false;
ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
size_t startIndex);
ReturnValue_t readNextPacket(const uint8_t *frame,
size_t frameSize, size_t& startIndex);
};
#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

View File

@ -33,7 +33,7 @@ PusVerificationMessage::PusVerificationMessage(uint8_t set_report_id,
uint8_t ackFlags, uint16_t tcPacketId, uint16_t tcSequenceControl,
ReturnValue_t set_error_code, uint8_t set_step, uint32_t parameter1,
uint32_t parameter2) {
uint8_t* data = this->getBuffer();
uint8_t *data = this->getBuffer();
data[messageSize] = set_report_id;
messageSize += sizeof(set_report_id);
data[messageSize] = ackFlags;
@ -108,13 +108,13 @@ PusSuccessReport::PusSuccessReport(uint16_t setPacketId,
uint16_t setSequenceControl, uint8_t setStep) :
reportSize(0), pBuffer(reportBuffer) {
//Serialization won't fail, because we know the necessary max-size of the buffer.
SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
&reportSize, sizeof(reportBuffer), true);
SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
if (setStep != 0) {
SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
}
}
@ -135,26 +135,26 @@ PusFailureReport::PusFailureReport(uint16_t setPacketId,
uint8_t setStep, uint32_t parameter1, uint32_t parameter2) :
reportSize(0), pBuffer(reportBuffer) {
//Serialization won't fail, because we know the necessary max-size of the buffer.
SerializeAdapter<uint16_t>::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter<uint16_t>::serialize(&setSequenceControl, &pBuffer,
&reportSize, sizeof(reportBuffer), true);
SerializeAdapter::serialize(&setPacketId, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&setSequenceControl, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
if (setStep != 0) {
SerializeAdapter<uint8_t>::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter::serialize(&setStep, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
}
SerializeAdapter<ReturnValue_t>::serialize(&setErrorCode, &pBuffer,
&reportSize, sizeof(reportBuffer), true);
SerializeAdapter<uint32_t>::serialize(&parameter1, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter<uint32_t>::serialize(&parameter2, &pBuffer, &reportSize,
sizeof(reportBuffer), true);
SerializeAdapter::serialize(&setErrorCode, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&parameter1, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
SerializeAdapter::serialize(&parameter2, &pBuffer, &reportSize,
sizeof(reportBuffer), SerializeIF::Endianness::BIG);
}
PusFailureReport::~PusFailureReport() {
}
uint32_t PusFailureReport::getSize() {
size_t PusFailureReport::getSize() {
return reportSize;
}

Some files were not shown because too many files have changed in this diff Show More