mohr/fsfw
1
0
Fork 0
forked from fsfw/fsfw
Code Pull Requests Activity

updating code from Flying Laptop

Browse Source 
This is the framework of Flying Laptop OBSW version A.13.0.
This commit is contained in:
Ulrich Mohr
2018-07-12 16:29:32 +02:00
parent 1d22a6c97e
commit 575f70ba03
395 changed files with 12807 additions and 8404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
serialize/EndianSwapper.h
View File

@ -1,9 +1,9 @@
#ifndef ENDIANSWAPPER_H_
#define ENDIANSWAPPER_H_
#include <framework/osal/OSAL.h>
//#include <endian.h> //for testing on x86
#include <framework/osal/Endiness.h>
#include <cstring>
class EndianSwapper {
private:

6
serialize/SerialArrayListAdapter.h
View File

@ -57,11 +57,13 @@ public:
static ReturnValue_t deSerialize(ArrayList<T, count_t>* list, const uint8_t** buffer, int32_t* size,
bool bigEndian) {
ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&list->size,
count_t tempSize = 0;
ReturnValue_t result = SerializeAdapter<count_t>::deSerialize(&tempSize,
buffer, size, bigEndian);
if (list->size > list->maxSize()) {
if (tempSize > list->maxSize()) {
return SerializeIF::TOO_MANY_ELEMENTS;
}
list->size = tempSize;
count_t i = 0;
while ((result == HasReturnvaluesIF::RETURN_OK) && (i < list->size)) {
result = SerializeAdapter<T>::deSerialize(

70
serialize/SerialBufferAdapter.cpp
View File

@ -1,23 +1,41 @@
#include <framework/serialize/SerialBufferAdapter.h>
#include <cstring>
SerialBufferAdapter::SerialBufferAdapter(const uint8_t* buffer,
uint32_t bufferLength) :
constBuffer(buffer), buffer(NULL), bufferLength(bufferLength) {
template<typename T>
SerialBufferAdapter<T>::SerialBufferAdapter(const uint8_t* buffer,
T bufferLength, bool serializeLenght) :
serializeLength(serializeLenght), constBuffer(buffer), buffer(NULL), bufferLength(
bufferLength) {
}
SerialBufferAdapter::SerialBufferAdapter(uint8_t* buffer, uint32_t bufferLength) :
constBuffer(NULL), buffer(buffer), bufferLength(bufferLength) {
template<typename T>
SerialBufferAdapter<T>::SerialBufferAdapter(uint8_t* buffer, T bufferLength,
bool serializeLenght) :
serializeLength(serializeLenght), constBuffer(NULL), buffer(buffer), bufferLength(
bufferLength) {
}
SerialBufferAdapter::~SerialBufferAdapter() {
template<typename T>
SerialBufferAdapter<T>::~SerialBufferAdapter() {
}
ReturnValue_t SerialBufferAdapter::serialize(uint8_t** buffer, uint32_t* size,
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::serialize(uint8_t** buffer, uint32_t* size,
const uint32_t max_size, bool bigEndian) const {
if (*size + bufferLength > max_size) {
uint32_t serializedLength = bufferLength;
if (serializeLength) {
serializedLength += AutoSerializeAdapter::getSerializedSize(
&bufferLength);
}
if (*size + serializedLength > max_size) {
return BUFFER_TOO_SHORT;
} else {
if (serializeLength) {
AutoSerializeAdapter::serialize(&bufferLength, buffer, size,
max_size, bigEndian);
}
if (this->constBuffer != NULL) {
memcpy(*buffer, this->constBuffer, bufferLength);
} else if (this->buffer != NULL) {
@ -26,22 +44,39 @@ ReturnValue_t SerialBufferAdapter::serialize(uint8_t** buffer, uint32_t* size,
return HasReturnvaluesIF::RETURN_FAILED;
}
*size += bufferLength;
buffer += bufferLength;
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
}
}
uint32_t SerialBufferAdapter::getSerializedSize() const {
return bufferLength;
template<typename T>
uint32_t SerialBufferAdapter<T>::getSerializedSize() const {
if (serializeLength) {
return bufferLength + AutoSerializeAdapter::getSerializedSize(&bufferLength);
} else {
return bufferLength;
}
}
ReturnValue_t SerialBufferAdapter::deSerialize(const uint8_t** buffer,
template<typename T>
ReturnValue_t SerialBufferAdapter<T>::deSerialize(const uint8_t** buffer,
int32_t* size, bool bigEndian) {
//TODO Ignores Endian flag!
if (buffer != NULL) {
if(serializeLength){
T serializedSize = AutoSerializeAdapter::getSerializedSize(
&bufferLength);
if((*size - bufferLength - serializedSize) >= 0){
*buffer += serializedSize;
*size -= serializedSize;
}else{
return STREAM_TOO_SHORT;
}
}
//No Else If, go on with buffer
if (*size - bufferLength >= 0) {
*size -= bufferLength;
memcpy(this->buffer, *buffer, bufferLength);
buffer += bufferLength;
(*buffer) += bufferLength;
return HasReturnvaluesIF::RETURN_OK;
} else {
return STREAM_TOO_SHORT;
@ -50,3 +85,10 @@ ReturnValue_t SerialBufferAdapter::deSerialize(const uint8_t** buffer,
return HasReturnvaluesIF::RETURN_FAILED;
}
}
//forward Template declaration for linker
template class SerialBufferAdapter<uint8_t>;
template class SerialBufferAdapter<uint16_t>;
template class SerialBufferAdapter<uint32_t>;

12
serialize/SerialBufferAdapter.h
View File

@ -2,11 +2,14 @@
#define SERIALBUFFERADAPTER_H_
#include <framework/serialize/SerializeIF.h>
#include <framework/serialize/SerializeAdapter.h>
template<typename T>
class SerialBufferAdapter: public SerializeIF {
public:
SerialBufferAdapter(const uint8_t * buffer, uint32_t bufferLength);
SerialBufferAdapter(uint8_t* buffer, uint32_t bufferLength);
SerialBufferAdapter(const uint8_t * buffer, T bufferLength, bool serializeLenght = false);
SerialBufferAdapter(uint8_t* buffer, T bufferLength,
bool serializeLenght = false);
virtual ~SerialBufferAdapter();
@ -18,9 +21,12 @@ public:
virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
bool bigEndian);
private:
bool serializeLength;
const uint8_t *constBuffer;
uint8_t *buffer;
uint32_t bufferLength;
T bufferLength;
};
#endif /* SERIALBUFFERADAPTER_H_ */

7
serialize/SerialFixedArrayListAdapter.h
View File

@ -1,10 +1,3 @@
/*
* SerialFixedArrayListAdapter.h
*
* Created on: 22.07.2014
* Author: baetz
*/
#ifndef SERIALFIXEDARRAYLISTADAPTER_H_
#define SERIALFIXEDARRAYLISTADAPTER_H_

29
serialize/SerializeAdapter.h
View File

@ -1,10 +1,3 @@
/*
* SerializeAdapter.h
*
* Created on: 19.03.2014
* Author: baetz
*/
#ifndef SERIALIZEADAPTER_H_
#define SERIALIZEADAPTER_H_
@ -104,4 +97,26 @@ public:
}
};
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_ */

7
serialize/SerializeElement.h
View File

@ -1,10 +1,3 @@
/*
* SerializeElement.h
*
* Created on: 24.03.2014
* Author: baetz
*/
#ifndef SERIALIZEELEMENT_H_
#define SERIALIZEELEMENT_H_

9
serialize/SerializeIF.h
View File

@ -1,10 +1,3 @@
/*
* SerializeIF.h
*
* Created on: 19.03.2014
* Author: baetz
*/
#ifndef SERIALIZEIF_H_
#define SERIALIZEIF_H_
@ -12,7 +5,7 @@
class SerializeIF {
public:
static const uint8_t INTERFACE_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 STREAM_TOO_SHORT = MAKE_RETURN_CODE(2);
static const ReturnValue_t TOO_MANY_ELEMENTS = MAKE_RETURN_CODE(3);