renormalized line endings
This commit is contained in:
@ -1,67 +1,67 @@
|
||||
#ifndef HASPARAMETERSIF_H_
|
||||
#define HASPARAMETERSIF_H_
|
||||
|
||||
#include "../parameters/ParameterWrapper.h"
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include <stdint.h>
|
||||
|
||||
/** Each parameter is identified with a unique parameter ID */
|
||||
typedef uint32_t ParameterId_t;
|
||||
|
||||
/**
|
||||
* @brief This interface is used by components which have modifiable
|
||||
* parameters, e.g. atittude controllers
|
||||
* @details
|
||||
* Each parameter has a unique parameter ID. The first byte of the parameter
|
||||
* ID is the domain ID which can be used to identify unqiue spacecraft domains
|
||||
* (e.g. control and sensor domain in the AOCS controller).
|
||||
*
|
||||
* The second and third byte represent the matrix ID, which can represent
|
||||
* a 8-bit row and column number and the last byte...
|
||||
*
|
||||
* Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
|
||||
* of a 8 bit number now?
|
||||
*/
|
||||
class HasParametersIF {
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
|
||||
static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
|
||||
static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
|
||||
static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
|
||||
static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
|
||||
|
||||
static uint8_t getDomain(ParameterId_t id) {
|
||||
return id >> 24;
|
||||
}
|
||||
|
||||
static uint16_t getMatrixId(ParameterId_t id) {
|
||||
return id >> 8;
|
||||
}
|
||||
|
||||
static uint8_t getIndex(ParameterId_t id) {
|
||||
return id;
|
||||
}
|
||||
|
||||
static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
|
||||
uint8_t index) {
|
||||
return (domainId << 24) + (parameterId << 8) + index;
|
||||
}
|
||||
|
||||
virtual ~HasParametersIF() {}
|
||||
|
||||
/**
|
||||
* Always set parameter before checking newValues!
|
||||
*
|
||||
* @param domainId
|
||||
* @param parameterId
|
||||
* @param parameterWrapper
|
||||
* @param newValues
|
||||
* @param startAtIndex
|
||||
* @return
|
||||
*/
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
|
||||
};
|
||||
|
||||
#endif /* HASPARAMETERSIF_H_ */
|
||||
#ifndef HASPARAMETERSIF_H_
|
||||
#define HASPARAMETERSIF_H_
|
||||
|
||||
#include "../parameters/ParameterWrapper.h"
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include <stdint.h>
|
||||
|
||||
/** Each parameter is identified with a unique parameter ID */
|
||||
typedef uint32_t ParameterId_t;
|
||||
|
||||
/**
|
||||
* @brief This interface is used by components which have modifiable
|
||||
* parameters, e.g. atittude controllers
|
||||
* @details
|
||||
* Each parameter has a unique parameter ID. The first byte of the parameter
|
||||
* ID is the domain ID which can be used to identify unqiue spacecraft domains
|
||||
* (e.g. control and sensor domain in the AOCS controller).
|
||||
*
|
||||
* The second and third byte represent the matrix ID, which can represent
|
||||
* a 8-bit row and column number and the last byte...
|
||||
*
|
||||
* Yeah, it it matrix ID oder parameter ID now and is index a 16 bit number
|
||||
* of a 8 bit number now?
|
||||
*/
|
||||
class HasParametersIF {
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::HAS_PARAMETERS_IF;
|
||||
static const ReturnValue_t INVALID_MATRIX_ID = MAKE_RETURN_CODE(0x01);
|
||||
static const ReturnValue_t INVALID_DOMAIN_ID = MAKE_RETURN_CODE(0x02);
|
||||
static const ReturnValue_t INVALID_VALUE = MAKE_RETURN_CODE(0x03);
|
||||
static const ReturnValue_t READ_ONLY = MAKE_RETURN_CODE(0x05);
|
||||
|
||||
static uint8_t getDomain(ParameterId_t id) {
|
||||
return id >> 24;
|
||||
}
|
||||
|
||||
static uint16_t getMatrixId(ParameterId_t id) {
|
||||
return id >> 8;
|
||||
}
|
||||
|
||||
static uint8_t getIndex(ParameterId_t id) {
|
||||
return id;
|
||||
}
|
||||
|
||||
static uint32_t getFullParameterId(uint8_t domainId, uint16_t parameterId,
|
||||
uint8_t index) {
|
||||
return (domainId << 24) + (parameterId << 8) + index;
|
||||
}
|
||||
|
||||
virtual ~HasParametersIF() {}
|
||||
|
||||
/**
|
||||
* Always set parameter before checking newValues!
|
||||
*
|
||||
* @param domainId
|
||||
* @param parameterId
|
||||
* @param parameterWrapper
|
||||
* @param newValues
|
||||
* @param startAtIndex
|
||||
* @return
|
||||
*/
|
||||
virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex) = 0;
|
||||
};
|
||||
|
||||
#endif /* HASPARAMETERSIF_H_ */
|
||||
|
||||
@ -1,132 +1,132 @@
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
#include "../parameters/ParameterHelper.h"
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
|
||||
ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
|
||||
owner(owner) {}
|
||||
|
||||
ParameterHelper::~ParameterHelper() {
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
switch (message->getCommand()) {
|
||||
case ParameterMessage::CMD_PARAMETER_DUMP: {
|
||||
ParameterWrapper description;
|
||||
uint8_t domain = HasParametersIF::getDomain(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint16_t parameterId = HasParametersIF::getMatrixId(
|
||||
ParameterMessage::getParameterId(message));
|
||||
result = owner->getParameter(domain, parameterId,
|
||||
&description, &description, 0);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = sendParameter(message->getSender(),
|
||||
ParameterMessage::getParameterId(message), &description);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ParameterMessage::CMD_PARAMETER_LOAD: {
|
||||
uint8_t domain = HasParametersIF::getDomain(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint16_t parameterId = HasParametersIF::getMatrixId(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint8_t index = HasParametersIF::getIndex(
|
||||
ParameterMessage::getParameterId(message));
|
||||
|
||||
const uint8_t *storedStream = nullptr;
|
||||
size_t storedStreamSize = 0;
|
||||
result = storage->getData(
|
||||
ParameterMessage::getStoreId(message), &storedStream,
|
||||
&storedStreamSize);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "ParameterHelper::handleParameterMessage: Getting"
|
||||
" store data failed for load command." << std::endl;
|
||||
break;
|
||||
}
|
||||
|
||||
ParameterWrapper streamWrapper;
|
||||
result = streamWrapper.set(storedStream, storedStreamSize);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
break;
|
||||
}
|
||||
|
||||
ParameterWrapper ownerWrapper;
|
||||
result = owner->getParameter(domain, parameterId, &ownerWrapper,
|
||||
&streamWrapper, index);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
break;
|
||||
}
|
||||
|
||||
result = ownerWrapper.copyFrom(&streamWrapper, index);
|
||||
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = sendParameter(message->getSender(),
|
||||
ParameterMessage::getParameterId(message), &ownerWrapper);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
rejectCommand(message->getSender(), result, message->getCommand());
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
|
||||
const ParameterWrapper* description) {
|
||||
size_t serializedSize = description->getSerializedSize();
|
||||
|
||||
uint8_t *storeElement;
|
||||
store_address_t address;
|
||||
|
||||
ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
|
||||
&storeElement);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t storeElementSize = 0;
|
||||
|
||||
result = description->serialize(&storeElement, &storeElementSize,
|
||||
serializedSize, SerializeIF::Endianness::BIG);
|
||||
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(address);
|
||||
return result;
|
||||
}
|
||||
|
||||
CommandMessage reply;
|
||||
|
||||
ParameterMessage::setParameterDumpReply(&reply, id, address);
|
||||
|
||||
MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::initialize() {
|
||||
ownerQueueId = owner->getCommandQueue();
|
||||
|
||||
|
||||
storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
|
||||
if (storage == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
} else {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
}
|
||||
|
||||
void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
|
||||
Command_t initialCommand) {
|
||||
CommandMessage reply;
|
||||
reply.setReplyRejected(reason, initialCommand);
|
||||
MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
|
||||
}
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
#include "../parameters/ParameterHelper.h"
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
|
||||
ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner) :
|
||||
owner(owner) {}
|
||||
|
||||
ParameterHelper::~ParameterHelper() {
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::handleParameterMessage(CommandMessage *message) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
switch (message->getCommand()) {
|
||||
case ParameterMessage::CMD_PARAMETER_DUMP: {
|
||||
ParameterWrapper description;
|
||||
uint8_t domain = HasParametersIF::getDomain(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint16_t parameterId = HasParametersIF::getMatrixId(
|
||||
ParameterMessage::getParameterId(message));
|
||||
result = owner->getParameter(domain, parameterId,
|
||||
&description, &description, 0);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = sendParameter(message->getSender(),
|
||||
ParameterMessage::getParameterId(message), &description);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ParameterMessage::CMD_PARAMETER_LOAD: {
|
||||
uint8_t domain = HasParametersIF::getDomain(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint16_t parameterId = HasParametersIF::getMatrixId(
|
||||
ParameterMessage::getParameterId(message));
|
||||
uint8_t index = HasParametersIF::getIndex(
|
||||
ParameterMessage::getParameterId(message));
|
||||
|
||||
const uint8_t *storedStream = nullptr;
|
||||
size_t storedStreamSize = 0;
|
||||
result = storage->getData(
|
||||
ParameterMessage::getStoreId(message), &storedStream,
|
||||
&storedStreamSize);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::error << "ParameterHelper::handleParameterMessage: Getting"
|
||||
" store data failed for load command." << std::endl;
|
||||
break;
|
||||
}
|
||||
|
||||
ParameterWrapper streamWrapper;
|
||||
result = streamWrapper.set(storedStream, storedStreamSize);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
break;
|
||||
}
|
||||
|
||||
ParameterWrapper ownerWrapper;
|
||||
result = owner->getParameter(domain, parameterId, &ownerWrapper,
|
||||
&streamWrapper, index);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
break;
|
||||
}
|
||||
|
||||
result = ownerWrapper.copyFrom(&streamWrapper, index);
|
||||
|
||||
storage->deleteData(ParameterMessage::getStoreId(message));
|
||||
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = sendParameter(message->getSender(),
|
||||
ParameterMessage::getParameterId(message), &ownerWrapper);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
rejectCommand(message->getSender(), result, message->getCommand());
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
|
||||
const ParameterWrapper* description) {
|
||||
size_t serializedSize = description->getSerializedSize();
|
||||
|
||||
uint8_t *storeElement;
|
||||
store_address_t address;
|
||||
|
||||
ReturnValue_t result = storage->getFreeElement(&address, serializedSize,
|
||||
&storeElement);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t storeElementSize = 0;
|
||||
|
||||
result = description->serialize(&storeElement, &storeElementSize,
|
||||
serializedSize, SerializeIF::Endianness::BIG);
|
||||
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
storage->deleteData(address);
|
||||
return result;
|
||||
}
|
||||
|
||||
CommandMessage reply;
|
||||
|
||||
ParameterMessage::setParameterDumpReply(&reply, id, address);
|
||||
|
||||
MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterHelper::initialize() {
|
||||
ownerQueueId = owner->getCommandQueue();
|
||||
|
||||
|
||||
storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
|
||||
if (storage == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
} else {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
}
|
||||
|
||||
void ParameterHelper::rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
|
||||
Command_t initialCommand) {
|
||||
CommandMessage reply;
|
||||
reply.setReplyRejected(reason, initialCommand);
|
||||
MessageQueueSenderIF::sendMessage(to, &reply, ownerQueueId);
|
||||
}
|
||||
|
||||
@ -1,36 +1,36 @@
|
||||
#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
|
||||
#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
|
||||
|
||||
#include "../ipc/MessageQueueIF.h"
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
#include "../parameters/ReceivesParameterMessagesIF.h"
|
||||
|
||||
/**
|
||||
* @brief Helper class to handle parameter messages
|
||||
* @details
|
||||
* This class simplfiies handling of parameter messages, which are sent
|
||||
* to a class which implements ReceivesParameterMessagesIF.
|
||||
*/
|
||||
class ParameterHelper {
|
||||
public:
|
||||
ParameterHelper(ReceivesParameterMessagesIF *owner);
|
||||
virtual ~ParameterHelper();
|
||||
|
||||
ReturnValue_t handleParameterMessage(CommandMessage *message);
|
||||
|
||||
ReturnValue_t initialize();
|
||||
private:
|
||||
ReceivesParameterMessagesIF *owner;
|
||||
|
||||
MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
|
||||
|
||||
StorageManagerIF *storage = nullptr;
|
||||
|
||||
ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
|
||||
const ParameterWrapper *description);
|
||||
|
||||
void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
|
||||
Command_t initialCommand);
|
||||
};
|
||||
|
||||
#endif /* PARAMETERHELPER_H_ */
|
||||
#ifndef FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
|
||||
#define FRAMEWORK_PARAMETERS_PARAMETERHELPER_H_
|
||||
|
||||
#include "../ipc/MessageQueueIF.h"
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
#include "../parameters/ReceivesParameterMessagesIF.h"
|
||||
|
||||
/**
|
||||
* @brief Helper class to handle parameter messages
|
||||
* @details
|
||||
* This class simplfiies handling of parameter messages, which are sent
|
||||
* to a class which implements ReceivesParameterMessagesIF.
|
||||
*/
|
||||
class ParameterHelper {
|
||||
public:
|
||||
ParameterHelper(ReceivesParameterMessagesIF *owner);
|
||||
virtual ~ParameterHelper();
|
||||
|
||||
ReturnValue_t handleParameterMessage(CommandMessage *message);
|
||||
|
||||
ReturnValue_t initialize();
|
||||
private:
|
||||
ReceivesParameterMessagesIF *owner;
|
||||
|
||||
MessageQueueId_t ownerQueueId = MessageQueueIF::NO_QUEUE;
|
||||
|
||||
StorageManagerIF *storage = nullptr;
|
||||
|
||||
ReturnValue_t sendParameter(MessageQueueId_t to, uint32_t id,
|
||||
const ParameterWrapper *description);
|
||||
|
||||
void rejectCommand(MessageQueueId_t to, ReturnValue_t reason,
|
||||
Command_t initialCommand);
|
||||
};
|
||||
|
||||
#endif /* PARAMETERHELPER_H_ */
|
||||
|
||||
@ -1,48 +1,48 @@
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
|
||||
ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
|
||||
return message->getParameter();
|
||||
}
|
||||
|
||||
store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
|
||||
store_address_t address;
|
||||
address.raw = message->getParameter2();
|
||||
return address;
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
|
||||
ParameterId_t id) {
|
||||
message->setCommand(CMD_PARAMETER_DUMP);
|
||||
message->setParameter(id);
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterDumpReply(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID) {
|
||||
message->setCommand(REPLY_PARAMETER_DUMP);
|
||||
message->setParameter(id);
|
||||
message->setParameter2(storageID.raw);
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID) {
|
||||
message->setCommand(CMD_PARAMETER_LOAD);
|
||||
message->setParameter(id);
|
||||
message->setParameter2(storageID.raw);
|
||||
}
|
||||
|
||||
void ParameterMessage::clear(CommandMessage* message) {
|
||||
switch (message->getCommand()) {
|
||||
case CMD_PARAMETER_LOAD:
|
||||
case REPLY_PARAMETER_DUMP: {
|
||||
StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
|
||||
objects::IPC_STORE);
|
||||
if (ipcStore != NULL) {
|
||||
ipcStore->deleteData(getStoreId(message));
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
#include "../parameters/ParameterMessage.h"
|
||||
#include "../objectmanager/ObjectManagerIF.h"
|
||||
|
||||
ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
|
||||
return message->getParameter();
|
||||
}
|
||||
|
||||
store_address_t ParameterMessage::getStoreId(const CommandMessage* message) {
|
||||
store_address_t address;
|
||||
address.raw = message->getParameter2();
|
||||
return address;
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterDumpCommand(CommandMessage* message,
|
||||
ParameterId_t id) {
|
||||
message->setCommand(CMD_PARAMETER_DUMP);
|
||||
message->setParameter(id);
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterDumpReply(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID) {
|
||||
message->setCommand(REPLY_PARAMETER_DUMP);
|
||||
message->setParameter(id);
|
||||
message->setParameter2(storageID.raw);
|
||||
}
|
||||
|
||||
void ParameterMessage::setParameterLoadCommand(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID) {
|
||||
message->setCommand(CMD_PARAMETER_LOAD);
|
||||
message->setParameter(id);
|
||||
message->setParameter2(storageID.raw);
|
||||
}
|
||||
|
||||
void ParameterMessage::clear(CommandMessage* message) {
|
||||
switch (message->getCommand()) {
|
||||
case CMD_PARAMETER_LOAD:
|
||||
case REPLY_PARAMETER_DUMP: {
|
||||
StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
|
||||
objects::IPC_STORE);
|
||||
if (ipcStore != NULL) {
|
||||
ipcStore->deleteData(getStoreId(message));
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,29 +1,29 @@
|
||||
#ifndef PARAMETERMESSAGE_H_
|
||||
#define PARAMETERMESSAGE_H_
|
||||
|
||||
#include "../ipc/CommandMessage.h"
|
||||
#include "../parameters/HasParametersIF.h"
|
||||
#include "../storagemanager/StorageManagerIF.h"
|
||||
|
||||
class ParameterMessage {
|
||||
private:
|
||||
ParameterMessage();
|
||||
public:
|
||||
static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
|
||||
static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
|
||||
static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
|
||||
static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
|
||||
|
||||
static ParameterId_t getParameterId(const CommandMessage* message);
|
||||
static store_address_t getStoreId(const CommandMessage* message);
|
||||
static void setParameterDumpCommand(CommandMessage* message,
|
||||
ParameterId_t id);
|
||||
static void setParameterDumpReply(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID);
|
||||
static void setParameterLoadCommand(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID);
|
||||
static void clear(CommandMessage* message);
|
||||
|
||||
};
|
||||
|
||||
#endif /* PARAMETERMESSAGE_H_ */
|
||||
#ifndef PARAMETERMESSAGE_H_
|
||||
#define PARAMETERMESSAGE_H_
|
||||
|
||||
#include "../ipc/CommandMessage.h"
|
||||
#include "../parameters/HasParametersIF.h"
|
||||
#include "../storagemanager/StorageManagerIF.h"
|
||||
|
||||
class ParameterMessage {
|
||||
private:
|
||||
ParameterMessage();
|
||||
public:
|
||||
static const uint8_t MESSAGE_ID = messagetypes::PARAMETER;
|
||||
static const Command_t CMD_PARAMETER_LOAD = MAKE_COMMAND_ID( 0x01 );
|
||||
static const Command_t CMD_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x02 );
|
||||
static const Command_t REPLY_PARAMETER_DUMP = MAKE_COMMAND_ID( 0x03 );
|
||||
|
||||
static ParameterId_t getParameterId(const CommandMessage* message);
|
||||
static store_address_t getStoreId(const CommandMessage* message);
|
||||
static void setParameterDumpCommand(CommandMessage* message,
|
||||
ParameterId_t id);
|
||||
static void setParameterDumpReply(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID);
|
||||
static void setParameterLoadCommand(CommandMessage* message,
|
||||
ParameterId_t id, store_address_t storageID);
|
||||
static void clear(CommandMessage* message);
|
||||
|
||||
};
|
||||
|
||||
#endif /* PARAMETERMESSAGE_H_ */
|
||||
|
||||
@ -1,280 +1,280 @@
|
||||
#include "../parameters/ParameterWrapper.h"
|
||||
|
||||
ParameterWrapper::ParameterWrapper() :
|
||||
pointsToStream(false), type(Type::UNKNOWN_TYPE) {
|
||||
}
|
||||
|
||||
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
void *data) :
|
||||
pointsToStream(false), type(type), rows(rows), columns(columns),
|
||||
data(data), readonlyData(data) {
|
||||
}
|
||||
|
||||
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
const void *data) :
|
||||
pointsToStream(false), type(type), rows(rows), columns(columns),
|
||||
data(nullptr), readonlyData(data) {
|
||||
}
|
||||
|
||||
ParameterWrapper::~ParameterWrapper() {
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
|
||||
size_t maxSize, Endianness streamEndianness) const {
|
||||
ReturnValue_t result;
|
||||
|
||||
result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
//serialize uses readonlyData, as it is always valid
|
||||
if (readonlyData == NULL) {
|
||||
return NOT_SET;
|
||||
}
|
||||
switch (type) {
|
||||
case Type::UINT8_T:
|
||||
result = serializeData<uint8_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT8_T:
|
||||
result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
case Type::UINT16_T:
|
||||
result = serializeData<uint16_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT16_T:
|
||||
result = serializeData<int16_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::UINT32_T:
|
||||
result = serializeData<uint32_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT32_T:
|
||||
result = serializeData<int32_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::FLOAT:
|
||||
result = serializeData<float>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
case Type::DOUBLE:
|
||||
result = serializeData<double>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
default:
|
||||
result = UNKNOW_DATATYPE;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t ParameterWrapper::getSerializedSize() const {
|
||||
uint32_t serializedSize = 0;
|
||||
serializedSize += type.getSerializedSize();
|
||||
serializedSize += sizeof(rows);
|
||||
serializedSize += sizeof(columns);
|
||||
serializedSize += rows * columns * type.getSize();
|
||||
|
||||
return serializedSize;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
|
||||
size_t maxSize, Endianness streamEndianness) const {
|
||||
const T *element = (const T*) readonlyData;
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
uint16_t dataSize = columns * rows;
|
||||
while (dataSize != 0) {
|
||||
result = SerializeAdapter::serialize(element, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
element++;
|
||||
dataSize--;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
|
||||
uint8_t startingColumn, const void *from, uint8_t fromRows,
|
||||
uint8_t fromColumns) {
|
||||
|
||||
//treat from as a continuous Stream as we copy all of it
|
||||
const uint8_t *fromAsStream = (const uint8_t*) from;
|
||||
size_t streamSize = fromRows * fromColumns * sizeof(T);
|
||||
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
|
||||
for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
|
||||
|
||||
//get the start element of this row in data
|
||||
T *dataWithDataType = ((T*) data)
|
||||
+ (((startingRow + fromRow) * columns) + startingColumn);
|
||||
|
||||
for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
|
||||
result = SerializeAdapter::deSerialize(
|
||||
dataWithDataType + fromColumn, &fromAsStream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
|
||||
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
|
||||
size_t *size, Endianness streamEndianness) {
|
||||
return deSerialize(buffer, size, streamEndianness, 0);
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
|
||||
size_t *size, Endianness streamEndianness,
|
||||
uint16_t startWritingAtIndex) {
|
||||
ParameterWrapper streamDescription;
|
||||
|
||||
ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return copyFrom(&streamDescription, startWritingAtIndex);
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
|
||||
const uint8_t **remainingStream, size_t *remainingSize) {
|
||||
ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
|
||||
&streamSize, SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t dataSize = type.getSize() * rows * columns;
|
||||
|
||||
if (streamSize < dataSize) {
|
||||
return SerializeIF::STREAM_TOO_SHORT;
|
||||
}
|
||||
|
||||
data = nullptr;
|
||||
readonlyData = stream;
|
||||
pointsToStream = true;
|
||||
|
||||
stream += dataSize;
|
||||
if (remainingStream != nullptr) {
|
||||
*remainingStream = stream;
|
||||
}
|
||||
streamSize -= dataSize;
|
||||
if (remainingSize != nullptr) {
|
||||
*remainingSize = streamSize;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
|
||||
uint16_t startWritingAtIndex) {
|
||||
if (data == NULL) {
|
||||
return READONLY;
|
||||
}
|
||||
|
||||
if (from->readonlyData == NULL) {
|
||||
return SOURCE_NOT_SET;
|
||||
}
|
||||
|
||||
if (type != from->type) {
|
||||
return DATATYPE_MISSMATCH;
|
||||
}
|
||||
|
||||
//check if from fits into this
|
||||
uint8_t startingRow = startWritingAtIndex / columns;
|
||||
uint8_t startingColumn = startWritingAtIndex % columns;
|
||||
|
||||
if ((from->rows > (rows - startingRow))
|
||||
|| (from->columns > (columns - startingColumn))) {
|
||||
return TOO_BIG;
|
||||
}
|
||||
|
||||
uint8_t typeSize = type.getSize();
|
||||
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
//copy data
|
||||
if (from->pointsToStream) {
|
||||
switch (type) {
|
||||
case Type::UINT8_T:
|
||||
result = deSerializeData<uint8_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT8_T:
|
||||
result = deSerializeData<int8_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::UINT16_T:
|
||||
result = deSerializeData<uint16_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT16_T:
|
||||
result = deSerializeData<int16_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::UINT32_T:
|
||||
result = deSerializeData<uint32_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT32_T:
|
||||
result = deSerializeData<int32_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::FLOAT:
|
||||
result = deSerializeData<float>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::DOUBLE:
|
||||
result = deSerializeData<double>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
default:
|
||||
result = UNKNOW_DATATYPE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
//need a type to do arithmetic
|
||||
uint8_t* typedData = static_cast<uint8_t*>(data);
|
||||
for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
|
||||
uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
|
||||
std::memcpy(typedData + offset, from->readonlyData,
|
||||
typeSize * from->columns);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
#include "../parameters/ParameterWrapper.h"
|
||||
|
||||
ParameterWrapper::ParameterWrapper() :
|
||||
pointsToStream(false), type(Type::UNKNOWN_TYPE) {
|
||||
}
|
||||
|
||||
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
void *data) :
|
||||
pointsToStream(false), type(type), rows(rows), columns(columns),
|
||||
data(data), readonlyData(data) {
|
||||
}
|
||||
|
||||
ParameterWrapper::ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
const void *data) :
|
||||
pointsToStream(false), type(type), rows(rows), columns(columns),
|
||||
data(nullptr), readonlyData(data) {
|
||||
}
|
||||
|
||||
ParameterWrapper::~ParameterWrapper() {
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::serialize(uint8_t **buffer, size_t *size,
|
||||
size_t maxSize, Endianness streamEndianness) const {
|
||||
ReturnValue_t result;
|
||||
|
||||
result = SerializeAdapter::serialize(&type, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = SerializeAdapter::serialize(&columns, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::serialize(&rows, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
//serialize uses readonlyData, as it is always valid
|
||||
if (readonlyData == NULL) {
|
||||
return NOT_SET;
|
||||
}
|
||||
switch (type) {
|
||||
case Type::UINT8_T:
|
||||
result = serializeData<uint8_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT8_T:
|
||||
result = serializeData<int8_t>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
case Type::UINT16_T:
|
||||
result = serializeData<uint16_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT16_T:
|
||||
result = serializeData<int16_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::UINT32_T:
|
||||
result = serializeData<uint32_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::INT32_T:
|
||||
result = serializeData<int32_t>(buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
break;
|
||||
case Type::FLOAT:
|
||||
result = serializeData<float>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
case Type::DOUBLE:
|
||||
result = serializeData<double>(buffer, size, maxSize, streamEndianness);
|
||||
break;
|
||||
default:
|
||||
result = UNKNOW_DATATYPE;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t ParameterWrapper::getSerializedSize() const {
|
||||
uint32_t serializedSize = 0;
|
||||
serializedSize += type.getSerializedSize();
|
||||
serializedSize += sizeof(rows);
|
||||
serializedSize += sizeof(columns);
|
||||
serializedSize += rows * columns * type.getSize();
|
||||
|
||||
return serializedSize;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t ParameterWrapper::serializeData(uint8_t **buffer, size_t *size,
|
||||
size_t maxSize, Endianness streamEndianness) const {
|
||||
const T *element = (const T*) readonlyData;
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
uint16_t dataSize = columns * rows;
|
||||
while (dataSize != 0) {
|
||||
result = SerializeAdapter::serialize(element, buffer, size, maxSize,
|
||||
streamEndianness);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
element++;
|
||||
dataSize--;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t ParameterWrapper::deSerializeData(uint8_t startingRow,
|
||||
uint8_t startingColumn, const void *from, uint8_t fromRows,
|
||||
uint8_t fromColumns) {
|
||||
|
||||
//treat from as a continuous Stream as we copy all of it
|
||||
const uint8_t *fromAsStream = (const uint8_t*) from;
|
||||
size_t streamSize = fromRows * fromColumns * sizeof(T);
|
||||
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
|
||||
for (uint8_t fromRow = 0; fromRow < fromRows; fromRow++) {
|
||||
|
||||
//get the start element of this row in data
|
||||
T *dataWithDataType = ((T*) data)
|
||||
+ (((startingRow + fromRow) * columns) + startingColumn);
|
||||
|
||||
for (uint8_t fromColumn = 0; fromColumn < fromColumns; fromColumn++) {
|
||||
result = SerializeAdapter::deSerialize(
|
||||
dataWithDataType + fromColumn, &fromAsStream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
|
||||
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
|
||||
size_t *size, Endianness streamEndianness) {
|
||||
return deSerialize(buffer, size, streamEndianness, 0);
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::deSerialize(const uint8_t **buffer,
|
||||
size_t *size, Endianness streamEndianness,
|
||||
uint16_t startWritingAtIndex) {
|
||||
ParameterWrapper streamDescription;
|
||||
|
||||
ReturnValue_t result = streamDescription.set(*buffer, *size, buffer, size);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return copyFrom(&streamDescription, startWritingAtIndex);
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::set(const uint8_t *stream, size_t streamSize,
|
||||
const uint8_t **remainingStream, size_t *remainingSize) {
|
||||
ReturnValue_t result = SerializeAdapter::deSerialize(&type, &stream,
|
||||
&streamSize, SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = SerializeAdapter::deSerialize(&columns, &stream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = SerializeAdapter::deSerialize(&rows, &stream, &streamSize,
|
||||
SerializeIF::Endianness::BIG);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t dataSize = type.getSize() * rows * columns;
|
||||
|
||||
if (streamSize < dataSize) {
|
||||
return SerializeIF::STREAM_TOO_SHORT;
|
||||
}
|
||||
|
||||
data = nullptr;
|
||||
readonlyData = stream;
|
||||
pointsToStream = true;
|
||||
|
||||
stream += dataSize;
|
||||
if (remainingStream != nullptr) {
|
||||
*remainingStream = stream;
|
||||
}
|
||||
streamSize -= dataSize;
|
||||
if (remainingSize != nullptr) {
|
||||
*remainingSize = streamSize;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
|
||||
uint16_t startWritingAtIndex) {
|
||||
if (data == NULL) {
|
||||
return READONLY;
|
||||
}
|
||||
|
||||
if (from->readonlyData == NULL) {
|
||||
return SOURCE_NOT_SET;
|
||||
}
|
||||
|
||||
if (type != from->type) {
|
||||
return DATATYPE_MISSMATCH;
|
||||
}
|
||||
|
||||
//check if from fits into this
|
||||
uint8_t startingRow = startWritingAtIndex / columns;
|
||||
uint8_t startingColumn = startWritingAtIndex % columns;
|
||||
|
||||
if ((from->rows > (rows - startingRow))
|
||||
|| (from->columns > (columns - startingColumn))) {
|
||||
return TOO_BIG;
|
||||
}
|
||||
|
||||
uint8_t typeSize = type.getSize();
|
||||
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
//copy data
|
||||
if (from->pointsToStream) {
|
||||
switch (type) {
|
||||
case Type::UINT8_T:
|
||||
result = deSerializeData<uint8_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT8_T:
|
||||
result = deSerializeData<int8_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::UINT16_T:
|
||||
result = deSerializeData<uint16_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT16_T:
|
||||
result = deSerializeData<int16_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::UINT32_T:
|
||||
result = deSerializeData<uint32_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::INT32_T:
|
||||
result = deSerializeData<int32_t>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::FLOAT:
|
||||
result = deSerializeData<float>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
case Type::DOUBLE:
|
||||
result = deSerializeData<double>(startingRow, startingColumn,
|
||||
from->readonlyData, from->rows, from->columns);
|
||||
break;
|
||||
default:
|
||||
result = UNKNOW_DATATYPE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
//need a type to do arithmetic
|
||||
uint8_t* typedData = static_cast<uint8_t*>(data);
|
||||
for (uint8_t fromRow = 0; fromRow < from->rows; fromRow++) {
|
||||
uint8_t offset = (((startingRow + fromRow) * columns) + startingColumn) * typeSize;
|
||||
std::memcpy(typedData + offset, from->readonlyData,
|
||||
typeSize * from->columns);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -1,162 +1,162 @@
|
||||
#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
|
||||
#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
|
||||
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include "../serialize/SerializeAdapter.h"
|
||||
#include "../serialize/SerializeIF.h"
|
||||
#include <stddef.h>
|
||||
#include "../globalfunctions/Type.h"
|
||||
|
||||
/**
|
||||
* @brief
|
||||
* @details
|
||||
*/
|
||||
class ParameterWrapper: public SerializeIF {
|
||||
friend class DataPoolParameterWrapper;
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
|
||||
static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
|
||||
static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
|
||||
static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
|
||||
static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
|
||||
static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
|
||||
static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
|
||||
static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
|
||||
|
||||
ParameterWrapper();
|
||||
ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
|
||||
ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
const void *data);
|
||||
virtual ~ParameterWrapper();
|
||||
|
||||
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
size_t maxSize, Endianness streamEndianness) const override;
|
||||
|
||||
virtual size_t getSerializedSize() const override;
|
||||
|
||||
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
Endianness streamEndianness) override;
|
||||
|
||||
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
|
||||
|
||||
/**
|
||||
* Get a specific parameter value by supplying the row and the column.
|
||||
* @tparam T Type of target data
|
||||
* @param value [out] Pointer to storage location
|
||||
* @param row
|
||||
* @param column
|
||||
* @return
|
||||
* -@c RETURN_OK if element was retrieved successfully
|
||||
* -@c NOT_SET data has not been set yet
|
||||
* -@c DATATYPE_MISSMATCH Invalid supplied type
|
||||
* -@c OUT_OF_BOUNDS Invalid row and/or column.
|
||||
*/
|
||||
template<typename T>
|
||||
ReturnValue_t getElement(T *value, uint8_t row = 0,
|
||||
uint8_t column = 0) const;
|
||||
|
||||
template<typename T>
|
||||
void set(T *data, uint8_t rows, uint8_t columns) {
|
||||
this->data = data;
|
||||
this->readonlyData = data;
|
||||
this->type = PodTypeConversion<T>::type;
|
||||
this->rows = rows;
|
||||
this->columns = columns;
|
||||
this->pointsToStream = false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
|
||||
this->data = NULL;
|
||||
this->readonlyData = readonlyData;
|
||||
this->type = PodTypeConversion<T>::type;
|
||||
this->rows = rows;
|
||||
this->columns = columns;
|
||||
this->pointsToStream = false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(T& member) {
|
||||
this->set(&member, 1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(const T& readonlyMember) {
|
||||
this->set(&readonlyMember, 1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setVector(T& member) {
|
||||
this->set(member, sizeof(member)/sizeof(member[0]), 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setVector(const T& member) {
|
||||
this->set(member, 1, sizeof(member)/sizeof(member[0]));
|
||||
}
|
||||
template<typename T>
|
||||
void setMatrix(T& member) {
|
||||
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setMatrix(const T& member) {
|
||||
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
|
||||
}
|
||||
|
||||
ReturnValue_t set(const uint8_t *stream, size_t streamSize,
|
||||
const uint8_t **remainingStream = nullptr,
|
||||
size_t *remainingSize = nullptr);
|
||||
|
||||
ReturnValue_t copyFrom(const ParameterWrapper *from,
|
||||
uint16_t startWritingAtIndex);
|
||||
|
||||
private:
|
||||
bool pointsToStream = false;
|
||||
|
||||
Type type;
|
||||
uint8_t rows = 0;
|
||||
uint8_t columns = 0;
|
||||
void *data = nullptr;
|
||||
const void *readonlyData = nullptr;
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
|
||||
size_t maxSize, Endianness streamEndianness) const;
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
|
||||
const void *from, uint8_t fromRows, uint8_t fromColumns);
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
|
||||
uint8_t column) const {
|
||||
if (readonlyData == nullptr){
|
||||
return NOT_SET;
|
||||
}
|
||||
|
||||
if (PodTypeConversion<T>::type != type) {
|
||||
return DATATYPE_MISSMATCH;
|
||||
}
|
||||
|
||||
if ((row >= rows) or (column >= columns)) {
|
||||
return OUT_OF_BOUNDS;
|
||||
}
|
||||
|
||||
if (pointsToStream) {
|
||||
const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
|
||||
streamWithType += (row * columns + column) * type.getSize();
|
||||
int32_t size = type.getSize();
|
||||
return SerializeAdapter::deSerialize(value, &streamWithType,
|
||||
&size, true);
|
||||
}
|
||||
else {
|
||||
const T *dataWithType = static_cast<const T*>(readonlyData);
|
||||
*value = dataWithType[row * columns + column];
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PARAMETERWRAPPER_H_ */
|
||||
#ifndef FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
|
||||
#define FRAMEWORK_PARAMETERS_PARAMETERWRAPPER_H_
|
||||
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include "../serialize/SerializeAdapter.h"
|
||||
#include "../serialize/SerializeIF.h"
|
||||
#include <stddef.h>
|
||||
#include "../globalfunctions/Type.h"
|
||||
|
||||
/**
|
||||
* @brief
|
||||
* @details
|
||||
*/
|
||||
class ParameterWrapper: public SerializeIF {
|
||||
friend class DataPoolParameterWrapper;
|
||||
public:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::PARAMETER_WRAPPER;
|
||||
static const ReturnValue_t UNKNOW_DATATYPE = MAKE_RETURN_CODE(0x01);
|
||||
static const ReturnValue_t DATATYPE_MISSMATCH = MAKE_RETURN_CODE(0x02);
|
||||
static const ReturnValue_t READONLY = MAKE_RETURN_CODE(0x03);
|
||||
static const ReturnValue_t TOO_BIG = MAKE_RETURN_CODE(0x04);
|
||||
static const ReturnValue_t SOURCE_NOT_SET = MAKE_RETURN_CODE(0x05);
|
||||
static const ReturnValue_t OUT_OF_BOUNDS = MAKE_RETURN_CODE(0x06);
|
||||
static const ReturnValue_t NOT_SET = MAKE_RETURN_CODE(0x07);
|
||||
|
||||
ParameterWrapper();
|
||||
ParameterWrapper(Type type, uint8_t rows, uint8_t columns, void *data);
|
||||
ParameterWrapper(Type type, uint8_t rows, uint8_t columns,
|
||||
const void *data);
|
||||
virtual ~ParameterWrapper();
|
||||
|
||||
virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
|
||||
size_t maxSize, Endianness streamEndianness) const override;
|
||||
|
||||
virtual size_t getSerializedSize() const override;
|
||||
|
||||
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
Endianness streamEndianness) override;
|
||||
|
||||
virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
|
||||
Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
|
||||
|
||||
/**
|
||||
* Get a specific parameter value by supplying the row and the column.
|
||||
* @tparam T Type of target data
|
||||
* @param value [out] Pointer to storage location
|
||||
* @param row
|
||||
* @param column
|
||||
* @return
|
||||
* -@c RETURN_OK if element was retrieved successfully
|
||||
* -@c NOT_SET data has not been set yet
|
||||
* -@c DATATYPE_MISSMATCH Invalid supplied type
|
||||
* -@c OUT_OF_BOUNDS Invalid row and/or column.
|
||||
*/
|
||||
template<typename T>
|
||||
ReturnValue_t getElement(T *value, uint8_t row = 0,
|
||||
uint8_t column = 0) const;
|
||||
|
||||
template<typename T>
|
||||
void set(T *data, uint8_t rows, uint8_t columns) {
|
||||
this->data = data;
|
||||
this->readonlyData = data;
|
||||
this->type = PodTypeConversion<T>::type;
|
||||
this->rows = rows;
|
||||
this->columns = columns;
|
||||
this->pointsToStream = false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(const T *readonlyData, uint8_t rows, uint8_t columns) {
|
||||
this->data = NULL;
|
||||
this->readonlyData = readonlyData;
|
||||
this->type = PodTypeConversion<T>::type;
|
||||
this->rows = rows;
|
||||
this->columns = columns;
|
||||
this->pointsToStream = false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(T& member) {
|
||||
this->set(&member, 1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void set(const T& readonlyMember) {
|
||||
this->set(&readonlyMember, 1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setVector(T& member) {
|
||||
this->set(member, sizeof(member)/sizeof(member[0]), 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setVector(const T& member) {
|
||||
this->set(member, 1, sizeof(member)/sizeof(member[0]));
|
||||
}
|
||||
template<typename T>
|
||||
void setMatrix(T& member) {
|
||||
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void setMatrix(const T& member) {
|
||||
this->set(member[0], sizeof(member)/sizeof(member[0]), sizeof(member[0])/sizeof(member[0][0]));
|
||||
}
|
||||
|
||||
ReturnValue_t set(const uint8_t *stream, size_t streamSize,
|
||||
const uint8_t **remainingStream = nullptr,
|
||||
size_t *remainingSize = nullptr);
|
||||
|
||||
ReturnValue_t copyFrom(const ParameterWrapper *from,
|
||||
uint16_t startWritingAtIndex);
|
||||
|
||||
private:
|
||||
bool pointsToStream = false;
|
||||
|
||||
Type type;
|
||||
uint8_t rows = 0;
|
||||
uint8_t columns = 0;
|
||||
void *data = nullptr;
|
||||
const void *readonlyData = nullptr;
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t serializeData(uint8_t** buffer, size_t* size,
|
||||
size_t maxSize, Endianness streamEndianness) const;
|
||||
|
||||
template<typename T>
|
||||
ReturnValue_t deSerializeData(uint8_t startingRow, uint8_t startingColumn,
|
||||
const void *from, uint8_t fromRows, uint8_t fromColumns);
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
inline ReturnValue_t ParameterWrapper::getElement(T *value, uint8_t row,
|
||||
uint8_t column) const {
|
||||
if (readonlyData == nullptr){
|
||||
return NOT_SET;
|
||||
}
|
||||
|
||||
if (PodTypeConversion<T>::type != type) {
|
||||
return DATATYPE_MISSMATCH;
|
||||
}
|
||||
|
||||
if ((row >= rows) or (column >= columns)) {
|
||||
return OUT_OF_BOUNDS;
|
||||
}
|
||||
|
||||
if (pointsToStream) {
|
||||
const uint8_t *streamWithType = static_cast<const uint8_t*>(readonlyData);
|
||||
streamWithType += (row * columns + column) * type.getSize();
|
||||
int32_t size = type.getSize();
|
||||
return SerializeAdapter::deSerialize(value, &streamWithType,
|
||||
&size, true);
|
||||
}
|
||||
else {
|
||||
const T *dataWithType = static_cast<const T*>(readonlyData);
|
||||
*value = dataWithType[row * columns + column];
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PARAMETERWRAPPER_H_ */
|
||||
|
||||
@ -1,19 +1,19 @@
|
||||
#ifndef RECEIVESPARAMETERMESSAGESIF_H_
|
||||
#define RECEIVESPARAMETERMESSAGESIF_H_
|
||||
|
||||
|
||||
#include "../parameters/HasParametersIF.h"
|
||||
#include "../ipc/MessageQueueSenderIF.h"
|
||||
|
||||
class ReceivesParameterMessagesIF : public HasParametersIF {
|
||||
public:
|
||||
|
||||
static const uint8_t DOMAIN_ID_BASE = 0;
|
||||
virtual ~ReceivesParameterMessagesIF() {
|
||||
}
|
||||
|
||||
virtual MessageQueueId_t getCommandQueue() const = 0;
|
||||
};
|
||||
|
||||
|
||||
#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
|
||||
#ifndef RECEIVESPARAMETERMESSAGESIF_H_
|
||||
#define RECEIVESPARAMETERMESSAGESIF_H_
|
||||
|
||||
|
||||
#include "../parameters/HasParametersIF.h"
|
||||
#include "../ipc/MessageQueueSenderIF.h"
|
||||
|
||||
class ReceivesParameterMessagesIF : public HasParametersIF {
|
||||
public:
|
||||
|
||||
static const uint8_t DOMAIN_ID_BASE = 0;
|
||||
virtual ~ReceivesParameterMessagesIF() {
|
||||
}
|
||||
|
||||
virtual MessageQueueId_t getCommandQueue() const = 0;
|
||||
};
|
||||
|
||||
|
||||
#endif /* RECEIVESPARAMETERMESSAGESIF_H_ */
|
||||
|
||||
Reference in New Issue
Block a user