diff --git a/devicehandlers/CommunicationMessage.cpp b/devicehandlers/CommunicationMessage.cpp index 5c042487..028e8a2e 100644 --- a/devicehandlers/CommunicationMessage.cpp +++ b/devicehandlers/CommunicationMessage.cpp @@ -5,6 +5,7 @@ */ #include +#include #include CommunicationMessage::CommunicationMessage(): uninitialized(true) { @@ -23,19 +24,23 @@ void CommunicationMessage::setSendRequestFromPointer(uint32_t address, void CommunicationMessage::setSendRequestFromIpcStore(uint32_t address, store_address_t storeId) { setMessageType(SEND_DATA_FROM_IPC_STORE); setAddress(address); - setStoreId(storeId); + setStoreId(storeId.raw); } -void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length) { +void CommunicationMessage::setSendRequestRaw(uint32_t address, uint32_t length, + uint16_t sendBufferPosition) { setMessageType(SEND_DATA_RAW); setAddress(address); setDataLen(length); + if(sendBufferPosition != 0) { + setBufferPosition(sendBufferPosition); + } } void CommunicationMessage::setDataReplyFromIpcStore(uint32_t address, store_address_t storeId) { setMessageType(REPLY_DATA_IPC_STORE); setAddress(address); - setStoreId(storeId); + setStoreId(storeId.raw); } void CommunicationMessage::setDataReplyFromPointer(uint32_t address, uint32_t dataLen, uint8_t *data) { @@ -51,7 +56,7 @@ void CommunicationMessage::setDataReplyRaw(uint32_t address, setAddress(address); setDataLen(length); if(receiveBufferPosition != 0) { - setReceiveBufferPosition(receiveBufferPosition); + setBufferPosition(receiveBufferPosition); } } @@ -60,61 +65,137 @@ void CommunicationMessage::setMessageType(messageType status) { memcpy(getData() + sizeof(uint32_t), &status_uint8, sizeof(status_uint8)); } -void CommunicationMessage::setAddress(uint32_t address) { +void CommunicationMessage::setAddress(address_t address) { memcpy(getData(),&address,sizeof(address)); } -void CommunicationMessage::setReceiveBufferPosition(uint16_t bufferPosition) { - memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), +address_t CommunicationMessage::getAddress() const { + address_t address; + memcpy(&address,getData(),sizeof(address)); + return address; +} + +void CommunicationMessage::setBufferPosition(uint16_t bufferPosition) { + memcpy(getData() + sizeof(uint32_t) + sizeof(uint16_t), &bufferPosition, sizeof(bufferPosition)); } +uint16_t CommunicationMessage::getBufferPosition() const { + uint16_t bufferPosition; + memcpy(&bufferPosition, + getData() + sizeof(uint32_t) + sizeof(uint16_t), sizeof(bufferPosition)); + return bufferPosition; +} + void CommunicationMessage::setDataPointer(const void * data) { memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(uint32_t)); } void CommunicationMessage::setStoreId(store_address_t storeId) { - memcpy(getData() + 2 * sizeof(uint32_t), &storeId, sizeof(store_address_t)); + memcpy(getData() + 2 * sizeof(uint32_t), &storeId.raw, sizeof(uint32_t)); +} + +store_address_t CommunicationMessage::getStoreId() const{ + store_address_t temp; + memcpy(&temp.raw,getData() + 2 * sizeof(uint32_t), sizeof(uint32_t)); + return temp; } void CommunicationMessage::setDataLen(uint32_t length) { memcpy(getData() + 2 * sizeof(uint32_t), &length, sizeof(length)); } -void CommunicationMessage::setData(uint32_t data) { +uint32_t CommunicationMessage::getDataLen() const { + uint32_t len; + memcpy(&len, getData() + 2 * sizeof(uint32_t), sizeof(len)); + return len; +} + +void CommunicationMessage::setUint32Data(uint32_t data) { memcpy(getData() + 3 * sizeof(uint32_t), &data, sizeof(data)); } -void CommunicationMessage::setDataByte1(uint8_t byte1) { - memcpy(getData() + 3 * sizeof(uint32_t), &byte1, sizeof(byte1)); +uint32_t CommunicationMessage::getUint32Data() const{ + uint32_t data; + memcpy(&data,getData() + 3 * sizeof(uint32_t), sizeof(data)); + return data; } -void CommunicationMessage::setDataByte2(uint8_t byte2) { - memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint8_t), &byte2, sizeof(byte2)); +void CommunicationMessage::setDataByte(uint8_t byte, uint8_t position) { + if(0 <= position && position <= 3) { + memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), &byte, sizeof(byte)); + } + else { + error << "Comm Message: Invalid byte position" << std::endl; + } } -void CommunicationMessage::setDataByte3(uint8_t byte3) { - memcpy(getData() + 3 * sizeof(uint32_t) + 2* sizeof(uint8_t), &byte3, sizeof(byte3)); +uint8_t CommunicationMessage::getDataByte(uint8_t position) const { + if(0 <= position && position <= 3) { + uint8_t byte; + memcpy(&byte, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint8_t), sizeof(byte)); + return byte; + } + else { + return 0; + error << "Comm Message: Invalid byte position" << std::endl; + } } -void CommunicationMessage::setDataByte4(uint8_t byte4) { - memcpy(getData() + 3 * sizeof(uint32_t) + 3* sizeof(uint8_t), &byte4, sizeof(byte4)); +void CommunicationMessage::setDataUint16(uint16_t data, uint8_t position) { + if(position == 0 || position == 1) { + memcpy(getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), &data, sizeof(data)); + } + else { + error << "Comm Message: Invalid byte position" << std::endl; + } + } -void CommunicationMessage::setDataUINT16_1(uint16_t data1) { - memcpy(getData() + 3 * sizeof(uint32_t), &data1, sizeof(data1)); +uint16_t CommunicationMessage::getDataUint16(uint8_t position) const{ + if(position == 0 || position == 1) { + uint16_t data; + memcpy(&data, getData() + 3 * sizeof(uint32_t) + position * sizeof(uint16_t), sizeof(data)); + return data; + } + else { + return 0; + error << "Comm Message: Invalid byte position" << std::endl; + } } -void CommunicationMessage::setDataUINT16_2(uint16_t data2) { - memcpy(getData() + 3 * sizeof(uint32_t) + sizeof(uint16_t), &data2, sizeof(data2)); -} - -CommunicationMessage::messageType CommunicationMessage::getMessageType() { +CommunicationMessage::messageType CommunicationMessage::getMessageType() const{ messageType messageType; memcpy(&messageType, getData() + sizeof(uint32_t),sizeof(uint8_t)); return messageType; } +void CommunicationMessage::setMessageId(uint8_t messageId) { + memcpy(getData() + sizeof(uint32_t) + sizeof(uint8_t), &messageId, sizeof(messageId)); +} + +uint8_t CommunicationMessage::getMessageId() const { + uint8_t messageId; + memcpy(&messageId, getData() + sizeof(uint32_t) + sizeof(uint8_t), sizeof(messageId)); + return messageId; +} + void CommunicationMessage::clearCommunicationMessage() { messageType messageType = getMessageType(); + switch(messageType) { + case(messageType::REPLY_DATA_IPC_STORE): + case(messageType::SEND_DATA_FROM_IPC_STORE): { + store_address_t storeId = getStoreId(); + StorageManagerIF *ipcStore = objectManager-> + get(objects::IPC_STORE); + if (ipcStore != NULL) { + ipcStore->deleteData(storeId); + } + } + /* NO BREAK falls through*/ + default: + memset(getData(),0,4*sizeof(uint32_t)); + break; + } } + diff --git a/devicehandlers/CommunicationMessage.h b/devicehandlers/CommunicationMessage.h index 805dd9a8..a92c4b5c 100644 --- a/devicehandlers/CommunicationMessage.h +++ b/devicehandlers/CommunicationMessage.h @@ -10,6 +10,7 @@ #include #include +#include /** * @brief Used to pass communication information between tasks @@ -26,6 +27,7 @@ class CommunicationMessage: public MessageQueueMessage { public: enum messageType { + NONE, SEND_DATA_FROM_POINTER, SEND_DATA_FROM_IPC_STORE, SEND_DATA_RAW, @@ -41,6 +43,24 @@ public: CommunicationMessage(); virtual ~CommunicationMessage(); + /** + * Message Type is stored as the fifth byte of the message data + * @param status + */ + void setMessageType(messageType status); + messageType getMessageType() const; + + /** + * This is a unique ID which can be used to handle different kinds of messages. + * For example, the same interface (e.g. SPI) could be used to exchange raw data + * (e.g. sensor values) and data stored in the IPC store. + * The ID can be used to distinguish the messages in child implementations. + * The message ID is stored as the sixth byte of the message data. + * @param messageId + */ + void setMessageId(uint8_t messageId); + uint8_t getMessageId() const; + /** * Send requests with pointer to the data to be sent and send data length * @param address Target Address, first four bytes @@ -65,7 +85,8 @@ public: * @param data Pointer to data to send * */ - void setSendRequestRaw(uint32_t address, uint32_t length); + void setSendRequestRaw(uint32_t address, uint32_t length, + uint16_t sendBufferPosition = 0); /** * Data message with data stored in IPC store @@ -97,31 +118,27 @@ public: * First four bytes of message data * @param address */ - void setAddress(uint32_t address); + void setAddress(address_t address); + + address_t getAddress() const; + /** + * Set byte as position of 4 byte data field + * @param byte + * @param position Position, 0 to 3 possible + */ + void setDataByte(uint8_t byte, uint8_t position); + uint8_t getDataByte(uint8_t position) const; /** - * Message Type is stored as the fifth byte of the message data - * @param status + * Set 2 byte value at position 1 or 2 of data field + * @param data + * @param position 0 or 1 possible */ - void setMessageType(messageType status); - messageType getMessageType(); + void setDataUint16(uint16_t data, uint8_t position); + uint16_t getDataUint16(uint8_t position) const; - void setMessageId(uint8_t messageId); - messageType getMessageId(); - - /* - * The following functions can be used to - * set the data field (4 bytes possible); - */ - void setDataByte1(uint8_t byte1); - void setDataByte2(uint8_t byte2); - void setDataByte3(uint8_t byte3); - void setDataByte4(uint8_t byte4); - - void setDataUINT16_1(uint16_t data1); - void setDataUINT16_2(uint16_t data2); - - void setData(uint32_t data); + void setUint32Data(uint32_t data); + uint32_t getUint32Data() const; /** * Stored in Bytes 13-16 of message data @@ -129,6 +146,8 @@ public: */ void setDataLen(uint32_t length); + uint32_t getDataLen() const; + /** * Stored in last four bytes (Bytes 17-20) of message data * @param sendData @@ -136,19 +155,22 @@ public: void setDataPointer(const void * data); /** - * Buffer Position is stored as the seventh and eigth byte of + * In case the send request data or reply data is to be stored in a buffer, + * a buffer Position can be stored here as the seventh and eigth byte of * the message, so the receive buffer can't be larger than sizeof(uint16_t) for now. - * @param bufferPosition + * @param bufferPosition In case the data is stored in a buffer, the position can be supplied here */ - void setReceiveBufferPosition(uint16_t bufferPosition); + void setBufferPosition(uint16_t bufferPosition); + uint16_t getBufferPosition() const; void setStoreId(store_address_t storeId); + store_address_t getStoreId() const; /** - * Clear the message + * Clear the message. Deletes IPC Store data + * and sets all data to 0. Also sets message type to NONE */ void clearCommunicationMessage(); private: - bool uninitialized; //!< Could be used to warn if data has not been set. }; diff --git a/devicehandlers/DeviceCommunicationIF.h b/devicehandlers/DeviceCommunicationIF.h index e03db26b..99904510 100644 --- a/devicehandlers/DeviceCommunicationIF.h +++ b/devicehandlers/DeviceCommunicationIF.h @@ -73,10 +73,15 @@ public: virtual ReturnValue_t getSendSuccess(Cookie *cookie) = 0; + /** + * Called by DHB in the SEND_WRITE doSendRead(). + * @param cookie + * @return + */ virtual ReturnValue_t requestReceiveMessage(Cookie *cookie) = 0; /** - * Called by DHB in the GET_WIRTE doGetRead(). + * Called by DHB in the GET_WRITE doGetRead(). * This function is used to receive data from the physical device * by implementing and calling related drivers or wrapper functions. * @param cookie