diff --git a/datapool/PoolRawAccess.cpp b/datapool/PoolRawAccess.cpp index 6e9b3d08..41efdd7a 100644 --- a/datapool/PoolRawAccess.cpp +++ b/datapool/PoolRawAccess.cpp @@ -5,13 +5,27 @@ #include PoolRawAccess::PoolRawAccess(uint32_t set_id, uint8_t setArrayEntry, - DataSetIF* data_set, ReadWriteMode_t setReadWriteMode) : + DataSetIF* data_set, ReadWriteMode_t setReadWriteMode, + bool registerVectors) : dataPoolId(set_id), arrayEntry(setArrayEntry), valid(false), type(Type::UNKNOWN_TYPE), typeSize( 0), arraySize(0), sizeTillEnd(0), readWriteMode(setReadWriteMode) { memset(value, 0, sizeof(value)); if (data_set != NULL) { data_set->registerVariable(this); } + if(registerVectors == true) { + this->read(); + if(arraySize > 1) { + for(uint16_t vectorCount = typeSize;vectorCount < arraySize;vectorCount += typeSize) + { + PoolRawAccess * newPoolRawAccess = + new PoolRawAccess(set_id, setArrayEntry + typeSize, + data_set,setReadWriteMode,true); + if(newPoolRawAccess) {}; + } + } + } + } PoolRawAccess::~PoolRawAccess() { @@ -31,9 +45,10 @@ ReturnValue_t PoolRawAccess::read() { sizeTillEnd = read_out->getByteSize() - arrayPosition; uint8_t* ptr = &((uint8_t*) read_out->getRawData())[arrayPosition]; - for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) { - memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize); - } + memcpy(value, ptr, typeSize); + //for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) { + // memcpy(value + typeSize * arrayCount, ptr + typeSize * arrayCount, typeSize); + //} return HasReturnvaluesIF::RETURN_OK; } else { @@ -155,20 +170,25 @@ ReturnValue_t PoolRawAccess::serialize(uint8_t** buffer, uint32_t* size, #ifndef BYTE_ORDER_SYSTEM #error BYTE_ORDER_SYSTEM not defined #elif BYTE_ORDER_SYSTEM == LITTLE_ENDIAN - for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) { - for (uint8_t count = 0; count < typeSize; count++) { - (*buffer)[typeSize * (arrayCount + 1) - count - 1] = - value[typeSize * arrayCount + count]; - } + for (uint8_t count = 0; count < typeSize; count++) { + (*buffer)[count] = value[typeSize - count - 1]; } + //for(uint8_t arrayCount = 0; arrayCount < arraySize; arrayCount++) { + // for (uint8_t count = 0; count < typeSize; count++) { + // (*buffer)[typeSize * (arrayCount + 1) - count - 1] = + // value[typeSize * arrayCount + count]; + // } + //} #elif BYTE_ORDER_SYSTEM == BIG_ENDIAN - memcpy(*buffer, value, typeSize * arraySize); + memcpy(*buffer, value, typeSize); + //memcpy(*buffer, value, typeSize * arraySize); #endif } else { - memcpy(*buffer, value, typeSize * arraySize); + memcpy(*buffer, value, typeSize); + //memcpy(*buffer, value, typeSize * arraySize); } - *size += typeSize * arraySize; - (*buffer) += typeSize * arraySize; + *size += typeSize;// * arraySize; + (*buffer) += typeSize;// * arraySize; return HasReturnvaluesIF::RETURN_OK; } else { return SerializeIF::BUFFER_TOO_SHORT; diff --git a/datapool/PoolRawAccess.h b/datapool/PoolRawAccess.h index 2a634fa8..e85bef24 100644 --- a/datapool/PoolRawAccess.h +++ b/datapool/PoolRawAccess.h @@ -6,10 +6,14 @@ #include /** - * This class allows accessing Data Pool variables as raw bytes. + * @brief This class allows accessing Data Pool variables as raw bytes. + * @details * This is necessary to have an access method for HK data, as the PID's alone do not - * provide a type information. - * \ingroup data_pool + * provide a type information. Please note that the the raw pool access read() and commit() + * calls are not thread-safe and therefore private. + * Please supply a data set and use the data set read(), commit() calls for thread-safe + * data pool access. + * @ingroup data_pool */ class PoolRawAccess: public PoolVariableIF { private: @@ -48,6 +52,18 @@ private: ReadWriteMode_t readWriteMode; static const uint8_t RAW_MAX_SIZE = sizeof(double); protected: + /** + * \brief This is a call to read the value from the global data pool. + * \details When executed, this operation tries to fetch the pool entry with matching + * data pool id from the global data pool and copies the value and the valid + * information to its local attributes. In case of a failure (wrong type or + * pool id not found), the variable is set to zero and invalid. + * The operation does NOT provide any mutual exclusive protection by itself ! + * If reading from the data pool without information about the type is desired, + * initialize the raw pool access by supplying a data set and using the data set + * read function, which calls this read function. + */ + ReturnValue_t read(); /** * \brief The commit call writes back the variable's value to the data pool. * \details It checks type and size, as well as if the variable is writable. If so, @@ -62,23 +78,25 @@ public: static const ReturnValue_t INCORRECT_SIZE = MAKE_RETURN_CODE(0x01); static const ReturnValue_t DATA_POOL_ACCESS_FAILED = MAKE_RETURN_CODE(0x02); uint8_t value[RAW_MAX_SIZE]; + //uint8_t value[RAW_MAX_SIZE*3]; + + /** + * This constructor is used to access a data pool entry with a + * given ID if the target type is not known. A DataSet object is supplied + * and the data pool entry with the given ID is registered to that data set + * @param data_pool_id Target data pool entry ID + * @param arrayEntry + * @param data_set Dataset to register data pool entry to + * @param setReadWriteMode + */ PoolRawAccess(uint32_t data_pool_id, uint8_t arrayEntry, DataSetIF* data_set, ReadWriteMode_t setReadWriteMode = - PoolVariableIF::VAR_READ); + PoolVariableIF::VAR_READ,bool registerVectors = false); /** * \brief The classes destructor is empty. If commit() was not called, the local value is * discarded and not written back to the data pool. */ ~PoolRawAccess(); - /** - * \brief This is a call to read the value from the global data pool. - * \details When executed, this operation tries to fetch the pool entry with matching - * data pool id from the global data pool and copies the value and the valid - * information to its local attributes. In case of a failure (wrong type or - * pool id not found), the variable is set to zero and invalid. - * The operation does NOT provide any mutual exclusive protection by itself. - */ - ReturnValue_t read(); /** * @brief Serialize raw pool entry into provided buffer directly