Merge remote-tracking branch 'upstream/master' into mueller_FIFO_static_normal

This commit is contained in:
Robin Müller 2020-07-28 13:07:35 +02:00
commit 802004107b
75 changed files with 1396 additions and 1228 deletions

View File

@ -71,18 +71,18 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
CommandMessage reply; CommandMessage reply;
store_address_t storeAddress; store_address_t storeAddress;
uint8_t *dataPtr; uint8_t *dataPtr;
uint32_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();
if (maxSize == 0) { if (maxSize == 0) {
//No error, there's simply nothing to report. //No error, there's simply nothing to report.
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
uint32_t size = 0; size_t size = 0;
ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize, ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
&dataPtr); &dataPtr);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = data->serialize(&dataPtr, &size, maxSize, true); result = data->serialize(&dataPtr, &size, maxSize, SerializeIF::Endianness::BIG);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
ipcStore->deleteData(storeAddress); ipcStore->deleteData(storeAddress);
return result; return result;

View File

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

View File

@ -148,47 +148,47 @@ public:
return theMap.maxSize(); return theMap.maxSize();
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter<uint32_t>::serialize(&this->_size, ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
uint32_t i = 0; uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter<key_t>::serialize(&theMap[i].first, buffer, result = SerializeAdapter::serialize(&theMap[i].first, buffer,
size, max_size, bigEndian); size, maxSize, streamEndianness);
result = SerializeAdapter<T>::serialize(&theMap[i].second, buffer, size, result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
++i; ++i;
} }
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
uint32_t printSize = sizeof(_size); uint32_t printSize = sizeof(_size);
uint32_t i = 0; uint32_t i = 0;
for (i = 0; i < _size; ++i) { for (i = 0; i < _size; ++i) {
printSize += SerializeAdapter<key_t>::getSerializedSize( printSize += SerializeAdapter::getSerializedSize(
&theMap[i].first); &theMap[i].first);
printSize += SerializeAdapter<T>::getSerializedSize(&theMap[i].second); printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
} }
return printSize; return printSize;
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter<uint32_t>::deSerialize(&this->_size, ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (this->_size > theMap.maxSize()) { if (this->_size > theMap.maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS; return SerializeIF::TOO_MANY_ELEMENTS;
} }
uint32_t i = 0; uint32_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
result = SerializeAdapter<key_t>::deSerialize(&theMap[i].first, buffer, result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
size, bigEndian); size, streamEndianness);
result = SerializeAdapter<T>::deSerialize(&theMap[i].second, buffer, size, result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
bigEndian); streamEndianness);
++i; ++i;
} }
return result; return result;

View File

@ -1,5 +1,5 @@
#ifndef HYBRIDITERATOR_H_ #ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
#define HYBRIDITERATOR_H_ #define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
#include <framework/container/ArrayList.h> #include <framework/container/ArrayList.h>
#include <framework/container/SinglyLinkedList.h> #include <framework/container/SinglyLinkedList.h>
@ -8,34 +8,32 @@ template<typename T, typename count_t = uint8_t>
class HybridIterator: public LinkedElement<T>::Iterator, class HybridIterator: public LinkedElement<T>::Iterator,
public ArrayList<T, count_t>::Iterator { public ArrayList<T, count_t>::Iterator {
public: public:
HybridIterator() : HybridIterator() {}
value(NULL), linked(NULL), end(NULL) {
}
HybridIterator(typename LinkedElement<T>::Iterator *iter) : HybridIterator(typename LinkedElement<T>::Iterator *iter) :
LinkedElement<T>::Iterator(*iter), value( LinkedElement<T>::Iterator(*iter), value(iter->value),
iter->value), linked(true), end(NULL) { linked(true) {
} }
HybridIterator(LinkedElement<T> *start) : HybridIterator(LinkedElement<T> *start) :
LinkedElement<T>::Iterator(start), value( LinkedElement<T>::Iterator(start), value(start->value),
start->value), linked(true), end(NULL) { linked(true) {
} }
HybridIterator(typename ArrayList<T, count_t>::Iterator start, HybridIterator(typename ArrayList<T, count_t>::Iterator start,
typename ArrayList<T, count_t>::Iterator end) : typename ArrayList<T, count_t>::Iterator end) :
ArrayList<T, count_t>::Iterator(start), value(start.value), linked( ArrayList<T, count_t>::Iterator(start), value(start.value),
false), end(end.value) { linked(false), end(end.value) {
if (value == this->end) { if (value == this->end) {
value = NULL; value = NULL;
} }
} }
HybridIterator(T *firstElement, T *lastElement) : HybridIterator(T *firstElement, T *lastElement) :
ArrayList<T, count_t>::Iterator(firstElement), value(firstElement), linked( ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
false), end(++lastElement) { linked(false), end(++lastElement) {
if (value == end) { if (value == end) {
value = NULL; value = NULL;
} }
@ -44,17 +42,17 @@ public:
HybridIterator& operator++() { HybridIterator& operator++() {
if (linked) { if (linked) {
LinkedElement<T>::Iterator::operator++(); LinkedElement<T>::Iterator::operator++();
if (LinkedElement<T>::Iterator::value != NULL) { if (LinkedElement<T>::Iterator::value != nullptr) {
value = LinkedElement<T>::Iterator::value->value; value = LinkedElement<T>::Iterator::value->value;
} else { } else {
value = NULL; value = nullptr;
} }
} else { } else {
ArrayList<T, count_t>::Iterator::operator++(); ArrayList<T, count_t>::Iterator::operator++();
value = ArrayList<T, count_t>::Iterator::value; value = ArrayList<T, count_t>::Iterator::value;
if (value == end) { if (value == end) {
value = NULL; value = nullptr;
} }
} }
return *this; return *this;
@ -66,11 +64,11 @@ public:
return tmp; return tmp;
} }
bool operator==(HybridIterator other) { bool operator==(const HybridIterator& other) const {
return value == other->value; return value == other.value;
} }
bool operator!=(HybridIterator other) { bool operator!=(const HybridIterator& other) const {
return !(*this == other); return !(*this == other);
} }
@ -82,11 +80,11 @@ public:
return value; return value;
} }
T* value; T* value = nullptr;
private: private:
bool linked; bool linked = false;
T *end; T *end = nullptr;
}; };
#endif /* HYBRIDITERATOR_H_ */ #endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

View File

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

View File

@ -39,10 +39,10 @@ PoolEntryIF* DataPool::getRawData( uint32_t data_pool_id ) {
} }
} }
//uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t max_size ) { //uint8_t DataPool::getRawData( uint32_t data_pool_id, uint8_t* address, uint16_t* size, uint32_t maxSize ) {
// std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id ); // std::map<uint32_t, PoolEntryIF*>::iterator it = this->data_pool.find( data_pool_id );
// if ( it != this->data_pool.end() ) { // if ( it != this->data_pool.end() ) {
// if ( it->second->getByteSize() <= max_size ) { // if ( it->second->getByteSize() <= maxSize ) {
// *size = it->second->getByteSize(); // *size = it->second->getByteSize();
// memcpy( address, it->second->getRawData(), *size ); // memcpy( address, it->second->getRawData(), *size );
// return DP_SUCCESSFUL; // return DP_SUCCESSFUL;

View File

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

View File

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

View File

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

View File

@ -11,13 +11,13 @@ public:
ReturnValue_t set(uint8_t domainId, uint16_t parameterId); ReturnValue_t set(uint8_t domainId, uint16_t parameterId);
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; 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, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
ReturnValue_t copyFrom(const ParameterWrapper *from, ReturnValue_t copyFrom(const ParameterWrapper *from,
uint16_t startWritingAtIndex); uint16_t startWritingAtIndex);

View File

@ -106,12 +106,12 @@ uint8_t DataSet::lockDataPool() {
return ::dataPool.lockDataPool(); return ::dataPool.lockDataPool();
} }
ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t DataSet::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
result = registeredVariables[count]->serialize(buffer, size, max_size, result = registeredVariables[count]->serialize(buffer, size, maxSize,
bigEndian); streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -119,8 +119,8 @@ ReturnValue_t DataSet::serialize(uint8_t** buffer, uint32_t* size,
return result; return result;
} }
uint32_t DataSet::getSerializedSize() const { size_t DataSet::getSerializedSize() const {
uint32_t size = 0; size_t size = 0;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
size += registeredVariables[count]->getSerializedSize(); size += registeredVariables[count]->getSerializedSize();
} }
@ -136,12 +136,12 @@ void DataSet::setValid(uint8_t valid) {
} }
} }
ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t DataSet::deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED; ReturnValue_t result = RETURN_FAILED;
for (uint16_t count = 0; count < fill_count; count++) { for (uint16_t count = 0; count < fill_count; count++) {
result = registeredVariables[count]->deSerialize(buffer, size, result = registeredVariables[count]->deSerialize(buffer, size,
bigEndian); streamEndianness);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }

View File

@ -146,13 +146,13 @@ public:
*/ */
void setValid(uint8_t valid); void setValid(uint8_t valid);
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const override;
uint32_t getSerializedSize() const; size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
}; };

View File

@ -17,7 +17,7 @@ protected:
uint8_t valid; uint8_t valid;
ReturnValue_t read() { ReturnValue_t read() {
uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId); uint8_t arrayIndex = DataPool::PIDToArrayIndex(parameterId);
PoolEntry<T>* read_out = ::dataPool.getData<T>( PoolEntry<T> *read_out = ::dataPool.getData<T>(
DataPool::PIDToDataPoolId(parameterId), arrayIndex); DataPool::PIDToDataPoolId(parameterId), arrayIndex);
if (read_out != NULL) { if (read_out != NULL) {
valid = read_out->valid; valid = read_out->valid;
@ -43,7 +43,8 @@ protected:
* Empty ctor for List initialization * Empty ctor for List initialization
*/ */
PIDReader() : PIDReader() :
parameterId(PoolVariableIF::NO_PARAMETER), valid(PoolVariableIF::INVALID), value(0) { parameterId(PoolVariableIF::NO_PARAMETER), valid(
PoolVariableIF::INVALID), value(0) {
} }
public: public:
@ -63,9 +64,9 @@ public:
* \param setWritable If this flag is set to true, changes in the value attribute can be * \param setWritable If this flag is set to true, changes in the value attribute can be
* written back to the data pool, otherwise not. * written back to the data pool, otherwise not.
*/ */
PIDReader(uint32_t setParameterId, DataSetIF* dataSet) : PIDReader(uint32_t setParameterId, DataSetIF *dataSet) :
parameterId(setParameterId), valid( parameterId(setParameterId), valid(PoolVariableIF::INVALID), value(
PoolVariableIF::INVALID), value(0) { 0) {
if (dataSet != NULL) { if (dataSet != NULL) {
dataSet->registerVariable(this); dataSet->registerVariable(this);
} }
@ -74,7 +75,7 @@ public:
/** /**
* Copy ctor to copy classes containing Pool Variables. * 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) { parameterId(rhs.parameterId), valid(rhs.valid), value(rhs.value) {
} }
@ -121,24 +122,25 @@ public:
return value; return value;
} }
PIDReader<T> &operator=(T newValue) { PIDReader<T>& operator=(T newValue) {
value = newValue; value = newValue;
return *this; return *this;
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const override {
return SerializeAdapter<T>::serialize(&value, buffer, size, max_size, return SerializeAdapter::serialize(&value, buffer, size, maxSize,
bigEndian); streamEndianness);
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const override {
return SerializeAdapter<T>::getSerializedSize(&value); return SerializeAdapter::getSerializedSize(&value);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian) { Endianness streamEndianness) override {
return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&value, buffer, size,
streamEndianness);
} }
}; };

View File

@ -2,14 +2,15 @@
#include <framework/datapool/PoolEntryIF.h> #include <framework/datapool/PoolEntryIF.h>
#include <framework/datapool/PoolRawAccess.h> #include <framework/datapool/PoolRawAccess.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h> #include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/osal/Endiness.h> #include <framework/serialize/EndianConverter.h>
#include <cstring> #include <cstring>
PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry, PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry,
DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) : DataSetIF *data_set, ReadWriteMode_t setReadWriteMode) :
dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize( dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(
0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) { Type::UNKNOWN_TYPE), typeSize(0), arraySize(0), sizeTillEnd(0), readWriteMode(
setReadWriteMode) {
memset(value, 0, sizeof(value)); memset(value, 0, sizeof(value));
if (data_set != NULL) { if (data_set != NULL) {
data_set->registerVariable(this); data_set->registerVariable(this);
@ -21,7 +22,7 @@ PoolRawAccess::~PoolRawAccess() {
} }
ReturnValue_t PoolRawAccess::read() { ReturnValue_t PoolRawAccess::read() {
PoolEntryIF* read_out = ::dataPool.getRawData(dataPoolId); PoolEntryIF *read_out = ::dataPool.getRawData(dataPoolId);
if (read_out != NULL) { if (read_out != NULL) {
valid = read_out->getValid(); valid = read_out->getValid();
if (read_out->getSize() > arrayEntry) { if (read_out->getSize() > arrayEntry) {
@ -31,7 +32,7 @@ ReturnValue_t PoolRawAccess::read() {
if (typeSize <= sizeof(value)) { if (typeSize <= sizeof(value)) {
uint16_t arrayPosition = arrayEntry * typeSize; uint16_t arrayPosition = arrayEntry * typeSize;
sizeTillEnd = read_out->getByteSize() - arrayPosition; sizeTillEnd = read_out->getByteSize() - arrayPosition;
uint8_t* ptr = uint8_t *ptr =
&((uint8_t*) read_out->getRawData())[arrayPosition]; &((uint8_t*) read_out->getRawData())[arrayPosition];
memcpy(value, ptr, typeSize); memcpy(value, ptr, typeSize);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
@ -44,8 +45,8 @@ ReturnValue_t PoolRawAccess::read() {
} else { } else {
//Error entry does not exist. //Error entry does not exist.
} }
sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex << dataPoolId sif::error << "PoolRawAccess: read of DP Variable 0x" << std::hex
<< std::dec << " failed." << std::endl; << dataPoolId << std::dec << " failed." << std::endl;
valid = INVALID; valid = INVALID;
typeSize = 0; typeSize = 0;
sizeTillEnd = 0; sizeTillEnd = 0;
@ -54,11 +55,11 @@ ReturnValue_t PoolRawAccess::read() {
} }
ReturnValue_t PoolRawAccess::commit() { ReturnValue_t PoolRawAccess::commit() {
PoolEntryIF* write_back = ::dataPool.getRawData(dataPoolId); PoolEntryIF *write_back = ::dataPool.getRawData(dataPoolId);
if ((write_back != NULL) && (readWriteMode != VAR_READ)) { if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
write_back->setValid(valid); write_back->setValid(valid);
uint8_t array_position = arrayEntry * typeSize; uint8_t array_position = arrayEntry * typeSize;
uint8_t* ptr = &((uint8_t*) write_back->getRawData())[array_position]; uint8_t *ptr = &((uint8_t*) write_back->getRawData())[array_position];
memcpy(ptr, value, typeSize); memcpy(ptr, value, typeSize);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
@ -70,23 +71,17 @@ uint8_t* PoolRawAccess::getEntry() {
return value; return value;
} }
ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t* buffer, ReturnValue_t PoolRawAccess::getEntryEndianSafe(uint8_t *buffer,
uint32_t* writtenBytes, uint32_t max_size) { size_t *writtenBytes, size_t maxSize) {
uint8_t* data_ptr = getEntry(); uint8_t *data_ptr = getEntry();
// debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl; // debug << "PoolRawAccess::getEntry: Array position: " << index * size_of_type << " Size of T: " << (int)size_of_type << " ByteSize: " << byte_size << " Position: " << *size << std::endl;
if (typeSize == 0) if (typeSize == 0) {
return DATA_POOL_ACCESS_FAILED; 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 if (typeSize > maxSize) {
memcpy(buffer, data_ptr, typeSize); return INCORRECT_SIZE;
#endif }
EndianConverter::convertBigEndian(buffer, data_ptr, typeSize);
*writtenBytes = typeSize; *writtenBytes = typeSize;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
@ -95,11 +90,11 @@ Type PoolRawAccess::getType() {
return type; return type;
} }
uint8_t PoolRawAccess::getSizeOfType() { size_t PoolRawAccess::getSizeOfType() {
return typeSize; return typeSize;
} }
uint8_t PoolRawAccess::getArraySize(){ size_t PoolRawAccess::getArraySize() {
return arraySize; return arraySize;
} }
@ -111,21 +106,14 @@ PoolVariableIF::ReadWriteMode_t PoolRawAccess::getReadWriteMode() const {
return readWriteMode; return readWriteMode;
} }
ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t* buffer, ReturnValue_t PoolRawAccess::setEntryFromBigEndian(const uint8_t *buffer,
uint32_t setSize) { size_t setSize) {
if (typeSize == setSize) { if (typeSize == setSize) {
#ifndef BYTE_ORDER_SYSTEM EndianConverter::convertBigEndian(value, buffer, typeSize);
#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
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
sif::error << "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal" sif::error
<< "PoolRawAccess::setEntryFromBigEndian: Illegal sizes: Internal"
<< (uint32_t) typeSize << ", Requested: " << setSize << (uint32_t) typeSize << ", Requested: " << setSize
<< std::endl; << std::endl;
return INCORRECT_SIZE; return INCORRECT_SIZE;
@ -143,25 +131,24 @@ void PoolRawAccess::setValid(uint8_t valid) {
this->valid = valid; this->valid = valid;
} }
uint16_t PoolRawAccess::getSizeTillEnd() const { size_t PoolRawAccess::getSizeTillEnd() const {
return sizeTillEnd; return sizeTillEnd;
} }
ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t PoolRawAccess::serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
if (typeSize + *size <= max_size) { if (typeSize + *size <= maxSize) {
if (bigEndian) { switch (streamEndianness) {
#ifndef BYTE_ORDER_SYSTEM case (Endianness::BIG):
#error BYTE_ORDER_SYSTEM not defined EndianConverter::convertBigEndian(*buffer, value, typeSize);
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN break;
for (uint8_t count = 0; count < typeSize; count++) { case (Endianness::LITTLE):
(*buffer)[count] = value[typeSize - count - 1]; EndianConverter::convertLittleEndian(*buffer, value, typeSize);
} break;
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN default:
memcpy(*buffer, value, typeSize); case (Endianness::MACHINE):
#endif
} else {
memcpy(*buffer, value, typeSize); memcpy(*buffer, value, typeSize);
break;
} }
*size += typeSize; *size += typeSize;
(*buffer) += typeSize; (*buffer) += typeSize;
@ -171,28 +158,27 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size,
} }
} }
uint32_t PoolRawAccess::getSerializedSize() const { size_t PoolRawAccess::getSerializedSize() const {
return typeSize; return typeSize;
} }
ReturnValue_t PoolRawAccess::deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t PoolRawAccess::deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian) { Endianness streamEndianness) {
*size -= typeSize;
if (*size >= 0) {
if (bigEndian) { if (*size >= typeSize) {
#ifndef BYTE_ORDER_SYSTEM switch (streamEndianness) {
#error BYTE_ORDER_SYSTEM not defined case (Endianness::BIG):
#elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN EndianConverter::convertBigEndian(value, *buffer, typeSize);
for (uint8_t count = 0; count < typeSize; count++) { break;
value[count] = (*buffer)[typeSize - count - 1]; case (Endianness::LITTLE):
} EndianConverter::convertLittleEndian(value, *buffer, typeSize);
#elif BYTE_ORDER_SYSTEM == BIG_ENDIAN break;
memcpy(value, *buffer, typeSize); default:
#endif case (Endianness::MACHINE):
} else {
memcpy(value, *buffer, typeSize); memcpy(value, *buffer, typeSize);
break;
} }
*size -= typeSize;
*buffer += typeSize; *buffer += typeSize;
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {

View File

@ -32,15 +32,15 @@ private:
/** /**
* \brief This value contains the size of the data pool entry in bytes. * \brief This value contains the size of the data pool entry in bytes.
*/ */
uint8_t typeSize; size_t typeSize;
/** /**
* The size of the DP array (single values return 1) * 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. * 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. * \brief The information whether the class is read-write or read-only is stored here.
*/ */
@ -70,7 +70,7 @@ public:
static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02); static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02);
uint8_t value[RAW_MAX_SIZE]; uint8_t value[RAW_MAX_SIZE];
PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry, PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry,
DataSetIF* data_set, ReadWriteMode_t setReadWriteMode = DataSetIF *data_set, ReadWriteMode_t setReadWriteMode =
PoolVariableIF::VAR_READ); PoolVariableIF::VAR_READ);
/** /**
* \brief The classes destructor is empty. If commit() was not called, the local value is * \brief The classes destructor is empty. If commit() was not called, the local value is
@ -90,15 +90,15 @@ public:
* \details It makes use of the getEntry call of this function, but additionally flips the * \details It makes use of the getEntry call of this function, but additionally flips the
* bytes to big endian, which is the default for external communication (as House- * bytes to big endian, which is the default for external communication (as House-
* keeping telemetry). To achieve this, the data is copied directly to the passed * keeping telemetry). To achieve this, the data is copied directly to the passed
* buffer, if it fits in the given max_size. * buffer, if it fits in the given maxSize.
* \param buffer A pointer to a buffer to write to * \param buffer A pointer to a buffer to write to
* \param writtenBytes The number of bytes written is returned with this value. * \param writtenBytes The number of bytes written is returned with this value.
* \param max_size The maximum size that the function may write to buffer. * \param maxSize The maximum size that the function may write to buffer.
* \return - \c RETURN_OK if entry could be acquired * \return - \c RETURN_OK if entry could be acquired
* - \c RETURN_FAILED else. * - \c RETURN_FAILED else.
*/ */
ReturnValue_t getEntryEndianSafe(uint8_t* buffer, uint32_t* size, ReturnValue_t getEntryEndianSafe(uint8_t *buffer, size_t *size,
uint32_t max_size); size_t maxSize);
/** /**
* With this method, the content can be set from a big endian buffer safely. * With this method, the content can be set from a big endian buffer safely.
* @param buffer Pointer to the data to set * @param buffer Pointer to the data to set
@ -106,8 +106,8 @@ public:
* @return - \c RETURN_OK on success * @return - \c RETURN_OK on success
* - \c RETURN_FAILED on failure * - \c RETURN_FAILED on failure
*/ */
ReturnValue_t setEntryFromBigEndian(const uint8_t* buffer, ReturnValue_t setEntryFromBigEndian(const uint8_t *buffer,
uint32_t setSize); size_t setSize);
/** /**
* \brief This operation returns the type of the entry currently stored. * \brief This operation returns the type of the entry currently stored.
*/ */
@ -115,12 +115,12 @@ public:
/** /**
* \brief This operation returns the size of the entry currently stored. * \brief This operation returns the size of the entry currently stored.
*/ */
uint8_t getSizeOfType(); size_t getSizeOfType();
/** /**
* *
* @return the size of the datapool array * @return the size of the datapool array
*/ */
uint8_t getArraySize(); size_t getArraySize();
/** /**
* \brief This operation returns the data pool id of the variable. * \brief This operation returns the data pool id of the variable.
*/ */
@ -138,15 +138,15 @@ public:
/** /**
* Getter for the remaining size. * Getter for the remaining size.
*/ */
uint16_t getSizeTillEnd() const; size_t getSizeTillEnd() const;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
const uint32_t max_size, bool bigEndian) const; Endianness streamEndianness) const override;
uint32_t getSerializedSize() const; size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian); Endianness streamEndianness) override;
}; };
#endif /* POOLRAWACCESS_H_ */ #endif /* POOLRAWACCESS_H_ */

View File

@ -58,7 +58,7 @@ protected:
* The operation does NOT provide any mutual exclusive protection by itself. * The operation does NOT provide any mutual exclusive protection by itself.
*/ */
ReturnValue_t read() { ReturnValue_t read() {
PoolEntry<T>* read_out = ::dataPool.getData<T>(dataPoolId, 1); PoolEntry<T> *read_out = ::dataPool.getData < T > (dataPoolId, 1);
if (read_out != NULL) { if (read_out != NULL) {
valid = read_out->valid; valid = read_out->valid;
value = *(read_out->address); value = *(read_out->address);
@ -79,7 +79,7 @@ protected:
* *
*/ */
ReturnValue_t commit() { ReturnValue_t commit() {
PoolEntry<T>* write_back = ::dataPool.getData<T>(dataPoolId, 1); PoolEntry<T> *write_back = ::dataPool.getData < T > (dataPoolId, 1);
if ((write_back != NULL) && (readWriteMode != VAR_READ)) { if ((write_back != NULL) && (readWriteMode != VAR_READ)) {
write_back->valid = valid; write_back->valid = valid;
*(write_back->address) = value; *(write_back->address) = value;
@ -115,7 +115,7 @@ public:
* \param setWritable If this flag is set to true, changes in the value attribute can be * \param setWritable If this flag is set to true, changes in the value attribute can be
* written back to the data pool, otherwise not. * written back to the data pool, otherwise not.
*/ */
PoolVariable(uint32_t set_id, DataSetIF* dataSet, PoolVariable(uint32_t set_id, DataSetIF *dataSet,
ReadWriteMode_t setReadWriteMode) : ReadWriteMode_t setReadWriteMode) :
dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode( dataPoolId(set_id), valid(PoolVariableIF::INVALID), readWriteMode(
setReadWriteMode), value(0) { setReadWriteMode), value(0) {
@ -126,7 +126,7 @@ public:
/** /**
* Copy ctor to copy classes containing Pool Variables. * Copy ctor to copy classes containing Pool Variables.
*/ */
PoolVariable(const PoolVariable& rhs) : PoolVariable(const PoolVariable &rhs) :
dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode( dataPoolId(rhs.dataPoolId), valid(rhs.valid), readWriteMode(
rhs.readWriteMode), value(rhs.value) { rhs.readWriteMode), value(rhs.value) {
} }
@ -184,29 +184,29 @@ public:
return value; return value;
} }
PoolVariable<T> &operator=(T newValue) { PoolVariable<T>& operator=(T newValue) {
value = newValue; value = newValue;
return *this; return *this;
} }
PoolVariable<T> &operator=(PoolVariable<T> newPoolVariable) { PoolVariable<T>& operator=(PoolVariable<T> newPoolVariable) {
value = newPoolVariable.value; value = newPoolVariable.value;
return *this; return *this;
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const override {
return SerializeAdapter<T>::serialize(&value, buffer, size, max_size, return SerializeAdapter::serialize<T>(&value, buffer, size, maxSize,
bigEndian); streamEndianness);
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const override {
return SerializeAdapter<T>::getSerializedSize(&value); return SerializeAdapter::getSerializedSize(&value);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian) { Endianness streamEndianness) override {
return SerializeAdapter<T>::deSerialize(&value, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
} }
}; };

View File

@ -197,13 +197,13 @@ public:
return *this; return *this;
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
uint16_t i; uint16_t i;
ReturnValue_t result; ReturnValue_t result;
for (i = 0; i < vector_size; i++) { for (i = 0; i < vector_size; i++) {
result = SerializeAdapter<T>::serialize(&(value[i]), buffer, size, result = SerializeAdapter::serialize(&(value[i]), buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
@ -211,17 +211,17 @@ public:
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
return vector_size * SerializeAdapter<T>::getSerializedSize(value); return vector_size * SerializeAdapter::getSerializedSize(value);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
uint16_t i; uint16_t i;
ReturnValue_t result; ReturnValue_t result;
for (i = 0; i < vector_size; i++) { for (i = 0; i < vector_size; i++) {
result = SerializeAdapter<T>::deSerialize(&(value[i]), buffer, size, result = SerializeAdapter::deSerialize(&(value[i]), buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -35,7 +35,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
parent->registerChild(getObjectId()); parent->registerChild(getObjectId());
} }
healthHelper.setParentQeueue(parentQueue); healthHelper.setParentQueue(parentQueue);
modeHelper.setParentQueue(parentQueue); modeHelper.setParentQueue(parentQueue);

View File

@ -1085,7 +1085,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) { void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
modeHelper.setParentQueue(parentQueueId); modeHelper.setParentQueue(parentQueueId);
healthHelper.setParentQeueue(parentQueueId); healthHelper.setParentQueue(parentQueueId);
} }
bool DeviceHandlerBase::isAwaitingReply() { bool DeviceHandlerBase::isAwaitingReply() {

View File

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

View File

@ -11,13 +11,13 @@ public:
SerializeIF *data); SerializeIF *data);
virtual ~DeviceTmReportingWrapper(); virtual ~DeviceTmReportingWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; 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, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
private: private:
object_id_t objectId; object_id_t objectId;
ActionId_t actionId; ActionId_t actionId;

View File

@ -38,7 +38,7 @@ MessageQueueId_t HealthDevice::getCommandQueue() const {
} }
void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) { void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
healthHelper.setParentQeueue(parentQueue); healthHelper.setParentQueue(parentQueue);
} }
bool HealthDevice::hasHealthChanged() { bool HealthDevice::hasHealthChanged() {

View File

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

View File

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

View File

@ -22,7 +22,7 @@ public:
Type(ActualType_t actualType); Type(ActualType_t actualType);
Type(const Type& type); Type(const Type &type);
Type& operator=(Type rhs); Type& operator=(Type rhs);
@ -30,8 +30,8 @@ public:
operator ActualType_t() const; 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; uint8_t getSize() const;
@ -39,13 +39,13 @@ public:
static ActualType_t getActualType(uint8_t ptc, uint8_t pfc); static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const; 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, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian); Endianness streamEndianness) override;
private: private:
ActualType_t actualType; 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

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

View File

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

View File

@ -29,11 +29,11 @@ HasHealthIF::HealthState HealthHelper::getHealth() {
} }
ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) { ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
setParentQeueue(parentQueue); setParentQueue(parentQueue);
return initialize(); return initialize();
} }
void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) { void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
this->parentQueue = parentQueue; this->parentQueue = parentQueue;
} }

View File

@ -78,7 +78,7 @@ public:
/** /**
* @param parentQueue the Queue id of the parent object. Set to 0 if no parent present * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
*/ */
void setParentQeueue(MessageQueueId_t parentQueue); void setParentQueue(MessageQueueId_t parentQueue);
/** /**
* *

View File

@ -63,21 +63,21 @@ bool HealthTable::hasHealth(object_id_t object) {
return exits; return exits;
} }
void HealthTable::printAll(uint8_t* pointer, uint32_t maxSize) { void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
mutex->lockMutex(MutexIF::NO_TIMEOUT); mutex->lockMutex(MutexIF::NO_TIMEOUT);
uint32_t size = 0; size_t size = 0;
uint16_t count = healthMap.size(); uint16_t count = healthMap.size();
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count, ReturnValue_t result = SerializeAdapter::serialize(&count,
&pointer, &size, maxSize, true); &pointer, &size, maxSize, SerializeIF::Endianness::BIG);
HealthMap::iterator iter; HealthMap::iterator iter;
for (iter = healthMap.begin(); for (iter = healthMap.begin();
iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK; iter != healthMap.end() && result == HasReturnvaluesIF::RETURN_OK;
++iter) { ++iter) {
result = SerializeAdapter<object_id_t>::serialize(&iter->first, result = SerializeAdapter::serialize(&iter->first,
&pointer, &size, maxSize, true); &pointer, &size, maxSize, SerializeIF::Endianness::BIG);
uint8_t health = iter->second; uint8_t health = iter->second;
result = SerializeAdapter<uint8_t>::serialize(&health, &pointer, &size, result = SerializeAdapter::serialize(&health, &pointer, &size,
maxSize, true); maxSize, SerializeIF::Endianness::BIG);
} }
mutex->unlockMutex(); mutex->unlockMutex();
} }

View File

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

View File

@ -17,7 +17,7 @@ public:
HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0; HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
virtual uint32_t getPrintSize() = 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: protected:
virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0; virtual ReturnValue_t iterate(std::pair<object_id_t,HasHealthIF::HealthState> *value, bool reset = false) = 0;

View File

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

View File

@ -17,7 +17,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
} }
store_address_t storeId; store_address_t storeId;
uint8_t* dataTarget = NULL; uint8_t* dataTarget = NULL;
uint32_t maxSize = data->getSerializedSize(); size_t maxSize = data->getSerializedSize();
if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) { if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
return MonitoringIF::INVALID_SIZE; return MonitoringIF::INVALID_SIZE;
} }
@ -26,8 +26,8 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
uint32_t size = 0; 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) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }

View File

@ -1,6 +1,7 @@
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include "FixedTimeslotTask.h" #include "FixedTimeslotTask.h"
#include <framework/serviceinterface/ServiceInterfaceStream.h>
uint32_t FixedTimeslotTask::deadlineMissedCount = 0; uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE; const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
@ -18,16 +19,19 @@ FixedTimeslotTask::~FixedTimeslotTask() {
void FixedTimeslotTask::taskEntryPoint(void* argument) { void FixedTimeslotTask::taskEntryPoint(void* argument) {
//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place. // The argument is re-interpreted as FixedTimeslotTask. The Task object is
// global, so it is found from any place.
FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument)); FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
// Task should not start until explicitly requested /* Task should not start until explicitly requested,
// in FreeRTOS, tasks start as soon as they are created if the scheduler is running * but in FreeRTOS, tasks start as soon as they are created if the scheduler
// but not if the scheduler is not running. * is running but not if the scheduler is not running.
// to be able to accommodate both cases we check a member which is set in #startTask() * To be able to accommodate both cases we check a member which is set in
// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend * #startTask(). If it is not set and we get here, the scheduler was started
// if it is set, the scheduler was not running before #startTask() was called and we can continue * before #startTask() was called and we need to suspend if it is set,
* the scheduler was not running before #startTask() was called and we
* can continue */
if (!originalTask->started) { if (not originalTask->started) {
vTaskSuspend(NULL); vTaskSuspend(NULL);
} }
@ -58,11 +62,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
uint32_t slotTimeMs, int8_t executionStep) { uint32_t slotTimeMs, int8_t executionStep) {
if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) { if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
if(slotTimeMs == 0) {
// FreeRTOS throws a sanity error for zero values, so we set
// the time to one millisecond.
slotTimeMs = 1;
}
pst.addSlot(componentId, slotTimeMs, executionStep, this); pst.addSlot(componentId, slotTimeMs, executionStep, this);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} }
@ -81,8 +80,9 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
} }
void FixedTimeslotTask::taskFunctionality() { void FixedTimeslotTask::taskFunctionality() {
// A local iterator for the Polling Sequence Table is created to find the start time for the first entry. // A local iterator for the Polling Sequence Table is created to find the
auto slotListIter = pst.current; // start time for the first entry.
FixedSlotSequence::SlotListIter slotListIter = pst.current;
//The start time for the first entry is read. //The start time for the first entry is read.
uint32_t intervalMs = slotListIter->pollingTimeMs; uint32_t intervalMs = slotListIter->pollingTimeMs;
@ -90,29 +90,65 @@ void FixedTimeslotTask::taskFunctionality() {
TickType_t xLastWakeTime; TickType_t xLastWakeTime;
/* The xLastWakeTime variable needs to be initialized with the current tick /* The xLastWakeTime variable needs to be initialized with the current tick
count. Note that this is the only time the variable is written to explicitly. count. Note that this is the only time the variable is written to
After this assignment, xLastWakeTime is updated automatically internally within explicitly. After this assignment, xLastWakeTime is updated automatically
vTaskDelayUntil(). */ internally within vTaskDelayUntil(). */
xLastWakeTime = xTaskGetTickCount(); xLastWakeTime = xTaskGetTickCount();
// wait for first entry's start time // wait for first entry's start time
if(interval > 0) {
vTaskDelayUntil(&xLastWakeTime, interval); vTaskDelayUntil(&xLastWakeTime, interval);
}
/* Enter the loop that defines the task behavior. */ /* Enter the loop that defines the task behavior. */
for (;;) { for (;;) {
//The component for this slot is executed and the next one is chosen. //The component for this slot is executed and the next one is chosen.
this->pst.executeAndAdvance(); this->pst.executeAndAdvance();
if (pst.slotFollowsImmediately()) { if (not pst.slotFollowsImmediately()) {
//Do nothing // Get the interval till execution of the next slot.
} else {
// we need to wait before executing the current slot
//this gives us the time to wait:
intervalMs = this->pst.getIntervalToPreviousSlotMs(); intervalMs = this->pst.getIntervalToPreviousSlotMs();
interval = pdMS_TO_TICKS(intervalMs); interval = pdMS_TO_TICKS(intervalMs);
vTaskDelayUntil(&xLastWakeTime, interval);
//TODO deadline missed check
}
checkMissedDeadline(xLastWakeTime, interval);
// Wait for the interval. This exits immediately if a deadline was
// missed while also updating the last wake time.
vTaskDelayUntil(&xLastWakeTime, interval);
}
}
}
void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
const TickType_t interval) {
/* Check whether deadline was missed while also taking overflows
* into account. Drawing this on paper with a timeline helps to understand
* it. */
TickType_t currentTickCount = xTaskGetTickCount();
TickType_t timeToWake = xLastWakeTime + interval;
// Tick count has overflown
if(currentTickCount < xLastWakeTime) {
// Time to wake has overflown as well. If the tick count
// is larger than the time to wake, a deadline was missed.
if(timeToWake < xLastWakeTime and
currentTickCount > timeToWake) {
handleMissedDeadline();
}
}
// No tick count overflow. If the timeToWake has not overflown
// and the current tick count is larger than the time to wake,
// a deadline was missed.
else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
handleMissedDeadline();
}
}
void FixedTimeslotTask::handleMissedDeadline() {
#ifdef DEBUG
sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
" missed deadline!\n" << std::flush;
#endif
if(deadlineMissedFunc != nullptr) {
this->deadlineMissedFunc();
} }
} }

View File

@ -1,26 +1,27 @@
#ifndef POLLINGTASK_H_ #ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
#define POLLINGTASK_H_ #define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
#include <framework/devicehandlers/FixedSlotSequence.h> #include <framework/devicehandlers/FixedSlotSequence.h>
#include <framework/tasks/FixedTimeslotTaskIF.h> #include <framework/tasks/FixedTimeslotTaskIF.h>
#include <framework/tasks/Typedef.h> #include <framework/tasks/Typedef.h>
extern "C" { #include <freertos/FreeRTOS.h>
#include "FreeRTOS.h" #include <freertos/task.h>
#include "task.h"
}
class FixedTimeslotTask: public FixedTimeslotTaskIF { class FixedTimeslotTask: public FixedTimeslotTaskIF {
public: public:
/** /**
* @brief The standard constructor of the class. * Keep in mind that you need to call before vTaskStartScheduler()!
* * A lot of task parameters are set in "FreeRTOSConfig.h".
* @details This is the general constructor of the class. In addition to the TaskBase parameters, * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
* the following variables are passed: * @param setPriority Number of priorities specified by
* * configMAX_PRIORITIES. High taskPriority_ number means high priority.
* @param (*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned. * @param setStack Stack size in words (not bytes!).
* * Lower limit specified by configMINIMAL_STACK_SIZE
* @param getPst The object id of the completely initialized polling sequence. * @param overallPeriod Period in seconds.
* @param setDeadlineMissedFunc Callback if a deadline was missed.
* @return Pointer to the newly created task.
*/ */
FixedTimeslotTask(const char *name, TaskPriority setPriority, FixedTimeslotTask(const char *name, TaskPriority setPriority,
TaskStackSize setStack, TaskPeriod overallPeriod, TaskStackSize setStack, TaskPeriod overallPeriod,
@ -28,16 +29,18 @@ public:
/** /**
* @brief The destructor of the class. * @brief The destructor of the class.
* * @details
* @details The destructor frees all heap memory that was allocated on thread initialization for the PST and * The destructor frees all heap memory that was allocated on thread
* the device handlers. This is done by calling the PST's destructor. * initialization for the PST and the device handlers. This is done by
* calling the PST's destructor.
*/ */
virtual ~FixedTimeslotTask(void); virtual ~FixedTimeslotTask(void);
ReturnValue_t startTask(void); ReturnValue_t startTask(void);
/** /**
* This static function can be used as #deadlineMissedFunc. * This static function can be used as #deadlineMissedFunc.
* It counts missedDeadlines and prints the number of missed deadlines every 10th time. * It counts missedDeadlines and prints the number of missed deadlines
* every 10th time.
*/ */
static void missedDeadlineCounter(); static void missedDeadlineCounter();
/** /**
@ -46,13 +49,14 @@ public:
static uint32_t deadlineMissedCount; static uint32_t deadlineMissedCount;
ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
int8_t executionStep); int8_t executionStep) override;
uint32_t getPeriodMs() const; uint32_t getPeriodMs() const override;
ReturnValue_t checkSequence() const; ReturnValue_t checkSequence() const override;
ReturnValue_t sleepFor(uint32_t ms) override;
ReturnValue_t sleepFor(uint32_t ms);
protected: protected:
bool started; bool started;
TaskHandle_t handle; TaskHandle_t handle;
@ -60,32 +64,35 @@ protected:
FixedSlotSequence pst; FixedSlotSequence pst;
/** /**
* @brief This attribute holds a function pointer that is executed when a deadline was missed. * @brief This attribute holds a function pointer that is executed when
* * a deadline was missed.
* @details Another function may be announced to determine the actions to perform when a deadline was missed. * @details
* Currently, only one function for missing any deadline is allowed. * Another function may be announced to determine the actions to perform
* If not used, it shall be declared NULL. * when a deadline was missed. Currently, only one function for missing
* any deadline is allowed. If not used, it shall be declared NULL.
*/ */
void (*deadlineMissedFunc)(void); void (*deadlineMissedFunc)(void);
/** /**
* @brief This is the entry point in a new polling thread. * @brief This is the entry point for a new task.
* * @details
* @details This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate * This method starts the task by calling taskFunctionality(), as soon as
* and link the Polling Sequence Table to the thread object and start taskFunctionality() * all requirements (task scheduler has started and startTask()
* on success. If operation of the task is ended for some reason, * has been called) are met.
* the destructor is called to free allocated memory.
*/ */
static void taskEntryPoint(void* argument); static void taskEntryPoint(void* argument);
/** /**
* @brief This function holds the main functionality of the thread. * @brief This function holds the main functionality of the thread.
* * @details
* * Core function holding the main functionality of the task
* @details Holding the main functionality of the task, this method is most important. * It links the functionalities provided by FixedSlotSequence with the
* It links the functionalities provided by FixedSlotSequence with the OS's System Calls * OS's System Calls to keep the timing of the periods.
* to keep the timing of the periods.
*/ */
void taskFunctionality(void); void taskFunctionality(void);
void checkMissedDeadline(const TickType_t xLastWakeTime,
const TickType_t interval);
void handleMissedDeadline();
}; };
#endif /* POLLINGTASK_H_ */ #endif /* FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_ */

View File

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

View File

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

View File

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

View File

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

View File

@ -25,16 +25,16 @@ public:
const void *data); const void *data);
virtual ~ParameterWrapper(); virtual ~ParameterWrapper();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; 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, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, 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> template<typename T>
ReturnValue_t getElement(T *value, uint8_t row = 0, uint8_t column = 0) const { 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; const uint8_t *streamWithtype = (const uint8_t *) readonlyData;
streamWithtype += (row * columns + column) * type.getSize(); streamWithtype += (row * columns + column) * type.getSize();
int32_t size = type.getSize(); int32_t size = type.getSize();
return SerializeAdapter<T>::deSerialize(value, &streamWithtype, return SerializeAdapter::deSerialize(value, &streamWithtype,
&size, true); &size, true);
} else { } else {
const T *dataWithType = (const T *) readonlyData; const T *dataWithType = (const T *) readonlyData;
@ -111,8 +111,8 @@ public:
void setMatrix(const T& member) { void setMatrix(const T& member) {
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0])); this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
} }
ReturnValue_t set(const uint8_t *stream, int32_t streamSize, ReturnValue_t set(const uint8_t *stream, size_t streamSize,
const uint8_t **remainingStream = NULL, int32_t *remainingSize = const uint8_t **remainingStream = NULL, size_t *remainingSize =
NULL); NULL);
ReturnValue_t copyFrom(const ParameterWrapper *from, ReturnValue_t copyFrom(const ParameterWrapper *from,
@ -128,8 +128,8 @@ private:
const void *readonlyData; const void *readonlyData;
template<typename T> template<typename T>
ReturnValue_t serializeData(uint8_t** buffer, uint32_t* size, ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; size_t maxSize, Endianness streamEndianness) const;
template<typename T> template<typename T>
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn, ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,

View File

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

View File

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

View File

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

View File

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

126
serialize/EndianConverter.h Normal file
View File

@ -0,0 +1,126 @@
#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,47 +0,0 @@
#ifndef ENDIANSWAPPER_H_
#define ENDIANSWAPPER_H_
#include <framework/osal/Endiness.h>
#include <cstring>
#include <iostream>
class EndianSwapper {
private:
EndianSwapper() {
}
;
public:
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
}
static void swap(uint8_t* out, const uint8_t* in, uint32_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
}
};
#endif /* ENDIANSWAPPER_H_ */

View File

@ -20,25 +20,25 @@ public:
SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) { SerialArrayListAdapter(ArrayList<T, count_t> *adaptee) : adaptee(adaptee) {
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return serialize(adaptee, buffer, size, max_size, bigEndian); return serialize(adaptee, buffer, size, maxSize, streamEndianness);
} }
static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, uint32_t* size, static ReturnValue_t serialize(const ArrayList<T, count_t>* list, uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) { size_t maxSize, Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&list->size, ReturnValue_t result = SerializeAdapter::serialize(&list->size,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
count_t i = 0; count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter<T>::serialize(&list->entries[i], buffer, size, result = SerializeAdapter::serialize(&list->entries[i], buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
++i; ++i;
} }
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const {
return getSerializedSize(adaptee); return getSerializedSize(adaptee);
} }
@ -47,31 +47,31 @@ public:
count_t i = 0; count_t i = 0;
for (i = 0; i < list->size; ++i) { for (i = 0; i < list->size; ++i) {
printSize += SerializeAdapter<T>::getSerializedSize(&list->entries[i]); printSize += SerializeAdapter::getSerializedSize(&list->entries[i]);
} }
return printSize; return printSize;
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return deSerialize(adaptee, buffer, size, bigEndian); return deSerialize(adaptee, buffer, size, streamEndianness);
} }
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size, static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
count_t tempSize = 0; count_t tempSize = 0;
ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize, ReturnValue_t result = SerializeAdapter::deSerialize(&tempSize,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (tempSize > list->maxSize()) { if (tempSize > list->maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS; return SerializeIF::TOO_MANY_ELEMENTS;
} }
list->size = tempSize; list->size = tempSize;
count_t i = 0; count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter<T>::deSerialize( result = SerializeAdapter::deSerialize(
&list->front()[i], buffer, size, &list->front()[i], buffer, size,
bigEndian); streamEndianness);
++i; ++i;
} }
return result; return result;

View File

@ -22,19 +22,19 @@ SerialBufferAdapter<T>::~SerialBufferAdapter() {
} }
template<typename T> template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
uint32_t serializedLength = bufferLength; uint32_t serializedLength = bufferLength;
if (serializeLength) { if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize( serializedLength += SerializeAdapter::getSerializedSize(
&bufferLength); &bufferLength);
} }
if (*size + serializedLength > max_size) { if (*size + serializedLength > maxSize) {
return BUFFER_TOO_SHORT; return BUFFER_TOO_SHORT;
} else { } else {
if (serializeLength) { if (serializeLength) {
AutoSerializeAdapter::serialize(&bufferLength, buffer, size, SerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
} }
if (this->constBuffer != NULL) { if (this->constBuffer != NULL) {
memcpy(*buffer, this->constBuffer, bufferLength); memcpy(*buffer, this->constBuffer, bufferLength);
@ -50,20 +50,20 @@ ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size
} }
template<typename T> template<typename T>
uint32_t SerialBufferAdapter<T>::getSerializedSize() const { size_t SerialBufferAdapter<T>::getSerializedSize() const {
if (serializeLength) { if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength); return bufferLength + SerializeAdapter::getSerializedSize(&bufferLength);
} else { } else {
return bufferLength; return bufferLength;
} }
} }
template<typename T> template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer, ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) { size_t* size, Endianness streamEndianness) {
//TODO Ignores Endian flag! //TODO Ignores Endian flag!
if (buffer != NULL) { if (buffer != NULL) {
if(serializeLength){ if(serializeLength){
T serializedSize = AutoSerializeAdapter::getSerializedSize( T serializedSize = SerializeAdapter::getSerializedSize(
&bufferLength); &bufferLength);
if((*size - bufferLength - serializedSize) >= 0){ if((*size - bufferLength - serializedSize) >= 0){
*buffer += serializedSize; *buffer += serializedSize;

View File

@ -16,13 +16,13 @@ public:
virtual ~SerialBufferAdapter(); virtual ~SerialBufferAdapter();
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const; 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, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian); Endianness streamEndianness) override;
private: private:
bool serializeLength; bool serializeLength;
const uint8_t *constBuffer; const uint8_t *constBuffer;

View File

@ -13,16 +13,16 @@ public:
template<typename... Args> template<typename... Args>
SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) { SerialFixedArrayListAdapter(Args... args) : FixedArrayList<T, MAX_SIZE, count_t>(std::forward<Args>(args)...) {
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, max_size, bigEndian); return SerialArrayListAdapter<T, count_t>::serialize(this, buffer, size, maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return SerialArrayListAdapter<T, count_t>::getSerializedSize(this); return SerialArrayListAdapter<T, count_t>::getSerializedSize(this);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, bigEndian); return SerialArrayListAdapter<T, count_t>::deSerialize(this, buffer, size, streamEndianness);
} }
}; };

View File

@ -31,32 +31,32 @@ public:
SinglyLinkedList<T>(), printCount(printCount) { SinglyLinkedList<T>(), printCount(printCount) {
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const override {
if (printCount) { if (printCount) {
count_t mySize = SinglyLinkedList<T>::getSize(); count_t mySize = SinglyLinkedList<T>::getSize();
ReturnValue_t result = SerializeAdapter<count_t>::serialize(&mySize, ReturnValue_t result = SerializeAdapter::serialize(&mySize,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
} }
return serialize(SinglyLinkedList<T>::start, buffer, size, max_size, return serialize(SinglyLinkedList<T>::start, buffer, size, maxSize,
bigEndian); streamEndianness);
} }
static ReturnValue_t serialize(const LinkedElement<T>* element, static ReturnValue_t serialize(const LinkedElement<T>* element,
uint8_t** buffer, uint32_t* size, const uint32_t max_size, uint8_t** buffer, size_t* size, size_t maxSize,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
result = element->value->serialize(buffer, size, max_size, result = element->value->serialize(buffer, size, maxSize,
bigEndian); streamEndianness);
element = element->getNext(); element = element->getNext();
} }
return result; return result;
} }
virtual uint32_t getSerializedSize() const { virtual size_t getSerializedSize() const override {
if (printCount) { if (printCount) {
return SerialLinkedListAdapter<T>::getSerializedSize() return SerialLinkedListAdapter<T>::getSerializedSize()
+ sizeof(count_t); + sizeof(count_t);
@ -64,8 +64,8 @@ public:
return getSerializedSize(SinglyLinkedList<T>::start); return getSerializedSize(SinglyLinkedList<T>::start);
} }
} }
static uint32_t getSerializedSize(const LinkedElement<T> *element) { static size_t getSerializedSize(const LinkedElement<T> *element) {
uint32_t size = 0; size_t size = 0;
while (element != NULL) { while (element != NULL) {
size += element->value->getSerializedSize(); size += element->value->getSerializedSize();
element = element->getNext(); element = element->getNext();
@ -73,16 +73,16 @@ public:
return size; return size;
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) override {
return deSerialize(SinglyLinkedList<T>::start, buffer, size, bigEndian); return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
} }
static ReturnValue_t deSerialize(LinkedElement<T>* element, static ReturnValue_t deSerialize(LinkedElement<T>* element,
const uint8_t** buffer, int32_t* size, bool bigEndian) { const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) { while ((result == HasReturnvaluesIF::RETURN_OK) && (element != NULL)) {
result = element->value->deSerialize(buffer, size, bigEndian); result = element->value->deSerialize(buffer, size, streamEndianness);
element = element->getNext(); element = element->getNext();
} }
return result; return result;

View File

@ -3,28 +3,58 @@
#include <framework/container/IsDerivedFrom.h> #include <framework/container/IsDerivedFrom.h>
#include <framework/returnvalues/HasReturnvaluesIF.h> #include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/serialize/EndianSwapper.h> #include <framework/serialize/EndianConverter.h>
#include <framework/serialize/SerializeIF.h> #include <framework/serialize/SerializeIF.h>
#include <string.h> #include <string.h>
/** /**
* \ingroup serialize * \ingroup serialize
*/ */
template<typename T, int>
class SerializeAdapter_ { class SerializeAdapter {
public: public:
static ReturnValue_t serialize(const T* object, uint8_t** buffer, template<typename T>
uint32_t* size, const uint32_t max_size, bool bigEndian) { static ReturnValue_t serialize(const T *object, uint8_t **buffer,
uint32_t ignoredSize = 0; size_t *size, size_t maxSize, SerializeIF::Endianness streamEndianness) {
InternalSerializeAdapter<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, maxSize,
streamEndianness);
}
template<typename T>
static uint32_t getSerializedSize(const T *object) {
InternalSerializeAdapter<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, 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) { if (size == NULL) {
size = &ignoredSize; size = &ignoredSize;
} }
//TODO check integer overflow of *size
if (sizeof(T) + *size <= max_size) { if (sizeof(T) + *size <= max_size) {
T tmp; T tmp;
if (bigEndian) { switch (streamEndianness) {
tmp = EndianSwapper::swap<T>(*object); case SerializeIF::Endianness::BIG:
} else { tmp = EndianConverter::convertBigEndian<T>(*object);
break;
case SerializeIF::Endianness::LITTLE:
tmp = EndianConverter::convertLittleEndian<T>(*object);
break;
default:
case SerializeIF::Endianness::MACHINE:
tmp = *object; tmp = *object;
break;
} }
memcpy(*buffer, &tmp, sizeof(T)); memcpy(*buffer, &tmp, sizeof(T));
*size += sizeof(T); *size += sizeof(T);
@ -35,17 +65,25 @@ public:
} }
} }
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
bool bigEndian) { size_t *size, SerializeIF::Endianness streamEndianness) {
T tmp; T tmp;
if (*size >= sizeof(T)) {
*size -= sizeof(T); *size -= sizeof(T);
if (*size >= 0) {
memcpy(&tmp, *buffer, sizeof(T)); memcpy(&tmp, *buffer, sizeof(T));
if (bigEndian) { switch (streamEndianness) {
*object = EndianSwapper::swap<T>(tmp); case SerializeIF::Endianness::BIG:
} else { *object = EndianConverter::convertBigEndian<T>(tmp);
break;
case SerializeIF::Endianness::LITTLE:
*object = EndianConverter::convertLittleEndian<T>(tmp);
break;
default:
case SerializeIF::Endianness::MACHINE:
*object = tmp; *object = tmp;
break;
} }
*buffer += sizeof(T); *buffer += sizeof(T);
return HasReturnvaluesIF::RETURN_OK; return HasReturnvaluesIF::RETURN_OK;
} else { } else {
@ -53,73 +91,33 @@ public:
} }
} }
uint32_t getSerializedSize(const T * object) { uint32_t getSerializedSize(const T *object) {
return sizeof(T); return sizeof(T);
} }
}; };
template<typename T> template<typename T>
class SerializeAdapter_<T, 1> { class InternalSerializeAdapter<T, 1> {
public: public:
ReturnValue_t serialize(const T* object, uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(const T *object, uint8_t **buffer,
const uint32_t max_size, bool bigEndian) const { size_t *size, size_t max_size,
uint32_t ignoredSize = 0; SerializeIF::Endianness streamEndianness) const {
size_t ignoredSize = 0;
if (size == NULL) { if (size == NULL) {
size = &ignoredSize; size = &ignoredSize;
} }
return object->serialize(buffer, size, max_size, bigEndian); return object->serialize(buffer, size, max_size, streamEndianness);
} }
uint32_t getSerializedSize(const T* object) const { uint32_t getSerializedSize(const T *object) const {
return object->getSerializedSize(); return object->getSerializedSize();
} }
ReturnValue_t deSerialize(T* object, const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(T *object, const uint8_t **buffer,
bool bigEndian) { size_t *size, SerializeIF::Endianness streamEndianness) {
return object->deSerialize(buffer, size, bigEndian); return object->deSerialize(buffer, size, streamEndianness);
}
};
template<typename T>
class SerializeAdapter {
public:
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
uint32_t* size, const uint32_t max_size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.serialize(object, buffer, size, max_size, bigEndian);
}
static uint32_t getSerializedSize(const T* object) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.getSerializedSize(object);
}
static ReturnValue_t deSerialize(T* object, const uint8_t** buffer,
int32_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
}
};
class AutoSerializeAdapter {
public:
template<typename T>
static ReturnValue_t serialize(const T* object, uint8_t** buffer,
uint32_t* size, const uint32_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 uint32_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,
int32_t* size, bool bigEndian) {
SerializeAdapter_<T, IsDerivedFrom<T, SerializeIF>::Is> adapter;
return adapter.deSerialize(object, buffer, size, bigEndian);
} }
};
}; };
#endif /* SERIALIZEADAPTER_H_ */ #endif /* SERIALIZEADAPTER_H_ */

View File

@ -9,41 +9,43 @@
* \ingroup serialize * \ingroup serialize
*/ */
template<typename T> template<typename T>
class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> { class SerializeElement: public SerializeIF, public LinkedElement<SerializeIF> {
public: public:
template<typename... Args> template<typename ... Args>
SerializeElement(Args... args) : LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) { SerializeElement(Args ... args) :
LinkedElement<SerializeIF>(this), entry(std::forward<Args>(args)...) {
} }
SerializeElement() : LinkedElement<SerializeIF>(this) { SerializeElement() :
LinkedElement<SerializeIF>(this) {
} }
T entry; T entry;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
const uint32_t max_size, bool bigEndian) const { Endianness streamEndianness) const override {
return SerializeAdapter<T>::serialize(&entry, buffer, size, max_size, bigEndian); return SerializeAdapter::serialize(&entry, buffer, size, maxSize,
streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const override {
return SerializeAdapter<T>::getSerializedSize(&entry); return SerializeAdapter::getSerializedSize(&entry);
} }
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian) { Endianness streamEndianness) override {
return SerializeAdapter<T>::deSerialize(&entry, buffer, size, bigEndian); return SerializeAdapter::deSerialize(&entry, buffer, size,
streamEndianness);
} }
operator T() { operator T() {
return entry; return entry;
} }
SerializeElement<T> &operator=(T newValue) { SerializeElement<T>& operator=(T newValue) {
entry = newValue; entry = newValue;
return *this; return *this;
} }
T *operator->() { T* operator->() {
return &entry; return &entry;
} }
}; };
#endif /* SERIALIZEELEMENT_H_ */ #endif /* SERIALIZEELEMENT_H_ */

View File

@ -2,6 +2,7 @@
#define SERIALIZEIF_H_ #define SERIALIZEIF_H_
#include <framework/returnvalues/HasReturnvaluesIF.h> #include <framework/returnvalues/HasReturnvaluesIF.h>
#include <stddef.h>
/** /**
* \defgroup serialize Serialization * \defgroup serialize Serialization
@ -14,6 +15,10 @@
*/ */
class SerializeIF { class SerializeIF {
public: public:
enum class Endianness : uint8_t {
BIG, LITTLE, MACHINE
};
static const uint8_t INTERFACE_ID = CLASS_ID::SERIALIZE_IF; 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 BUFFER_TOO_SHORT = MAKE_RETURN_CODE(1);
static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2); static const ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
@ -22,13 +27,13 @@ public:
virtual ~SerializeIF() { virtual ~SerializeIF() {
} }
virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
const uint32_t max_size, bool bigEndian) const = 0; size_t maxSize, Endianness streamEndianness) const = 0;
virtual uint32_t getSerializedSize() const = 0; virtual size_t getSerializedSize() const = 0;
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
bool bigEndian) = 0; Endianness streamEndianness) = 0;
}; };

View File

@ -1,11 +1,58 @@
#include <framework/timemanager/Clock.h> #include <framework/timemanager/Clock.h>
#include <framework/serviceinterface/ServiceInterfaceBuffer.h> #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
#include <cstring> #include <cstring>
#include <inttypes.h>
// to be implemented by bsp // to be implemented by bsp
extern "C" void printChar(const char*); extern "C" void printChar(const char*, bool errStream);
#ifndef UT699
ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
isActive(true), logMessage(setMessage),
addCrToPreamble(addCrToPreamble), buffered(buffered),
errStream(errStream) {
if(buffered) {
// Set pointers if the stream is buffered.
setp( buf, buf + BUF_SIZE );
}
preamble.reserve(MAX_PREAMBLE_SIZE);
preamble.resize(MAX_PREAMBLE_SIZE);
}
void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
char array[BUF_SIZE];
uint32_t length = end - begin;
if (length > sizeof(array)) {
length = sizeof(array);
}
memcpy(array, begin, length);
for(; begin != end; begin++){
if(errStream) {
printChar(begin, true);
}
else {
printChar(begin, false);
}
}
}
#endif
int ServiceInterfaceBuffer::overflow(int c) { int ServiceInterfaceBuffer::overflow(int c) {
if(not buffered and this->isActive) {
if (c != Traits::eof()) {
if(errStream) {
printChar(reinterpret_cast<const char*>(&c), true);
}
else {
printChar(reinterpret_cast<const char*>(&c), false);
}
}
return 0;
}
// Handle output // Handle output
putChars(pbase(), pptr()); putChars(pbase(), pptr());
if (c != Traits::eof()) { if (c != Traits::eof()) {
@ -20,52 +67,70 @@ int ServiceInterfaceBuffer::overflow(int c) {
} }
int ServiceInterfaceBuffer::sync(void) { int ServiceInterfaceBuffer::sync(void) {
if (this->isActive) { if(not this->isActive and not buffered) {
Clock::TimeOfDay_t loggerTime; if(not buffered) {
Clock::getDateAndTime(&loggerTime); setp(buf, buf + BUF_SIZE - 1);
char preamble[96] = { 0 }; }
sprintf(preamble, "%s: | %lu:%02lu:%02lu.%03lu | ", return 0;
this->log_message.c_str(), (unsigned long) loggerTime.hour, }
(unsigned long) loggerTime.minute, if(not buffered) {
(unsigned long) loggerTime.second, return 0;
(unsigned long) loggerTime.usecond /1000); }
// Write log_message and time
this->putChars(preamble, preamble + sizeof(preamble)); size_t preambleSize = 0;
auto preamble = getPreamble(&preambleSize);
// Write logMessage and time
this->putChars(preamble.data(), preamble.data() + preambleSize);
// Handle output // Handle output
this->putChars(pbase(), pptr()); this->putChars(pbase(), pptr());
}
// This tells that buffer is empty again // This tells that buffer is empty again
setp(buf, buf + BUF_SIZE - 1); setp(buf, buf + BUF_SIZE - 1);
return 0; return 0;
} }
#ifndef UT699 bool ServiceInterfaceBuffer::isBuffered() const {
return buffered;
ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
this->log_message = set_message;
this->isActive = true;
setp( buf, buf + BUF_SIZE );
} }
void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) { std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
char array[BUF_SIZE]; Clock::TimeOfDay_t loggerTime;
uint32_t length = end - begin; Clock::getDateAndTime(&loggerTime);
if (length > sizeof(array)) { size_t currentSize = 0;
length = sizeof(array); char* parsePosition = &preamble[0];
if(addCrToPreamble) {
preamble[0] = '\r';
currentSize += 1;
parsePosition += 1;
} }
memcpy(array, begin, length); int32_t charCount = sprintf(parsePosition,
"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
for( ; begin != end; begin++){ this->logMessage.c_str(), loggerTime.hour,
printChar(begin); loggerTime.minute,
loggerTime.second,
loggerTime.usecond /1000);
if(charCount < 0) {
printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
return "";
} }
if(charCount > MAX_PREAMBLE_SIZE) {
printf("ServiceInterfaceBuffer: Char count too large for maximum "
"preamble size");
return "";
}
currentSize += charCount;
if(preambleSize != nullptr) {
*preambleSize = currentSize;
}
return preamble;
} }
#endif
#ifdef UT699 #ifdef UT699
#include <framework/osal/rtems/Interrupt.h> #include <framework/osal/rtems/Interrupt.h>
ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) { ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
uint16_t port) {
this->log_message = set_message; this->log_message = set_message;
this->isActive = true; this->isActive = true;
setp( buf, buf + BUF_SIZE ); setp( buf, buf + BUF_SIZE );

View File

@ -1,51 +1,71 @@
#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <iostream> #include <iostream>
#include <iosfwd>
#include <sstream> #include <sstream>
#include <cstdio> #include <iomanip>
#ifndef UT699 #ifndef UT699
class ServiceInterfaceBuffer: public std::basic_streambuf<char,
std::char_traits<char> > { /**
* @brief This is the underlying stream buffer which implements the
* streambuf class and overloads the overflow() and sync() methods
* @details
* This class is used to modify the output of the stream, for example by adding.
* It also calls the char printing function which is implemented in the
* board supply package (BSP).
*/
class ServiceInterfaceBuffer:
public std::streambuf {
friend class ServiceInterfaceStream; friend class ServiceInterfaceStream;
public: public:
ServiceInterfaceBuffer(std::string set_message, uint16_t port); static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
bool buffered, bool errStream, uint16_t port);
protected: protected:
bool isActive; bool isActive;
// This is called when buffer becomes full. If //! This is called when buffer becomes full. If
// buffer is not used, then this is called every //! buffer is not used, then this is called every
// time when characters are put to stream. //! time when characters are put to stream.
virtual int overflow(int c = Traits::eof()); int overflow(int c = Traits::eof()) override;
// This function is called when stream is flushed, //! This function is called when stream is flushed,
// for example when std::endl is put to stream. //! for example when std::endl is put to stream.
virtual int sync(void); int sync(void) override;
bool isBuffered() const;
private: private:
// For additional message information //! For additional message information
std::string log_message; std::string logMessage;
std::string preamble;
// For EOF detection // For EOF detection
typedef std::char_traits<char> Traits; typedef std::char_traits<char> Traits;
// Work in buffer mode. It is also possible to work without buffer. //! This is useful for some terminal programs which do not have
//! implicit carriage return with newline characters.
bool addCrToPreamble;
//! Specifies whether the stream operates in buffered or unbuffered mode.
bool buffered;
//! This specifies to print to stderr and work in unbuffered mode.
bool errStream;
//! Needed for buffered mode.
static size_t const BUF_SIZE = 128; static size_t const BUF_SIZE = 128;
char buf[BUF_SIZE]; char buf[BUF_SIZE];
// In this function, the characters are parsed. //! In this function, the characters are parsed.
void putChars(char const* begin, char const* end); void putChars(char const* begin, char const* end);
std::string getPreamble(size_t * preambleSize = nullptr);
}; };
#endif #endif
#ifdef UT699 #ifdef UT699
class ServiceInterfaceBuffer: public std::basic_streambuf<char, class ServiceInterfaceBuffer: public std::basic_streambuf<char,
std::char_traits<char> > { std::char_traits<char> > {

View File

@ -1,11 +1,32 @@
#include <framework/serviceinterface/ServiceInterfaceStream.h> #include <framework/serviceinterface/ServiceInterfaceStream.h>
ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
std::ostream(&streambuf),
streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
void ServiceInterfaceStream::setActive( bool myActive) { void ServiceInterfaceStream::setActive( bool myActive) {
this->buf.isActive = myActive; this->streambuf.isActive = myActive;
} }
ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message, std::string ServiceInterfaceStream::getPreamble() {
uint16_t port) : return streambuf.getPreamble();
std::basic_ostream<char, std::char_traits<char> >(&buf), buf( }
set_message, port) {
void ServiceInterfaceStream::print(std::string error,
bool withPreamble, bool withNewline, bool flush) {
if(not streambuf.isBuffered() and withPreamble) {
*this << getPreamble() << error;
}
else {
*this << error;
}
if(withNewline) {
*this << "\n";
}
// if mode is non-buffered, no need to flush.
if(flush and streambuf.isBuffered()) {
this->flush();
}
} }

View File

@ -3,28 +3,56 @@
#include <framework/serviceinterface/ServiceInterfaceBuffer.h> #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
#include <iostream> #include <iostream>
#include <iosfwd>
#include <sstream>
#include <cstdio> #include <cstdio>
// Unfortunately, there must be a forward declaration of log_fe /**
// (MUST be defined in main), to let the system know where to write to. * Generic service interface stream which can be used like std::cout or
namespace sif { * std::cerr but has additional capability. Add preamble and timestamp
extern std::ostream debug; * to output. Can be run in buffered or unbuffered mode.
extern std::ostream info; */
extern std::ostream warning; class ServiceInterfaceStream : public std::ostream {
extern std::ostream error;
}
class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
protected:
ServiceInterfaceBuffer buf;
public: public:
ServiceInterfaceStream( std::string set_message, uint16_t port = 1234 ); /**
* This constructor is used by specifying the preamble message.
* Optionally, the output can be directed to stderr and a CR character
* can be prepended to the preamble.
* @param setMessage message of preamble.
* @param addCrToPreamble Useful for applications like Puttty.
* @param buffered specify whether to use buffered mode.
* @param errStream specify which output stream to use (stderr or stdout).
*/
ServiceInterfaceStream(std::string setMessage,
bool addCrToPreamble = false, bool buffered = true,
bool errStream = false, uint16_t port = 1234);
//! An inactive stream will not print anything.
void setActive( bool ); void setActive( bool );
/**
* This can be used to retrieve the preamble in case it should be printed in
* the unbuffered mode.
* @return Preamle consisting of log message and timestamp.
*/
std::string getPreamble();
/**
* This prints an error with a preamble. Useful if using the unbuffered
* mode. Flushes in default mode (prints immediately).
*/
void print(std::string error, bool withPreamble = true,
bool withNewline = true, bool flush = true);
protected:
ServiceInterfaceBuffer streambuf;
}; };
// Forward declaration of interface streams. These should be instantiated in
// main. They can then be used like std::cout or std::cerr.
namespace sif {
extern ServiceInterfaceStream debug;
extern ServiceInterfaceStream info;
extern ServiceInterfaceStream warning;
extern ServiceInterfaceStream error;
}
#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */ #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

View File

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

View File

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

View File

@ -1,15 +1,5 @@
/** #ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
* @file ExecutableObjectIF.h #define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
*
* @brief This file contains the definition for the ExecutableObjectIF interface.
*
* @author Bastian Baetz
*
* @date 12.03.2012
*/
#ifndef EXECUTABLEOBJECTIF_H_
#define EXECUTABLEOBJECTIF_H_
class PeriodicTaskIF; class PeriodicTaskIF;
@ -20,6 +10,7 @@ class PeriodicTaskIF;
* @brief The interface provides a method to execute objects within a task. * @brief The interface provides a method to execute objects within a task.
* @details The performOperation method, that is required by the interface is * @details The performOperation method, that is required by the interface is
* executed cyclically within a task context. * executed cyclically within a task context.
* @author Bastian Baetz
*/ */
class ExecutableObjectIF { class ExecutableObjectIF {
public: public:
@ -37,13 +28,26 @@ public:
/** /**
* @brief Function called during setup assignment of object to task * @brief Function called during setup assignment of object to task
* @details Has to be called from the function that assigns the object to a task and * @details
* enables the object implementation to overwrite this function and get a reference to the executing task * Has to be called from the function that assigns the object to a task and
* enables the object implementation to overwrite this function and get
* a reference to the executing task
* @param task_ Pointer to the taskIF of this task * @param task_ Pointer to the taskIF of this task
*/ */
virtual void setTaskIF(PeriodicTaskIF* task_) { virtual void setTaskIF(PeriodicTaskIF* task_) {};
/**
* This function should be called after the object was assigned to a
* specific task.
*
* Example: Can be used to get task execution frequency.
* The task is created after initialize() and the object ctors have been
* called so the execution frequency can't be cached in initialize()
* @return
*/
virtual ReturnValue_t initializeAfterTaskCreation() {
return HasReturnvaluesIF::RETURN_OK;
} }
}; };
#endif /* EXECUTABLEOBJECTIF_H_ */ #endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */

View File

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

View File

@ -32,31 +32,31 @@ public:
} }
uint16_t apid; uint16_t apid;
uint16_t ssc; uint16_t ssc;
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&apid, ReturnValue_t result = SerializeAdapter::serialize(&apid,
buffer, size, max_size, bigEndian); buffer, size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter<uint16_t>::serialize(&ssc, buffer, size, return SerializeAdapter::serialize(&ssc, buffer, size,
max_size, bigEndian); maxSize, streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
return sizeof(apid) + sizeof(ssc); return sizeof(apid) + sizeof(ssc);
} }
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter<uint16_t>::deSerialize(&apid, ReturnValue_t result = SerializeAdapter::deSerialize(&apid,
buffer, size, bigEndian); buffer, size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
return SerializeAdapter<uint16_t>::deSerialize(&ssc, buffer, size, return SerializeAdapter::deSerialize(&ssc, buffer, size,
bigEndian); streamEndianness);
} }
}; };
@ -218,74 +218,74 @@ public:
} }
ReturnValue_t serialize(uint8_t** buffer, uint32_t* size, ReturnValue_t serialize(uint8_t** buffer, size_t* size,
const uint32_t max_size, bool bigEndian) const { size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = AutoSerializeAdapter::serialize(&apid,buffer,size,max_size,bigEndian); ReturnValue_t result = SerializeAdapter::serialize(&apid,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = AutoSerializeAdapter::serialize(&sourceSequenceCount,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&sourceSequenceCount,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = AutoSerializeAdapter::serialize(&serviceType,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&serviceType,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = AutoSerializeAdapter::serialize(&serviceSubtype,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&serviceSubtype,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
result = AutoSerializeAdapter::serialize(&subCounter,buffer,size,max_size,bigEndian); result = SerializeAdapter::serialize(&subCounter,buffer,size,maxSize,streamEndianness);
if(result!=HasReturnvaluesIF::RETURN_OK){ if(result!=HasReturnvaluesIF::RETURN_OK){
return result; return result;
} }
SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp)); SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
return adapter.serialize(buffer,size,max_size,bigEndian); return adapter.serialize(buffer,size,maxSize,streamEndianness);
} }
uint32_t getSerializedSize() const { size_t getSerializedSize() const {
uint32_t size = 0; uint32_t size = 0;
size += AutoSerializeAdapter::getSerializedSize(&apid); size += SerializeAdapter::getSerializedSize(&apid);
size += AutoSerializeAdapter::getSerializedSize(&sourceSequenceCount); size += SerializeAdapter::getSerializedSize(&sourceSequenceCount);
size += AutoSerializeAdapter::getSerializedSize(&serviceType); size += SerializeAdapter::getSerializedSize(&serviceType);
size += AutoSerializeAdapter::getSerializedSize(&serviceSubtype); size += SerializeAdapter::getSerializedSize(&serviceSubtype);
size += AutoSerializeAdapter::getSerializedSize(&subCounter); size += SerializeAdapter::getSerializedSize(&subCounter);
SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp)); SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
size += adapter.getSerializedSize(); size += adapter.getSerializedSize();
return size; return size;
}; };
ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size, ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
bool bigEndian) { Endianness streamEndianness) {
ReturnValue_t result = AutoSerializeAdapter::deSerialize(&apid, buffer, ReturnValue_t result = SerializeAdapter::deSerialize(&apid, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = AutoSerializeAdapter::deSerialize(&sourceSequenceCount, buffer, result = SerializeAdapter::deSerialize(&sourceSequenceCount, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = AutoSerializeAdapter::deSerialize(&serviceType, buffer, size, result = SerializeAdapter::deSerialize(&serviceType, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = AutoSerializeAdapter::deSerialize(&serviceSubtype, buffer, result = SerializeAdapter::deSerialize(&serviceSubtype, buffer,
size, bigEndian); size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
result = AutoSerializeAdapter::deSerialize(&subCounter, buffer, size, result = SerializeAdapter::deSerialize(&subCounter, buffer, size,
bigEndian); streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
return result; return result;
} }
SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp)); SerialBufferAdapter<uint8_t> adapter(rawTimestamp,sizeof(rawTimestamp));
return adapter.deSerialize(buffer,size,bigEndian); return adapter.deSerialize(buffer,size,streamEndianness);
} }
private: private:

View File

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

View File

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

View File

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

View File

@ -10,14 +10,14 @@ TmPacketStored::TmPacketStored(store_address_t setAddress) :
} }
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service, TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, const uint8_t* data, uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
uint32_t size, const uint8_t* headerData, uint32_t headerSize) : uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
TmPacketBase(NULL) { TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS; storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) { if (!checkAndSetStore()) {
return; return;
} }
uint8_t* pData = NULL; uint8_t *pData = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress, ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData); (TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &pData);
@ -34,21 +34,21 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
} }
TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service, TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
uint8_t subservice, uint8_t packetSubcounter, SerializeIF* content, uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
SerializeIF* header) : SerializeIF *header) :
TmPacketBase(NULL) { TmPacketBase(NULL) {
storeAddress.raw = StorageManagerIF::INVALID_ADDRESS; storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
if (!checkAndSetStore()) { if (!checkAndSetStore()) {
return; return;
} }
uint32_t sourceDataSize = 0; size_t sourceDataSize = 0;
if (content != NULL) { if (content != NULL) {
sourceDataSize += content->getSerializedSize(); sourceDataSize += content->getSerializedSize();
} }
if (header != NULL) { if (header != NULL) {
sourceDataSize += header->getSerializedSize(); sourceDataSize += header->getSerializedSize();
} }
uint8_t* p_data = NULL; uint8_t *p_data = NULL;
ReturnValue_t returnValue = store->getFreeElement(&storeAddress, ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
(TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data); (TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data);
if (returnValue != store->RETURN_OK) { if (returnValue != store->RETURN_OK) {
@ -56,13 +56,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
} }
setData(p_data); setData(p_data);
initializeTmPacket(apid, service, subservice, packetSubcounter); initializeTmPacket(apid, service, subservice, packetSubcounter);
uint8_t* putDataHere = getSourceData(); uint8_t *putDataHere = getSourceData();
uint32_t size = 0; size_t size = 0;
if (header != NULL) { if (header != NULL) {
header->serialize(&putDataHere, &size, sourceDataSize, true); header->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
} }
if (content != NULL) { if (content != NULL) {
content->serialize(&putDataHere, &size, sourceDataSize, true); content->serialize(&putDataHere, &size, sourceDataSize,
SerializeIF::Endianness::BIG);
} }
setPacketDataLength( setPacketDataLength(
sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1); sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
@ -106,8 +108,8 @@ bool TmPacketStored::checkAndSetStore() {
return true; return true;
} }
StorageManagerIF* TmPacketStored::store = NULL; StorageManagerIF *TmPacketStored::store = NULL;
InternalErrorReporterIF* TmPacketStored::internalErrorReporter = NULL; InternalErrorReporterIF *TmPacketStored::internalErrorReporter = NULL;
ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination, ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
MessageQueueId_t sentFrom, bool doErrorReporting) { MessageQueueId_t sentFrom, bool doErrorReporting) {
@ -116,7 +118,8 @@ ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
return HasReturnvaluesIF::RETURN_FAILED; return HasReturnvaluesIF::RETURN_FAILED;
} }
TmTcMessage tmMessage(getStoreAddress()); TmTcMessage tmMessage(getStoreAddress());
ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination, &tmMessage, sentFrom); ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
&tmMessage, sentFrom);
if (result != HasReturnvaluesIF::RETURN_OK) { if (result != HasReturnvaluesIF::RETURN_OK) {
deletePacket(); deletePacket();
if (doErrorReporting) { if (doErrorReporting) {

View File

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

View File

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

View File

@ -49,7 +49,7 @@ class PusSuccessReport {
private: private:
static const uint16_t MAX_SIZE = 7; static const uint16_t MAX_SIZE = 7;
uint8_t reportBuffer[MAX_SIZE]; uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize; size_t reportSize;
uint8_t * pBuffer; uint8_t * pBuffer;
public: public:
PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl, PusSuccessReport(uint16_t setPacketId, uint16_t setSequenceControl,
@ -63,14 +63,14 @@ class PusFailureReport {
private: private:
static const uint16_t MAX_SIZE = 16; static const uint16_t MAX_SIZE = 16;
uint8_t reportBuffer[MAX_SIZE]; uint8_t reportBuffer[MAX_SIZE];
uint32_t reportSize; size_t reportSize;
uint8_t * pBuffer; uint8_t * pBuffer;
public: public:
PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl, PusFailureReport(uint16_t setPacketId, uint16_t setSequenceControl,
ReturnValue_t setErrorCode, uint8_t setStep = 0, ReturnValue_t setErrorCode, uint8_t setStep = 0,
uint32_t parameter1 = 0, uint32_t parameter2 = 0); uint32_t parameter1 = 0, uint32_t parameter2 = 0);
~PusFailureReport(); ~PusFailureReport();
uint32_t getSize(); size_t getSize();
uint8_t* getReport(); uint8_t* getReport();
}; };

View File

@ -5,11 +5,13 @@
#include <framework/serviceinterface/ServiceInterfaceStream.h> #include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/globalfunctions/arrayprinter.h> #include <framework/globalfunctions/arrayprinter.h>
TmTcBridge::TmTcBridge(object_id_t objectId_, TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
object_id_t ccsdsPacketDistributor_): SystemObject(objectId_), object_id_t tmStoreId, object_id_t tcStoreId):
ccsdsPacketDistributor(ccsdsPacketDistributor_) SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
tcDestination(tcDestination)
{ {
TmTcReceptionQueue = QueueFactory::instance()-> tmTcReceptionQueue = QueueFactory::instance()->
createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH); createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
} }
@ -22,8 +24,9 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
return RETURN_OK; return RETURN_OK;
} }
else { else {
sif::warning << "TmTcBridge: Number of packets sent per cycle " sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
"exceeds limits. Keeping default value." << std::endl; << "packets sent per cycle exceeds limits. "
<< "Keeping default value." << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
} }
} }
@ -35,27 +38,35 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
return RETURN_OK; return RETURN_OK;
} }
else { else {
sif::warning << "TmTcBridge: Number of packets stored " sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
"exceeds limits. Keeping default value." << std::endl; << "packets stored exceeds limits. "
<< "Keeping default value." << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
} }
} }
ReturnValue_t TmTcBridge::initialize() { ReturnValue_t TmTcBridge::initialize() {
tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE); tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
if (tcStore == NULL) { if (tcStore == nullptr) {
return RETURN_FAILED; sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
"it is created and set up properly." << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
} }
tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE); tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
if (tmStore == NULL) { if (tmStore == nullptr) {
return RETURN_FAILED; sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
"it is created and set up properly." << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
} }
AcceptsTelecommandsIF* tcDistributor = AcceptsTelecommandsIF* tcDistributor =
objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor); objectManager->get<AcceptsTelecommandsIF>(tcDestination);
if (tcDistributor == NULL) { if (tcDistributor == nullptr) {
return RETURN_FAILED; sif::error << "TmTcBridge::initialize: TC Distributor invalid"
<< std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
} }
TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
return RETURN_OK; return RETURN_OK;
} }
@ -63,26 +74,25 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
ReturnValue_t result; ReturnValue_t result;
result = handleTc(); result = handleTc();
if(result != RETURN_OK) { if(result != RETURN_OK) {
sif::error << "TMTC Bridge: Error handling TCs" << std::endl; sif::debug << "TmTcBridge::performOperation: "
<< "Error handling TCs" << std::endl;
} }
result = handleTm(); result = handleTm();
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::error << "TMTC Bridge: Error handling TMs" << std::endl; sif::debug << "TmTcBridge::performOperation: "
<< "Error handling TMs" << std::endl;
} }
return result; return result;
} }
ReturnValue_t TmTcBridge::handleTc() { ReturnValue_t TmTcBridge::handleTc() {
uint8_t * recvBuffer = nullptr; return HasReturnvaluesIF::RETURN_OK;
size_t recvLen = 0;
ReturnValue_t result = receiveTc(&recvBuffer, &recvLen);
return result;
} }
ReturnValue_t TmTcBridge::handleTm() { ReturnValue_t TmTcBridge::handleTm() {
ReturnValue_t result = handleTmQueue(); ReturnValue_t result = handleTmQueue();
if(result != RETURN_OK) { if(result != RETURN_OK) {
sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl; sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
} }
@ -97,8 +107,8 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
TmTcMessage message; TmTcMessage message;
const uint8_t* data = nullptr; const uint8_t* data = nullptr;
size_t size = 0; size_t size = 0;
for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message); for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message)) result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
{ {
if(communicationLinkUp == false) { if(communicationLinkUp == false) {
result = storeDownlinkData(&message); result = storeDownlinkData(&message);
@ -112,7 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
result = sendTm(data, size); result = sendTm(data, size);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl; sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
tmStore->deleteData(message.getStorageId()); tmStore->deleteData(message.getStorageId());
return result; return result;
@ -123,13 +133,12 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
} }
ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) { ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
//debug << "TMTC Bridge: Comm Link down. "
// "Saving packet ID to be sent later\r\n" << std::flush;
store_address_t storeId = 0; store_address_t storeId = 0;
if(tmFifo.full()) { if(tmFifo.full()) {
sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs " sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
"reached! Overwriting old data" << std::endl; << "of stored packet IDs reached! "
<< "Overwriting old data" << std::endl;
tmFifo.retrieve(&storeId); tmFifo.retrieve(&storeId);
tmStore->deleteData(storeId); tmStore->deleteData(storeId);
} }
@ -183,10 +192,20 @@ void TmTcBridge::registerCommDisconnect() {
} }
MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) { MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
return TmTcReceptionQueue->getId(); return tmTcReceptionQueue->getId();
} }
void TmTcBridge::printData(uint8_t * data, size_t dataLen) { void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
arrayprinter::print(data, dataLen); arrayprinter::print(data, dataLen);
} }
uint16_t TmTcBridge::getIdentifier() {
// This is no PUS service, so we just return 0
return 0;
}
MessageQueueId_t TmTcBridge::getRequestQueue() {
// Default implementation: Relay TC messages to TC distributor directly.
return tmTcReceptionQueue->getDefaultDestination();
}

View File

@ -1,16 +1,18 @@
#ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
#define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_ #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
#include <framework/objectmanager/SystemObject.h>
#include <framework/tmtcservices/AcceptsTelemetryIF.h> #include <framework/tmtcservices/AcceptsTelemetryIF.h>
#include <framework/tasks/ExecutableObjectIF.h> #include <framework/tasks/ExecutableObjectIF.h>
#include <framework/ipc/MessageQueueIF.h> #include <framework/ipc/MessageQueueIF.h>
#include <framework/storagemanager/StorageManagerIF.h> #include <framework/storagemanager/StorageManagerIF.h>
#include <framework/objectmanager/SystemObject.h> #include <framework/tmtcservices/AcceptsTelecommandsIF.h>
#include <framework/tmtcservices/TmTcMessage.h>
#include <framework/container/FIFO.h> #include <framework/container/FIFO.h>
#include <framework/tmtcservices/TmTcMessage.h>
class TmTcBridge : public AcceptsTelemetryIF, class TmTcBridge : public AcceptsTelemetryIF,
public AcceptsTelecommandsIF,
public ExecutableObjectIF, public ExecutableObjectIF,
public HasReturnvaluesIF, public HasReturnvaluesIF,
public SystemObject { public SystemObject {
@ -22,7 +24,8 @@ public:
static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5; static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10; static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_); TmTcBridge(object_id_t objectId, object_id_t tcDestination,
object_id_t tmStoreId, object_id_t tcStoreId);
virtual ~TmTcBridge(); virtual ~TmTcBridge();
/** /**
@ -57,45 +60,42 @@ public:
*/ */
virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override; virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
/**
* Return TMTC Reception Queue /** AcceptsTelemetryIF override */
* @param virtualChannel virtual MessageQueueId_t getReportReceptionQueue(
* @return
*/
MessageQueueId_t getReportReceptionQueue(
uint8_t virtualChannel = 0) override; uint8_t virtualChannel = 0) override;
/** AcceptsTelecommandsIF override */
virtual uint16_t getIdentifier() override;
virtual MessageQueueId_t getRequestQueue() override;
protected: protected:
//! Cached for initialize function.
object_id_t tmStoreId = objects::NO_OBJECT;
object_id_t tcStoreId = objects::NO_OBJECT;
object_id_t tcDestination = objects::NO_OBJECT;
//! Used to send and receive TMTC messages. //! Used to send and receive TMTC messages.
//! TmTcMessage is used to transport messages between tasks. //! The TmTcMessage class is used to transport messages between tasks.
MessageQueueIF* TmTcReceptionQueue = nullptr; MessageQueueIF* tmTcReceptionQueue = nullptr;
StorageManagerIF* tcStore = nullptr;
StorageManagerIF* tmStore = nullptr; StorageManagerIF* tmStore = nullptr;
object_id_t ccsdsPacketDistributor = 0; StorageManagerIF* tcStore = nullptr;
//! Used to specify whether communication link is up
bool communicationLinkUp = false; //! Used to specify whether communication link is up. Will be true
//! by default, so telemetry will be handled immediately.
bool communicationLinkUp = true;
bool tmStored = false; bool tmStored = false;
/** /**
* @brief Handle TC reception * @brief Handle TC reception
* @details * @details
* Default implementation provided, but is empty. * Default implementation provided, but is empty.
* Child handler should override this in most cases orsend TC to the * In most cases, TC reception will be handled in a separate task anyway.
* TC distributor directly with the address of the reception queue by
* calling getReportRecptionQueue()
* @return * @return
*/ */
virtual ReturnValue_t handleTc(); virtual ReturnValue_t handleTc();
/**
* Implemented by child class. Perform receiving of Telecommand,
* for example by implementing specific drivers or wrappers,
* e.g. UART Communication or an ethernet stack
* @param recvBuffer [out] Received data
* @param size [out] Size of received data
* @return
*/
virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, size_t * size) = 0;
/** /**
* Handle Telemetry. Default implementation provided. * Handle Telemetry. Default implementation provided.
* Calls sendTm() * Calls sendTm()
@ -104,7 +104,8 @@ protected:
virtual ReturnValue_t handleTm(); virtual ReturnValue_t handleTm();
/** /**
* Read the TM Queue and send TM if necessary. Default implementation provided * Read the TM Queue and send TM if necessary.
* Default implementation provided
* @return * @return
*/ */
virtual ReturnValue_t handleTmQueue(); virtual ReturnValue_t handleTmQueue();
@ -117,7 +118,8 @@ protected:
/** /**
* Implemented by child class. Perform sending of Telemetry by implementing * Implemented by child class. Perform sending of Telemetry by implementing
* communication drivers or wrappers, e.g. UART communication or lwIP stack. * communication drivers or wrappers, e.g. serial communication or a socket
* call.
* @param data * @param data
* @param dataLen * @param dataLen
* @return * @return