From 958569be6e695d1be30e52e3c6c7963a6a5448c3 Mon Sep 17 00:00:00 2001 From: Dusan Cervenka Date: Tue, 24 Oct 2023 16:55:45 +0200 Subject: [PATCH] Feature/buffer head (#378) * Framed transport header data stored in MessageBuffer Signed-off-by: Cervenka Dusan * RPMSG compile issues. !!! removed one mbf file and one file renamed. Signed-off-by: Cervenka Dusan * Fixed rpmsg tty Signed-off-by: Cervenka Dusan * swapping rpmsg inheritance Signed-off-by: Cervenka Dusan * Added missing override keyword Signed-off-by: Cervenka Dusan * Use using keyword to fix warnings Signed-off-by: Cervenka Dusan * Fix crcHeader for python Signed-off-by: Cervenka Dusan --------- Signed-off-by: Cervenka Dusan --- .../infra/erpc_arbitrated_client_manager.cpp | 2 +- erpc_c/infra/erpc_basic_codec.cpp | 14 + erpc_c/infra/erpc_basic_codec.hpp | 23 +- erpc_c/infra/erpc_client_manager.cpp | 15 +- erpc_c/infra/erpc_codec.hpp | 29 +- erpc_c/infra/erpc_framed_transport.cpp | 103 ++++-- erpc_c/infra/erpc_framed_transport.hpp | 48 ++- erpc_c/infra/erpc_message_buffer.cpp | 80 +++-- erpc_c/infra/erpc_message_buffer.hpp | 335 ++++++++++-------- erpc_c/infra/erpc_message_loggers.hpp | 2 +- erpc_c/infra/erpc_server.cpp | 2 +- erpc_c/infra/erpc_server.hpp | 2 +- erpc_c/infra/erpc_simple_server.cpp | 84 +++-- erpc_c/infra/erpc_simple_server.hpp | 27 +- erpc_c/infra/erpc_transport.hpp | 9 + erpc_c/infra/erpc_transport_arbitrator.cpp | 63 +++- erpc_c/infra/erpc_transport_arbitrator.hpp | 103 +++--- erpc_c/setup/erpc_mbf_setup.h | 14 - erpc_c/setup/erpc_setup_mbf_rpmsg.cpp | 19 +- erpc_c/setup/erpc_setup_mbf_rpmsg_tty.cpp | 151 -------- .../transports/erpc_dspi_master_transport.hpp | 7 +- .../transports/erpc_dspi_slave_transport.hpp | 7 +- .../transports/erpc_i2c_slave_transport.hpp | 7 +- .../erpc_inter_thread_buffer_transport.hpp | 4 +- .../transports/erpc_lpi2c_slave_transport.hpp | 7 +- .../transports/erpc_lpspi_slave_transport.hpp | 7 +- erpc_c/transports/erpc_mu_transport.cpp | 5 + erpc_c/transports/erpc_mu_transport.hpp | 6 +- .../transports/erpc_rpmsg_linux_transport.hpp | 4 +- ...transport.hpp => erpc_rpmsg_lite_base.hpp} | 16 +- .../erpc_rpmsg_lite_rtos_transport.cpp | 35 +- .../erpc_rpmsg_lite_rtos_transport.hpp | 30 +- .../transports/erpc_rpmsg_lite_transport.cpp | 34 +- .../transports/erpc_rpmsg_lite_transport.hpp | 30 +- .../erpc_rpmsg_tty_rtos_transport.cpp | 136 +++---- .../erpc_rpmsg_tty_rtos_transport.hpp | 68 ++-- erpc_c/transports/erpc_serial_transport.hpp | 19 +- .../transports/erpc_spi_master_transport.hpp | 7 +- .../transports/erpc_spi_slave_transport.hpp | 7 +- .../erpc_spidev_master_transport.hpp | 7 +- erpc_c/transports/erpc_tcp_transport.hpp | 8 +- .../transports/erpc_uart_cmsis_transport.hpp | 7 +- erpc_c/transports/erpc_usb_cdc_transport.hpp | 7 +- erpc_python/erpc/transport.py | 20 +- .../src/templates/cpp_server_header.template | 4 +- .../src/templates/cpp_server_source.template | 16 +- erpcsniffer/src/Sniffer.cpp | 2 +- test/common/gtest/gtest.h | 2 + .../unit_test_tcp_arbitrator_client.cpp | 3 - .../unit_test_tcp_arbitrator_server.cpp | 15 +- 50 files changed, 873 insertions(+), 779 deletions(-) delete mode 100644 erpc_c/setup/erpc_setup_mbf_rpmsg_tty.cpp rename erpc_c/transports/{erpc_rpmsg_lite_base_transport.hpp => erpc_rpmsg_lite_base.hpp} (87%) diff --git a/erpc_c/infra/erpc_arbitrated_client_manager.cpp b/erpc_c/infra/erpc_arbitrated_client_manager.cpp index 7338189f..53d3c4e6 100644 --- a/erpc_c/infra/erpc_arbitrated_client_manager.cpp +++ b/erpc_c/infra/erpc_arbitrated_client_manager.cpp @@ -73,7 +73,7 @@ void ArbitratedClientManager::performClientRequest(RequestContext &request) // Send the request. if (request.getCodec()->isStatusOk() == true) { - err = m_arbitrator->send(request.getCodec()->getBuffer()); + err = m_arbitrator->send(&request.getCodec()->getBufferRef()); request.getCodec()->updateStatus(err); } diff --git a/erpc_c/infra/erpc_basic_codec.cpp b/erpc_c/infra/erpc_basic_codec.cpp index 7fc54407..d59a697f 100644 --- a/erpc_c/infra/erpc_basic_codec.cpp +++ b/erpc_c/infra/erpc_basic_codec.cpp @@ -27,6 +27,13 @@ using namespace erpc; const uint32_t BasicCodec::kBasicCodecVersion = 1UL; +BasicCodec::BasicCodec(void) +: Codec() +{ +} + +BasicCodec::~BasicCodec(void) {} + void BasicCodec::startWriteMessage(message_type_t type, uint32_t service, uint32_t request, uint32_t sequence) { uint32_t header = @@ -367,6 +374,13 @@ void BasicCodec::readNullFlag(bool &isNull) ERPC_MANUALLY_CONSTRUCTED_ARRAY_STATIC(BasicCodec, s_basicCodecManual, ERPC_CODEC_COUNT); +BasicCodecFactory::BasicCodecFactory(void) +: CodecFactory() +{ +} + +BasicCodecFactory::~BasicCodecFactory(void) {} + Codec *BasicCodecFactory::create(void) { ERPC_CREATE_NEW_OBJECT(BasicCodec, s_basicCodecManual, ERPC_CODEC_COUNT) diff --git a/erpc_c/infra/erpc_basic_codec.hpp b/erpc_c/infra/erpc_basic_codec.hpp index c39a0c64..3dc0faa9 100644 --- a/erpc_c/infra/erpc_basic_codec.hpp +++ b/erpc_c/infra/erpc_basic_codec.hpp @@ -43,10 +43,15 @@ class BasicCodec : public Codec public: static const uint32_t kBasicCodecVersion; /*!< Codec version. */ - BasicCodec(void) - : Codec() - { - } + /*! + * @brief Constructor. + */ + BasicCodec(void); + + /*! + * @brief CodecFactory destructor + */ + virtual ~BasicCodec(void); //! @name Encoding //@{ @@ -344,6 +349,16 @@ class BasicCodec : public Codec class BasicCodecFactory : public CodecFactory { public: + /*! + * @brief Constructor. + */ + BasicCodecFactory(void); + + /*! + * @brief CodecFactory destructor + */ + virtual ~BasicCodecFactory(void); + /*! * @brief Return created codec. * diff --git a/erpc_c/infra/erpc_client_manager.cpp b/erpc_c/infra/erpc_client_manager.cpp index 34e62ad9..ef064b3d 100644 --- a/erpc_c/infra/erpc_client_manager.cpp +++ b/erpc_c/infra/erpc_client_manager.cpp @@ -78,7 +78,7 @@ void ClientManager::performClientRequest(RequestContext &request) // Send invocation request to server. if (request.getCodec()->isStatusOk() == true) { - err = m_transport->send(request.getCodec()->getBuffer()); + err = m_transport->send(&request.getCodec()->getBufferRef()); request.getCodec()->updateStatus(err); } @@ -88,7 +88,7 @@ void ClientManager::performClientRequest(RequestContext &request) if (request.getCodec()->isStatusOk() == true) { // Receive reply. - err = m_transport->receive(request.getCodec()->getBuffer()); + err = m_transport->receive(&request.getCodec()->getBufferRef()); request.getCodec()->updateStatus(err); } @@ -126,7 +126,7 @@ void ClientManager::performNestedClientRequest(RequestContext &request) // Send invocation request to server. if (request.getCodec()->isStatusOk() == true) { - err = m_transport->send(request.getCodec()->getBuffer()); + err = m_transport->send(&request.getCodec()->getBufferRef()); request.getCodec()->updateStatus(err); } @@ -167,7 +167,7 @@ void ClientManager::verifyReply(RequestContext &request) // Some transport layers change the request's message buffer pointer (for things like zero // copy support), so inCodec must be reset to work with correct buffer. - request.getCodec()->reset(); + request.getCodec()->reset(m_transport->reserveHeaderSize()); // Extract the reply header. request.getCodec()->startReadMessage(msgType, service, requestNumber, sequence); @@ -186,13 +186,14 @@ Codec *ClientManager::createBufferAndCodec(void) { Codec *codec = m_codecFactory->create(); MessageBuffer message; + uint8_t reservedMessageSpace = m_transport->reserveHeaderSize(); if (codec != NULL) { - message = m_messageFactory->create(); + message = m_messageFactory->create(reservedMessageSpace); if (NULL != message.get()) { - codec->setBuffer(message); + codec->setBuffer(message, reservedMessageSpace); } else { @@ -209,7 +210,7 @@ void ClientManager::releaseRequest(RequestContext &request) { if (request.getCodec() != NULL) { - m_messageFactory->dispose(request.getCodec()->getBuffer()); + m_messageFactory->dispose(&request.getCodec()->getBufferRef()); m_codecFactory->dispose(request.getCodec()); } } diff --git a/erpc_c/infra/erpc_codec.hpp b/erpc_c/infra/erpc_codec.hpp index c436f38b..af075bba 100644 --- a/erpc_c/infra/erpc_codec.hpp +++ b/erpc_c/infra/erpc_codec.hpp @@ -59,8 +59,7 @@ class Codec * This function initializes object attributes. */ Codec(void) - : m_buffer() - , m_cursor() + : m_cursor() , m_status(kErpcStatus_Success) { } @@ -75,24 +74,31 @@ class Codec * * @return Pointer to used message buffer. */ - MessageBuffer *getBuffer(void) { return &m_buffer; } + MessageBuffer getBuffer(void) { return m_cursor.getBuffer(); } + + MessageBuffer &getBufferRef(void) { return m_cursor.getBufferRef(); } /*! * @brief Prototype for set message buffer used for read and write data. * * @param[in] buf Message buffer to set. + * @param[in] skip How many bytes to skip from reading. */ - virtual void setBuffer(MessageBuffer &buf) + virtual void setBuffer(MessageBuffer &buf, uint8_t skip = 0) { - m_buffer = buf; - m_cursor.set(&m_buffer); + m_cursor.setBuffer(buf, skip); m_status = kErpcStatus_Success; } - /*! @brief Reset the codec to initial state. */ - virtual void reset(void) + /*! + * @brief Reset the codec to initial state. + * + * @param[in] skip How many bytes to skip from reading. + */ + virtual void reset(uint8_t skip = 0) { - m_cursor.set(&m_buffer); + MessageBuffer buffer = m_cursor.getBuffer(); + m_cursor.setBuffer(buffer, skip); m_status = kErpcStatus_Success; } @@ -394,9 +400,8 @@ class Codec virtual void readNullFlag(bool &isNull) = 0; protected: - MessageBuffer m_buffer; /*!< Message buffer object */ - MessageBuffer::Cursor m_cursor; /*!< Copy data to message buffers. */ - erpc_status_t m_status; /*!< Status of serialized data. */ + Cursor m_cursor; /*!< Copy data to message buffers. */ + erpc_status_t m_status; /*!< Status of serialized data. */ }; /*! diff --git a/erpc_c/infra/erpc_framed_transport.cpp b/erpc_c/infra/erpc_framed_transport.cpp index a27dfb05..b533241a 100644 --- a/erpc_c/infra/erpc_framed_transport.cpp +++ b/erpc_c/infra/erpc_framed_transport.cpp @@ -34,6 +34,12 @@ FramedTransport::FramedTransport(void) FramedTransport::~FramedTransport(void) {} +uint8_t FramedTransport::reserveHeaderSize(void) +{ + return sizeof(FramedTransport::Header::m_crcHeader) + sizeof(FramedTransport::Header::m_messageSize) + + sizeof(FramedTransport::Header::m_crcBody); +} + void FramedTransport::setCrc16(Crc16 *crcImpl) { erpc_assert(crcImpl); @@ -47,36 +53,57 @@ Crc16 *FramedTransport::getCrc16(void) erpc_status_t FramedTransport::receive(MessageBuffer *message) { - Header h; + Header h = { 0, 0, 0 }; erpc_status_t retVal; uint16_t computedCrc; + uint8_t offset = 0; erpc_assert((m_crcImpl != NULL) && ("Uninitialized Crc16 object." != NULL)); + // e.g. rpmsg tty may have nullptr and buffer is assigned in receive function. + if ((message->get() != nullptr) && (message->getLength() < reserveHeaderSize())) + { + retVal = kErpcStatus_MemoryError; + } + else { #if !ERPC_THREADS_IS(NONE) Mutex::Guard lock(m_receiveLock); #endif // Receive header first. - retVal = underlyingReceive((uint8_t *)&h, sizeof(h)); + retVal = underlyingReceive(message, reserveHeaderSize(), 0); + if ((retVal == kErpcStatus_Success) && (message->getLength() < reserveHeaderSize())) + { + retVal = kErpcStatus_MemoryError; + } if (retVal == kErpcStatus_Success) { + static_cast(memcpy(&h.m_crcHeader, message->get(), sizeof(h.m_crcHeader))); + offset = sizeof(h.m_crcHeader); + static_cast(memcpy(&h.m_messageSize, &message->get()[offset], sizeof(h.m_messageSize))); + offset += sizeof(h.m_messageSize); + static_cast(memcpy(&h.m_crcBody, &message->get()[offset], sizeof(h.m_crcBody))); + offset += sizeof(h.m_crcBody); + + ERPC_READ_AGNOSTIC_16(h.m_crcHeader); ERPC_READ_AGNOSTIC_16(h.m_messageSize); - ERPC_READ_AGNOSTIC_16(h.m_crc); + ERPC_READ_AGNOSTIC_16(h.m_crcBody); - // received size can't be zero. - if (h.m_messageSize == 0U) + computedCrc = + m_crcImpl->computeCRC16(reinterpret_cast(&h.m_messageSize), sizeof(h.m_messageSize)) + + m_crcImpl->computeCRC16(reinterpret_cast(&h.m_crcBody), sizeof(h.m_crcBody)); + if (computedCrc != h.m_crcHeader) { - retVal = kErpcStatus_ReceiveFailed; + retVal = kErpcStatus_CrcCheckFailed; } } if (retVal == kErpcStatus_Success) { // received size can't be larger then buffer length. - if (h.m_messageSize > message->getLength()) + if ((h.m_messageSize + reserveHeaderSize()) > message->getLength()) { retVal = kErpcStatus_ReceiveFailed; } @@ -84,20 +111,20 @@ erpc_status_t FramedTransport::receive(MessageBuffer *message) if (retVal == kErpcStatus_Success) { - // Receive rest of the message now we know its size. - retVal = underlyingReceive(message->get(), h.m_messageSize); + // rpmsg tty can receive all data in one buffer, others need second call. + if (message->getUsed() < (h.m_messageSize + reserveHeaderSize())) + { + // Receive rest of the message now we know its size. + retVal = underlyingReceive(message, h.m_messageSize, offset); + } } } if (retVal == kErpcStatus_Success) { // Verify CRC. - computedCrc = m_crcImpl->computeCRC16(message->get(), h.m_messageSize); - if (computedCrc == h.m_crc) - { - message->setUsed(h.m_messageSize); - } - else + computedCrc = m_crcImpl->computeCRC16(&message->get()[offset], h.m_messageSize); + if (computedCrc != h.m_crcBody) { retVal = kErpcStatus_CrcCheckFailed; } @@ -111,27 +138,51 @@ erpc_status_t FramedTransport::send(MessageBuffer *message) erpc_status_t ret; uint16_t messageLength; Header h; + uint8_t offset; erpc_assert((m_crcImpl != NULL) && ("Uninitialized Crc16 object." != NULL)); -#if !ERPC_THREADS_IS(NONE) - Mutex::Guard lock(m_sendLock); -#endif - - messageLength = message->getUsed(); + messageLength = message->getUsed() - reserveHeaderSize(); // Send header first. h.m_messageSize = messageLength; - h.m_crc = m_crcImpl->computeCRC16(message->get(), messageLength); + h.m_crcBody = m_crcImpl->computeCRC16(&message->get()[reserveHeaderSize()], messageLength); + h.m_crcHeader = + m_crcImpl->computeCRC16(reinterpret_cast(&h.m_messageSize), sizeof(h.m_messageSize)) + + m_crcImpl->computeCRC16(reinterpret_cast(&h.m_crcBody), sizeof(h.m_crcBody)); + ERPC_WRITE_AGNOSTIC_16(h.m_crcHeader); ERPC_WRITE_AGNOSTIC_16(h.m_messageSize); - ERPC_WRITE_AGNOSTIC_16(h.m_crc); + ERPC_WRITE_AGNOSTIC_16(h.m_crcBody); - ret = underlyingSend((uint8_t *)&h, sizeof(h)); - if (ret == kErpcStatus_Success) + static_cast(memcpy(message->get(), reinterpret_cast(&h.m_crcHeader), sizeof(h.m_crcHeader))); + offset = sizeof(h.m_crcHeader); + static_cast( + memcpy(&message->get()[offset], reinterpret_cast(&h.m_messageSize), sizeof(h.m_messageSize))); + offset += sizeof(h.m_messageSize); + static_cast( + memcpy(&message->get()[offset], reinterpret_cast(&h.m_crcBody), sizeof(h.m_crcBody))); + + ret = underlyingSend(message, message->getUsed(), 0); + + return ret; +} + +erpc_status_t FramedTransport::underlyingSend(MessageBuffer *message, uint32_t size, uint32_t offset) +{ + erpc_status_t retVal = underlyingSend(&message->get()[offset], size); + + return retVal; +} + +erpc_status_t FramedTransport::underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset) +{ + erpc_status_t retVal = underlyingReceive(&message->get()[offset], size); + + if (retVal == kErpcStatus_Success) { - ret = underlyingSend(message->get(), messageLength); + message->setUsed(size + offset); } - return ret; + return retVal; } diff --git a/erpc_c/infra/erpc_framed_transport.hpp b/erpc_c/infra/erpc_framed_transport.hpp index 580b0ab8..443f1cf4 100644 --- a/erpc_c/infra/erpc_framed_transport.hpp +++ b/erpc_c/infra/erpc_framed_transport.hpp @@ -56,6 +56,14 @@ namespace erpc { class FramedTransport : public Transport { public: + /*! @brief Contents of the header that prefixes each message. */ + struct Header + { + uint16_t m_crcHeader; //!< CRC-16 over this header structure data + uint16_t m_messageSize; //!< Size in bytes of the message, excluding the header. + uint16_t m_crcBody; //!< CRC-16 over the message data. + }; + /*! * @brief Constructor. */ @@ -66,6 +74,13 @@ class FramedTransport : public Transport */ virtual ~FramedTransport(void); + /** + * @brief Size of data placed in MessageBuffer before serializing eRPC data. + * + * @return uint8_t Amount of bytes, reserved before serialized data. + */ + virtual uint8_t reserveHeaderSize(void) override; + /*! * @brief Receives an entire message. * @@ -95,13 +110,6 @@ class FramedTransport : public Transport */ virtual erpc_status_t send(MessageBuffer *message) override; - /*! @brief Contents of the header that prefixes each message. */ - struct Header - { - uint16_t m_messageSize; //!< Size in bytes of the message, excluding the header. - uint16_t m_crc; //!< CRC-16 over the message data. - }; - /*! * @brief This functions sets the CRC-16 implementation. * @@ -124,6 +132,32 @@ class FramedTransport : public Transport Mutex m_receiveLock; //!< Mutex protecting receive. #endif + /*! + * @brief Adds ability to framed transport to overwrite MessageBuffer when sending data. + * + * Usually we don't want to do that. + * + * @param message MessageBuffer to send. + * @param size size of message to send. + * @param offset data start address offset + * + * @return erpc_status_t kErpcStatus_Success when it finished successful otherwise error. + */ + virtual erpc_status_t underlyingSend(MessageBuffer *message, uint32_t size, uint32_t offset); + + /*! + * @brief Adds ability to framed transport to overwrite MessageBuffer when receiving data. + * + * Usually we don't want to do that. + * + * @param message MessageBuffer to send. + * @param size size of message to send. + * @param offset data start address offset + * + * @return erpc_status_t kErpcStatus_Success when it finished successful otherwise error. + */ + virtual erpc_status_t underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset); + /*! * @brief Subclasses must implement this function to send data. * diff --git a/erpc_c/infra/erpc_message_buffer.cpp b/erpc_c/infra/erpc_message_buffer.cpp index 8c2cfc90..e578079c 100644 --- a/erpc_c/infra/erpc_message_buffer.cpp +++ b/erpc_c/infra/erpc_message_buffer.cpp @@ -9,6 +9,7 @@ */ #include "erpc_message_buffer.hpp" + #include "erpc_config_internal.h" #include @@ -20,6 +21,13 @@ using namespace std; // Code //////////////////////////////////////////////////////////////////////////////// +MessageBuffer::MessageBuffer(const MessageBuffer &buffer) +{ + m_buf = buffer.m_buf; + m_len = buffer.m_len; + m_used = buffer.m_used; +} + void MessageBuffer::setUsed(uint16_t used) { erpc_assert(used <= m_len); @@ -100,7 +108,7 @@ void MessageBuffer::swap(MessageBuffer *other) m_buf = temp.m_buf; } -void MessageBuffer::Cursor::set(MessageBuffer *buffer) +void Cursor::setBuffer(MessageBuffer &buffer, uint8_t reserved) { erpc_assert(buffer != NULL); @@ -108,62 +116,72 @@ void MessageBuffer::Cursor::set(MessageBuffer *buffer) // RPMSG when nested calls are enabled can set NULL buffer. // erpc_assert(buffer->get() && "Data buffer wasn't set to MessageBuffer."); // receive function should return err if it couldn't set data buffer. - m_pos = buffer->get(); + m_pos = buffer.get() + reserved; +} + +MessageBuffer Cursor::getBuffer(void) +{ + return m_buffer; +} + +MessageBuffer &Cursor::getBufferRef(void) +{ + return m_buffer; } -uint8_t &MessageBuffer::Cursor::operator[](int index) +uint8_t &Cursor::operator[](int index) { - erpc_assert(((m_pos + index) >= m_buffer->get()) && - ((uint16_t)(m_pos - m_buffer->get()) + index <= m_buffer->getLength())); + erpc_assert(((m_pos + index) >= m_buffer.get()) && + ((uint16_t)(m_pos - m_buffer.get()) + index <= m_buffer.getLength())); return m_pos[index]; } -const uint8_t &MessageBuffer::Cursor::operator[](int index) const +const uint8_t &Cursor::operator[](int index) const { - erpc_assert(((m_pos + index) >= m_buffer->get()) && - ((uint16_t)(m_pos - m_buffer->get()) + index <= m_buffer->getLength())); + erpc_assert(((m_pos + index) >= m_buffer.get()) && + ((uint16_t)(m_pos - m_buffer.get()) + index <= m_buffer.getLength())); return m_pos[index]; } -MessageBuffer::Cursor &MessageBuffer::Cursor::operator+=(uint16_t n) +Cursor &Cursor::operator+=(uint16_t n) { - erpc_assert((uint32_t)(m_pos - m_buffer->get()) + n <= m_buffer->getLength()); + erpc_assert((uint32_t)(m_pos - m_buffer.get()) + n <= m_buffer.getLength()); m_pos += n; return *this; } -MessageBuffer::Cursor &MessageBuffer::Cursor::operator-=(uint16_t n) +Cursor &Cursor::operator-=(uint16_t n) { - erpc_assert(((uintptr_t)m_pos >= n) && (m_pos - n) >= m_buffer->get()); + erpc_assert(((uintptr_t)m_pos >= n) && (m_pos - n) >= m_buffer.get()); m_pos -= n; return *this; } -MessageBuffer::Cursor &MessageBuffer::Cursor::operator++(void) +Cursor &Cursor::operator++(void) { - erpc_assert((uint16_t)(m_pos - m_buffer->get()) < m_buffer->getLength()); + erpc_assert((uint16_t)(m_pos - m_buffer.get()) < m_buffer.getLength()); ++m_pos; return *this; } -MessageBuffer::Cursor &MessageBuffer::Cursor::operator--(void) +Cursor &Cursor::operator--(void) { - erpc_assert(m_pos > m_buffer->get()); + erpc_assert(m_pos > m_buffer.get()); --m_pos; return *this; } -erpc_status_t MessageBuffer::Cursor::read(void *data, uint32_t length) +erpc_status_t Cursor::read(void *data, uint32_t length) { erpc_assert((m_pos != NULL) && ("Data buffer wasn't set to MessageBuffer." != NULL)); @@ -193,10 +211,10 @@ erpc_status_t MessageBuffer::Cursor::read(void *data, uint32_t length) return err; } -erpc_status_t MessageBuffer::Cursor::write(const void *data, uint32_t length) +erpc_status_t Cursor::write(const void *data, uint32_t length) { erpc_assert((m_pos != NULL) && ("Data buffer wasn't set to MessageBuffer." != NULL)); - erpc_assert(m_pos == (m_buffer->get() + m_buffer->getUsed())); + erpc_assert(m_pos == (m_buffer.get() + m_buffer.getUsed())); erpc_status_t err = kErpcStatus_Success; @@ -214,15 +232,33 @@ erpc_status_t MessageBuffer::Cursor::write(const void *data, uint32_t length) { (void)memcpy(m_pos, data, length); m_pos += length; - m_buffer->setUsed(m_buffer->getUsed() + length); + m_buffer.setUsed(m_buffer.getUsed() + length); } } return err; } -erpc_status_t MessageBufferFactory::prepareServerBufferForSend(MessageBuffer *message) +MessageBufferFactory::MessageBufferFactory(void) {} + +MessageBufferFactory::~MessageBufferFactory(void) {} + +MessageBuffer MessageBufferFactory::create(uint8_t reserveHeaderSize) +{ + MessageBuffer messageBuffer = create(); + + messageBuffer.setUsed(reserveHeaderSize); + + return messageBuffer; +} + +bool MessageBufferFactory::createServerBuffer(void) +{ + return true; +} + +erpc_status_t MessageBufferFactory::prepareServerBufferForSend(MessageBuffer &message, uint8_t reserveHeaderSize) { - message->setUsed(0); + message.setUsed(reserveHeaderSize); return kErpcStatus_Success; } diff --git a/erpc_c/infra/erpc_message_buffer.hpp b/erpc_c/infra/erpc_message_buffer.hpp index d815ca74..857c422f 100644 --- a/erpc_c/infra/erpc_message_buffer.hpp +++ b/erpc_c/infra/erpc_message_buffer.hpp @@ -64,6 +64,8 @@ class MessageBuffer { } + MessageBuffer(const MessageBuffer &buffer); + /*! * @brief This function set new buffer and his length. * @@ -183,162 +185,173 @@ class MessageBuffer */ const uint8_t &operator[](int index) const { return m_buf[index]; } +private: + uint8_t *volatile m_buf; /*!< Buffer used to read write data. */ + uint16_t volatile m_len; /*!< Length of buffer. */ + uint16_t volatile m_used; /*!< Used buffer bytes. */ +}; + +/*! + * @brief Cursor within a MessageBuffer. + */ +class Cursor +{ +public: + /*! + * @brief Constructor. + * + * This function initializes object attributes. + */ + Cursor(void) + : m_buffer() + , m_pos(NULL) + { + } + /*! - * @brief Cursor within a MessageBuffer. + * @brief Constructor. + * + * This function initializes object attributes. + * + * @param[in] buffer MessageBuffer for sending/receiving. */ - class Cursor + explicit Cursor(MessageBuffer &buffer) + : m_buffer(buffer) + , m_pos(buffer.get()) { - public: - /*! - * @brief Constructor. - * - * This function initializes object attributes. - */ - Cursor(void) - : m_buffer(NULL) - , m_pos(NULL) - { - } - - /*! - * @brief Constructor. - * - * This function initializes object attributes. - * - * @param[in] buffer MessageBuffer for sending/receiving. - */ - explicit Cursor(MessageBuffer *buffer) - : m_buffer(buffer) - , m_pos(buffer->get()) - { - } - - /*! - * @brief Set message buffer. - * - * @param[in] buffer Message buffer to set. - */ - void set(MessageBuffer *buffer); - - /*! - * @brief Return position in buffer. - * - * Return position, where it last write/read. - * - * @return Return position in buffer. - */ - uint8_t *get(void) { return m_pos; } - - /*! - * @brief Return position in buffer. - * - * Return position, where it last write/read. - * - * @return Return position in buffer. - */ - const uint8_t *get(void) const { return m_pos; } - - /*! - * @brief Return remaining free space in current buffer. - * - * @return Remaining free space in current buffer. - */ - uint16_t getRemaining(void) const { return m_buffer->getLength() - (uint16_t)(m_pos - m_buffer->get()); } - - /*! - * @brief Return remaining space from used of current buffer. - * - * @return Remaining space from used of current buffer. - */ - uint16_t getRemainingUsed(void) const { return m_buffer->getUsed() - (uint16_t)(m_pos - m_buffer->get()); } - - /*! - * @brief Read data from current buffer. - * - * @param[out] data Pointer to value, where copy read data. - * @param[in] length How much bytes need be read. - * - * @retval kErpcStatus_Success - * @retval kErpcStatus_BufferOverrun - */ - erpc_status_t read(void *data, uint32_t length); - - /*! - * @brief Read data from current buffer. - * - * @param[out] data Pointer to value to be sent. - * @param[in] length How much bytes need be wrote. - * - * @retval kErpcStatus_Success - * @retval kErpcStatus_BufferOverrun - */ - erpc_status_t write(const void *data, uint32_t length); - - /*! - * @brief Casting operator return local buffer. - */ - operator uint8_t *(void) { return m_pos; } - - /*! - * @brief Casting operator return local buffer. - */ - operator const uint8_t *(void) const { return m_pos; } - - /*! - * @brief Array operator return value of buffer at given index. - * - * @param[in] index Index in buffer. - */ - uint8_t &operator[](int index); - - /*! - * @brief Array operator return value of buffer at given index. - * - * @param[in] index Index in buffer. - */ - const uint8_t &operator[](int index) const; - - /*! - * @brief Sum operator return local buffer. - * - * @param[in] n Summing with n. - * - * @return Current cursor instance. - */ - Cursor &operator+=(uint16_t n); - - /*! - * @brief Subtract operator return local buffer. - * - * @param[in] n Subtracting with n. - * - * @return Current cursor instance. - */ - Cursor &operator-=(uint16_t n); - - /*! - * @brief Sum +1 operator. - * - * @return Current cursor instance. - */ - Cursor &operator++(void); - - /*! - * @brief Subtract -1 operator. - * - * @return Current cursor instance. - */ - Cursor &operator--(void); - - private: - MessageBuffer *m_buffer; /*!< Buffer for reading or writing data. */ - uint8_t *m_pos; /*!< Position in buffer, where it last write/read */ - }; + } + + /*! + * @brief Set message buffer. + * + * @param[in] buffer Message buffer to set. + * @param[in] reserved Moved cursor position outside of reserved memory. + */ + void setBuffer(MessageBuffer &buffer, uint8_t reserved = 0); + + /*! + * @brief Get message buffer. + */ + MessageBuffer getBuffer(void); + + /*! + * @brief Get message buffer. + */ + MessageBuffer &getBufferRef(void); + + /*! + * @brief Return position in buffer. + * + * Return position, where it last write/read. + * + * @return Return position in buffer. + */ + uint8_t *get(void) { return m_pos; } + + /*! + * @brief Return position in buffer. + * + * Return position, where it last write/read. + * + * @return Return position in buffer. + */ + const uint8_t *get(void) const { return m_pos; } + + /*! + * @brief Return remaining free space in current buffer. + * + * @return Remaining free space in current buffer. + */ + uint16_t getRemaining(void) const { return m_buffer.getLength() - (uint16_t)(m_pos - m_buffer.get()); } + + /*! + * @brief Return remaining space from used of current buffer. + * + * @return Remaining space from used of current buffer. + */ + uint16_t getRemainingUsed(void) const { return m_buffer.getUsed() - (uint16_t)(m_pos - m_buffer.get()); } + + /*! + * @brief Read data from current buffer. + * + * @param[out] data Pointer to value, where copy read data. + * @param[in] length How much bytes need be read. + * + * @retval kErpcStatus_Success + * @retval kErpcStatus_BufferOverrun + */ + erpc_status_t read(void *data, uint32_t length); + + /*! + * @brief Read data from current buffer. + * + * @param[out] data Pointer to value to be sent. + * @param[in] length How much bytes need be wrote. + * + * @retval kErpcStatus_Success + * @retval kErpcStatus_BufferOverrun + */ + erpc_status_t write(const void *data, uint32_t length); + + /*! + * @brief Casting operator return local buffer. + */ + operator uint8_t *(void) { return m_pos; } + + /*! + * @brief Casting operator return local buffer. + */ + operator const uint8_t *(void) const { return m_pos; } + + /*! + * @brief Array operator return value of buffer at given index. + * + * @param[in] index Index in buffer. + */ + uint8_t &operator[](int index); + + /*! + * @brief Array operator return value of buffer at given index. + * + * @param[in] index Index in buffer. + */ + const uint8_t &operator[](int index) const; + + /*! + * @brief Sum operator return local buffer. + * + * @param[in] n Summing with n. + * + * @return Current cursor instance. + */ + Cursor &operator+=(uint16_t n); + + /*! + * @brief Subtract operator return local buffer. + * + * @param[in] n Subtracting with n. + * + * @return Current cursor instance. + */ + Cursor &operator-=(uint16_t n); + + /*! + * @brief Sum +1 operator. + * + * @return Current cursor instance. + */ + Cursor &operator++(void); + + /*! + * @brief Subtract -1 operator. + * + * @return Current cursor instance. + */ + Cursor &operator--(void); private: - uint8_t *volatile m_buf; /*!< Buffer used to read write data. */ - uint16_t volatile m_len; /*!< Length of buffer. */ - uint16_t volatile m_used; /*!< Used buffer bytes. */ + MessageBuffer m_buffer; /*!< Buffer for reading or writing data. */ + uint8_t *m_pos; /*!< Position in buffer, where it last write/read */ }; /*! @@ -354,12 +367,12 @@ class MessageBufferFactory * * This function initializes object attributes. */ - MessageBufferFactory(void) {} + MessageBufferFactory(void); /*! * @brief MessageBufferFactory destructor */ - virtual ~MessageBufferFactory(void) {} + virtual ~MessageBufferFactory(void); /*! * @brief This function creates new message buffer. @@ -368,12 +381,23 @@ class MessageBufferFactory */ virtual MessageBuffer create(void) = 0; + /*! + * @brief This function creates new message buffer with reserved bytes at the beginning + * + * Reserved bytes can be used by transport to write transport related header file data. + * + * @param[in] reserveHeaderSize Reserved amount of bytes at the beginning of message buffer. + * + * @return New created MessageBuffer. + */ + MessageBuffer create(uint8_t reserveHeaderSize); + /*! * @brief This function informs server if it has to create buffer for received message. * * @return Has to return TRUE when server need create buffer for receiving message. */ - virtual bool createServerBuffer(void) { return true; } + virtual bool createServerBuffer(void); /*! * @brief This function is preparing output buffer on server side. @@ -382,8 +406,9 @@ class MessageBufferFactory * In case of using new buffer function has to free given buffer. * * @param[in] message MessageBuffer which can be reused. + * @param[in] reserveHeaderSize Reserved amount of bytes at the beginning of message buffer. */ - virtual erpc_status_t prepareServerBufferForSend(MessageBuffer *message); + virtual erpc_status_t prepareServerBufferForSend(MessageBuffer &message, uint8_t reserveHeaderSize = 0); /*! * @brief This function disposes message buffer. diff --git a/erpc_c/infra/erpc_message_loggers.hpp b/erpc_c/infra/erpc_message_loggers.hpp index a060d163..528c7702 100644 --- a/erpc_c/infra/erpc_message_loggers.hpp +++ b/erpc_c/infra/erpc_message_loggers.hpp @@ -86,7 +86,7 @@ class MessageLoggers /*! * @brief Transport destructor */ - virtual ~MessageLoggers(void); + ~MessageLoggers(void); /*! * @brief This function add given transport to newly created MessageLogger object. diff --git a/erpc_c/infra/erpc_server.cpp b/erpc_c/infra/erpc_server.cpp index 2fe306bb..0a2d558e 100644 --- a/erpc_c/infra/erpc_server.cpp +++ b/erpc_c/infra/erpc_server.cpp @@ -91,7 +91,7 @@ erpc_status_t Server::processMessage(Codec *codec, message_type_t msgType, uint3 if (err == kErpcStatus_Success) { - err = service->handleInvocation(methodId, sequence, codec, m_messageFactory); + err = service->handleInvocation(methodId, sequence, codec, m_messageFactory, m_transport); } return err; diff --git a/erpc_c/infra/erpc_server.hpp b/erpc_c/infra/erpc_server.hpp index ea0ea203..b16df195 100644 --- a/erpc_c/infra/erpc_server.hpp +++ b/erpc_c/infra/erpc_server.hpp @@ -87,7 +87,7 @@ class Service * @return Based on handleInvocation implementation. */ virtual erpc_status_t handleInvocation(uint32_t methodId, uint32_t sequence, Codec *codec, - MessageBufferFactory *messageFactory) = 0; + MessageBufferFactory *messageFactory, Transport *transport) = 0; protected: uint32_t m_serviceId; /*!< Service unique id. */ diff --git a/erpc_c/infra/erpc_simple_server.cpp b/erpc_c/infra/erpc_simple_server.cpp index 3ac59c37..9d268849 100644 --- a/erpc_c/infra/erpc_simple_server.cpp +++ b/erpc_c/infra/erpc_simple_server.cpp @@ -15,17 +15,49 @@ using namespace erpc; //////////////////////////////////////////////////////////////////////////////// // Code //////////////////////////////////////////////////////////////////////////////// +SimpleServer::SimpleServer(void) +: m_isServerOn(true) +{ +} -void SimpleServer::disposeBufferAndCodec(Codec *codec) +SimpleServer::~SimpleServer(void) {} + +erpc_status_t SimpleServer::run(void) { - if (codec != NULL) + erpc_status_t err = kErpcStatus_Success; + while ((err == kErpcStatus_Success) && m_isServerOn) { - if (codec->getBuffer() != NULL) + err = runInternal(); + } + return err; +} + +erpc_status_t SimpleServer::poll(void) +{ + erpc_status_t err; + + if (m_isServerOn) + { + if (m_transport->hasMessage() == true) { - m_messageFactory->dispose(codec->getBuffer()); + err = runInternal(); } - m_codecFactory->dispose(codec); + else + { + err = kErpcStatus_Success; + } + } + else + { + err = kErpcStatus_ServerIsDown; } + + return err; +} + +void SimpleServer::stop(void) +{ + m_isServerOn = false; } erpc_status_t SimpleServer::runInternal(void) @@ -103,7 +135,7 @@ erpc_status_t SimpleServer::runInternalBegin(Codec **codec, MessageBuffer &buff, if (err == kErpcStatus_Success) { - (*codec)->setBuffer(buff); + (*codec)->setBuffer(buff, m_transport->reserveHeaderSize()); err = readHeadOfMessage(*codec, msgType, serviceId, methodId, sequence); if (err != kErpcStatus_Success) @@ -130,7 +162,7 @@ erpc_status_t SimpleServer::runInternalEnd(Codec *codec, message_type_t msgType, if (err == kErpcStatus_Success) { #endif - err = m_transport->send(codec->getBuffer()); + err = m_transport->send(&codec->getBufferRef()); #if ERPC_MESSAGE_LOGGING } #endif @@ -151,16 +183,6 @@ erpc_status_t SimpleServer::runInternalEnd(Codec *codec, message_type_t msgType, return err; } -erpc_status_t SimpleServer::run(void) -{ - erpc_status_t err = kErpcStatus_Success; - while ((err == kErpcStatus_Success) && m_isServerOn) - { - err = runInternal(); - } - return err; -} - #if ERPC_NESTED_CALLS erpc_status_t SimpleServer::run(RequestContext &request) { @@ -188,7 +210,7 @@ erpc_status_t SimpleServer::run(RequestContext &request) if (sequence == request.getSequence()) { // Swap the received message buffer with the client's message buffer. - request.getCodec()->getBuffer()->swap(&buff); + request.getCodec()->getBufferRef().swap(&buff); codec->setBuffer(buff); } @@ -212,30 +234,14 @@ erpc_status_t SimpleServer::run(RequestContext &request) } #endif -erpc_status_t SimpleServer::poll(void) +void SimpleServer::disposeBufferAndCodec(Codec *codec) { - erpc_status_t err; - - if (m_isServerOn) + if (codec != NULL) { - if (m_transport->hasMessage() == true) + if (codec->getBuffer() != NULL) { - err = runInternal(); + m_messageFactory->dispose(&codec->getBufferRef()); } - else - { - err = kErpcStatus_Success; - } - } - else - { - err = kErpcStatus_ServerIsDown; + m_codecFactory->dispose(codec); } - - return err; -} - -void SimpleServer::stop(void) -{ - m_isServerOn = false; } diff --git a/erpc_c/infra/erpc_simple_server.hpp b/erpc_c/infra/erpc_simple_server.hpp index 21083348..efe0ebc0 100644 --- a/erpc_c/infra/erpc_simple_server.hpp +++ b/erpc_c/infra/erpc_simple_server.hpp @@ -37,10 +37,9 @@ class SimpleServer : public Server * * This function initializes object attributes. */ - SimpleServer(void) - : m_isServerOn(true) - { - } + SimpleServer(void); + + virtual ~SimpleServer(void); /*! * @brief Run server in infinite loop. @@ -66,6 +65,16 @@ class SimpleServer : public Server virtual void stop(void) override; protected: + bool m_isServerOn; /*!< Information if server is ON or OFF. */ + + /*! + * @brief Run server implementation. + * + * This function call functions for receiving data, process this data and + * if reply exist, send it back. + */ + erpc_status_t runInternal(void); + /*! * @brief This function handle receiving request message and reading base info about message. * @@ -104,22 +113,12 @@ class SimpleServer : public Server virtual erpc_status_t run(RequestContext &request) override; #endif - /*! - * @brief Run server implementation. - * - * This function call functions for receiving data, process this data and - * if reply exist, send it back. - */ - erpc_status_t runInternal(void); - /*! * @brief Disposing message buffers and codecs. * * @param[in] codec Pointer to codec to dispose. It contains also message buffer to dispose. */ void disposeBufferAndCodec(Codec *codec); - - bool m_isServerOn; /*!< Information if server is ON or OFF. */ }; } // namespace erpc diff --git a/erpc_c/infra/erpc_transport.hpp b/erpc_c/infra/erpc_transport.hpp index 88fe2e16..88fde0e3 100644 --- a/erpc_c/infra/erpc_transport.hpp +++ b/erpc_c/infra/erpc_transport.hpp @@ -46,6 +46,13 @@ class Transport */ virtual ~Transport(void) {} + /** + * @brief Size of data placed in MessageBuffer before serializing eRPC data. + * + * @return uint8_t Amount of bytes, reserved before serialized data. + */ + virtual uint8_t reserveHeaderSize(void) { return 0; } + /*! * @brief Prototype for receiving message. * @@ -106,10 +113,12 @@ class TransportFactory * @brief Constructor. */ TransportFactory(void) {} + /*! * @brief TransportFactory destructor */ virtual ~TransportFactory(void) {} + /*! * @brief Return created transport object. * diff --git a/erpc_c/infra/erpc_transport_arbitrator.cpp b/erpc_c/infra/erpc_transport_arbitrator.cpp index 453fa341..5d57f686 100644 --- a/erpc_c/infra/erpc_transport_arbitrator.cpp +++ b/erpc_c/infra/erpc_transport_arbitrator.cpp @@ -44,24 +44,9 @@ TransportArbitrator::~TransportArbitrator(void) freeClientList(m_clientFreeList); } -void TransportArbitrator::setCrc16(Crc16 *crcImpl) +uint8_t TransportArbitrator::reserveHeaderSize(void) { - erpc_assert(crcImpl != NULL); - erpc_assert(m_sharedTransport != NULL); - m_sharedTransport->setCrc16(crcImpl); -} - -Crc16 *TransportArbitrator::getCrc16(void) -{ - erpc_assert(m_sharedTransport != NULL); - return m_sharedTransport->getCrc16(); -} - -bool TransportArbitrator::hasMessage(void) -{ - erpc_assert((m_sharedTransport != NULL) && ("shared transport is not set" != NULL)); - - return m_sharedTransport->hasMessage(); + return m_sharedTransport->reserveHeaderSize(); } erpc_status_t TransportArbitrator::receive(MessageBuffer *message) @@ -96,7 +81,7 @@ erpc_status_t TransportArbitrator::receive(MessageBuffer *message) break; } - m_codec->setBuffer(*message); + m_codec->setBuffer(*message, m_sharedTransport->reserveHeaderSize()); // Parse the message header. m_codec->startReadMessage(msgType, service, requestNumber, sequence); @@ -125,7 +110,7 @@ erpc_status_t TransportArbitrator::receive(MessageBuffer *message) if (client->m_isValid && (sequence == client->m_request->getSequence())) { // Swap the received message buffer with the client's message buffer. - client->m_request->getCodec()->getBuffer()->swap(message); + client->m_request->getCodec()->getBufferRef().swap(message); // Wake up the client receive thread. client->m_sem.put(); @@ -151,6 +136,46 @@ erpc_status_t TransportArbitrator::send(MessageBuffer *message) return m_sharedTransport->send(message); } +bool TransportArbitrator::hasMessage(void) +{ + erpc_assert((m_sharedTransport != NULL) && ("shared transport is not set" != NULL)); + + return m_sharedTransport->hasMessage(); +} + +void TransportArbitrator::setCrc16(Crc16 *crcImpl) +{ + erpc_assert(crcImpl != NULL); + erpc_assert(m_sharedTransport != NULL); + m_sharedTransport->setCrc16(crcImpl); +} + +Crc16 *TransportArbitrator::getCrc16(void) +{ + erpc_assert(m_sharedTransport != NULL); + return m_sharedTransport->getCrc16(); +} + +void TransportArbitrator::setSharedTransport(Transport *shared) +{ + m_sharedTransport = shared; +} + +Transport *TransportArbitrator::getSharedTransport(void) +{ + return m_sharedTransport; +} + +void TransportArbitrator::setCodec(Codec *codec) +{ + m_codec = codec; +} + +Codec *TransportArbitrator::getCodec(void) +{ + return m_codec; +} + TransportArbitrator::client_token_t TransportArbitrator::prepareClientReceive(RequestContext &request) { PendingClientInfo *info = addPendingClient(); diff --git a/erpc_c/infra/erpc_transport_arbitrator.hpp b/erpc_c/infra/erpc_transport_arbitrator.hpp index 891ed7a3..3077d500 100644 --- a/erpc_c/infra/erpc_transport_arbitrator.hpp +++ b/erpc_c/infra/erpc_transport_arbitrator.hpp @@ -53,44 +53,84 @@ class TransportArbitrator : public Transport */ virtual ~TransportArbitrator(void); + /** + * @brief Size of data placed in MessageBuffer before serializing eRPC data. + * + * @return uint8_t Amount of bytes, reserved before serialized data. + */ + virtual uint8_t reserveHeaderSize(void) override; + + /*! + * @brief Prototype for receiving message. + * + * Each transport layer need define this function. + * + * @param[out] message Will return pointer to received message buffer. + * + * @return based on receive implementation. + */ + virtual erpc_status_t receive(MessageBuffer *message) override; + + /*! + * @brief Prototype for send message. + * + * Each transport layer need define this function. + * + * @param[in] message Pass message buffer to send. + * + * @return based on send implementation. + */ + virtual erpc_status_t send(MessageBuffer *message) override; + + /*! + * @brief Check if the underlying shared transport has a message + * + * @retval The underlying transport is expected to return true when a message is available to + * process and false otherwise. + */ + virtual bool hasMessage(void) override; + + /*! + * @brief This functions sets the CRC-16 implementation. + * + * @param[in] crcImpl Object containing crc-16 compute function. + */ + virtual void setCrc16(Crc16 *crcImpl) override; + + /*! + * @brief This functions gets the CRC-16 object. + * + * @return Crc16* Pointer to CRC-16 object containing crc-16 compute function. + */ + virtual Crc16 * getCrc16(void) override; + /*! * @brief This function set shared client/server transport. * * @param[in] shared Shared client/server transport. */ - void setSharedTransport(Transport *shared) { m_sharedTransport = shared; } + void setSharedTransport(Transport *shared); /*! * @brief This function returns shared client/server transport. * * @return Transport * Returns shared client/server transport. */ - Transport * getSharedTransport(void) { return m_sharedTransport; } + Transport * getSharedTransport(void); /*! * @brief This function set codec. * * @param[in] codec Codec. */ - void setCodec(Codec *codec) { m_codec = codec; } + void setCodec(Codec *codec); /*! * @brief This function get codec. * * @return Codec * Pointer to codec used within transport. */ - Codec * getCodec(void) { return m_codec; } - - /*! - * @brief Prototype for receiving message. - * - * Each transport layer need define this function. - * - * @param[out] message Will return pointer to received message buffer. - * - * @return based on receive implementation. - */ - virtual erpc_status_t receive(MessageBuffer *message) override; + Codec * getCodec(void); /*! * @brief Add a client request to the client list. @@ -117,39 +157,6 @@ class TransportArbitrator : public Transport */ erpc_status_t clientReceive(client_token_t token); - /*! - * @brief Prototype for send message. - * - * Each transport layer need define this function. - * - * @param[in] message Pass message buffer to send. - * - * @return based on send implementation. - */ - virtual erpc_status_t send(MessageBuffer *message) override; - - /*! - * @brief This functions sets the CRC-16 implementation. - * - * @param[in] crcImpl Object containing crc-16 compute function. - */ - virtual void setCrc16(Crc16 *crcImpl) override; - - /*! - * @brief This functions gets the CRC-16 object. - * - * @return Crc16* Pointer to CRC-16 object containing crc-16 compute function. - */ - virtual Crc16 * getCrc16(void) override; - - /*! - * @brief Check if the underlying shared transport has a message - * - * @retval The underlying transport is expected to return true when a message is available to - * process and false otherwise. - */ - virtual bool hasMessage(void) override; - /*! * @brief Request info for a client trying to receive a response. */ diff --git a/erpc_c/setup/erpc_mbf_setup.h b/erpc_c/setup/erpc_mbf_setup.h index f760914a..87ba45d3 100644 --- a/erpc_c/setup/erpc_mbf_setup.h +++ b/erpc_c/setup/erpc_mbf_setup.h @@ -48,20 +48,6 @@ erpc_mbf_t erpc_mbf_dynamic_init(void); */ void erpc_mbf_dynamic_deinit(erpc_mbf_t mbf); -/*! - * @brief Create MessageBuffer factory which is using RPMSG LITE TTY buffers. - * - * Has to be used with RPMSG lite TTY transport. - */ -erpc_mbf_t erpc_mbf_rpmsg_tty_init(erpc_transport_t transport); - -/*! - * @brief Deinit MessageBuffer factory. - * - * @param[in] mbf MessageBuffer factory which was initialized in init function. - */ -void erpc_mbf_rpmsg_tty_deinit(erpc_mbf_t mbf); - /*! * @brief Create MessageBuffer factory which is using RPMSG LITE zero copy buffers. * diff --git a/erpc_c/setup/erpc_setup_mbf_rpmsg.cpp b/erpc_c/setup/erpc_setup_mbf_rpmsg.cpp index ccf03eea..2d0c2e7d 100644 --- a/erpc_c/setup/erpc_setup_mbf_rpmsg.cpp +++ b/erpc_c/setup/erpc_setup_mbf_rpmsg.cpp @@ -12,7 +12,7 @@ #include "erpc_manually_constructed.hpp" #include "erpc_mbf_setup.h" #include "erpc_message_buffer.hpp" -#include "erpc_rpmsg_lite_base_transport.hpp" +#include "erpc_rpmsg_lite_base.hpp" extern "C" { #include "rpmsg_lite.h" @@ -20,6 +20,8 @@ extern "C" { using namespace erpc; +#define TIMEOUT_MS 10 + //////////////////////////////////////////////////////////////////////////////// // Classes //////////////////////////////////////////////////////////////////////////////// @@ -51,7 +53,7 @@ class RPMsgMessageBufferFactory : public MessageBufferFactory { void *buf = NULL; uint32_t size = 0; - buf = rpmsg_lite_alloc_tx_buffer(m_rpmsg, &size, RL_BLOCK); + buf = rpmsg_lite_alloc_tx_buffer(m_rpmsg, &size, TIMEOUT_MS); erpc_assert(NULL != buf); return MessageBuffer(reinterpret_cast(buf), size); @@ -77,14 +79,15 @@ class RPMsgMessageBufferFactory : public MessageBufferFactory } } - virtual erpc_status_t prepareServerBufferForSend(MessageBuffer *message) + virtual erpc_status_t prepareServerBufferForSend(MessageBuffer &message, uint8_t reserveHeaderSize = 0) { erpc_status_t status; - dispose(message); - *message = create(); - if (message->get() != NULL) + dispose(&message); + message = create(); + if (message.get() != NULL) { + message.setUsed(reserveHeaderSize); status = kErpcStatus_Success; } else @@ -118,12 +121,12 @@ erpc_mbf_t erpc_mbf_rpmsg_init(erpc_transport_t transport) } else { - s_msgFactory.construct(reinterpret_cast(transport)->get_rpmsg_lite_instance()); + s_msgFactory.construct(reinterpret_cast(transport)->get_rpmsg_lite_instance()); msgFactory = s_msgFactory.get(); } #elif ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC msgFactory = - new RPMsgMessageBufferFactory(reinterpret_cast(transport)->get_rpmsg_lite_instance()); + new RPMsgMessageBufferFactory(reinterpret_cast(transport)->get_rpmsg_lite_instance()); #else #error "Unknown eRPC allocation policy!" #endif diff --git a/erpc_c/setup/erpc_setup_mbf_rpmsg_tty.cpp b/erpc_c/setup/erpc_setup_mbf_rpmsg_tty.cpp deleted file mode 100644 index d6a6cd3a..00000000 --- a/erpc_c/setup/erpc_setup_mbf_rpmsg_tty.cpp +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright (c) 2016, Freescale Semiconductor, Inc. - * Copyright 2016-2017 NXP - * Copyright 2021 ACRIOS Systems s.r.o. - * All rights reserved. - * - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#include "erpc_config_internal.h" -#include "erpc_framed_transport.hpp" -#include "erpc_manually_constructed.hpp" -#include "erpc_mbf_setup.h" -#include "erpc_message_buffer.hpp" -#include "erpc_rpmsg_lite_base_transport.hpp" - -extern "C" { -#include "rpmsg_lite.h" -} - -using namespace erpc; - -#define TIMEOUT_MS 10 - -//////////////////////////////////////////////////////////////////////////////// -// Classes -//////////////////////////////////////////////////////////////////////////////// - -/*! - * @brief RPMsg TTY message buffer factory - */ -class RPMsgTTYMessageBufferFactory : public MessageBufferFactory -{ -public: - /*! - * @brief Constructor. - * - * @param [in] rpmsg Pointer to instance of RPMSG lite. - */ - explicit RPMsgTTYMessageBufferFactory(struct rpmsg_lite_instance *rpmsg) { m_rpmsg = rpmsg; } - - /*! - * @brief Destructor - */ - virtual ~RPMsgTTYMessageBufferFactory(void) {} - - /*! - * @brief This function creates new message buffer. - * - * @return MessageBuffer New created MessageBuffer. - */ - virtual MessageBuffer create(void) - { - void *buf = NULL; - uint32_t size = 0; - buf = rpmsg_lite_alloc_tx_buffer(m_rpmsg, &size, TIMEOUT_MS); - - erpc_assert(NULL != buf); - return MessageBuffer(&(reinterpret_cast(buf))[sizeof(FramedTransport::Header)], - size - sizeof(FramedTransport::Header)); - } - - /*! - * @brief This function disposes message buffer. - * - * @param[in] buf MessageBuffer to dispose. - */ - virtual void dispose(MessageBuffer *buf) - { - erpc_assert(buf != NULL); - void *tmp = reinterpret_cast(buf->get()); - if (tmp != NULL) - { - int32_t ret; - ret = rpmsg_lite_release_rx_buffer( - m_rpmsg, reinterpret_cast(reinterpret_cast(tmp) - sizeof(FramedTransport::Header))); - if (ret != RL_SUCCESS) - { - // error - } - } - } - - virtual erpc_status_t prepareServerBufferForSend(MessageBuffer *message) - { - erpc_status_t status; - - dispose(message); - *message = create(); - if (message->get() != NULL) - { - status = kErpcStatus_Success; - } - else - { - status = kErpcStatus_MemoryError; - } - - return status; - } - - virtual bool createServerBuffer(void) { return false; } - -protected: - struct rpmsg_lite_instance *m_rpmsg; /*!< Pointer to instance of RPMSG lite. */ -}; - -//////////////////////////////////////////////////////////////////////////////// -// Variables -//////////////////////////////////////////////////////////////////////////////// - -ERPC_MANUALLY_CONSTRUCTED_STATIC(RPMsgTTYMessageBufferFactory, s_msgFactory); - -erpc_mbf_t erpc_mbf_rpmsg_tty_init(erpc_transport_t transport) -{ - RPMsgTTYMessageBufferFactory *msgFactory; - -#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_STATIC - if (s_msgFactory.isUsed()) - { - msgFactory = NULL; - } - else - { - s_msgFactory.construct(reinterpret_cast(transport)->get_rpmsg_lite_instance()); - msgFactory = s_msgFactory.get(); - } -#elif ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC - msgFactory = - new RPMsgTTYMessageBufferFactory(reinterpret_cast(transport)->get_rpmsg_lite_instance()); -#else -#error "Unknown eRPC allocation policy!" -#endif - - return reinterpret_cast(msgFactory); -} - -void erpc_mbf_rpmsg_tty_deinit(erpc_mbf_t mbf) -{ -#if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_STATIC - (void)mbf; - s_msgFactory.destroy(); -#elif ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_DYNAMIC - erpc_assert(mbf != NULL); - - RPMsgTTYMessageBufferFactory *msgFactory = reinterpret_cast(mbf); - - delete msgFactory; -#endif -} diff --git a/erpc_c/transports/erpc_dspi_master_transport.hpp b/erpc_c/transports/erpc_dspi_master_transport.hpp index 3605542d..108a0d42 100644 --- a/erpc_c/transports/erpc_dspi_master_transport.hpp +++ b/erpc_c/transports/erpc_dspi_master_transport.hpp @@ -63,6 +63,9 @@ class DspiMasterTransport : public FramedTransport uint32_t m_srcClock_Hz; /*!< Source clock of DSPI peripheral used in this transport layer */ private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from DSPI peripheral. * @@ -72,7 +75,7 @@ class DspiMasterTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed DSPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to DSPI peripheral. @@ -83,7 +86,7 @@ class DspiMasterTransport : public FramedTransport * @retval kErpcStatus_SendFailed DSPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_dspi_slave_transport.hpp b/erpc_c/transports/erpc_dspi_slave_transport.hpp index f9d8039a..65cc214d 100644 --- a/erpc_c/transports/erpc_dspi_slave_transport.hpp +++ b/erpc_c/transports/erpc_dspi_slave_transport.hpp @@ -78,6 +78,9 @@ class DspiSlaveTransport : public FramedTransport #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from DSPI peripheral. * @@ -87,7 +90,7 @@ class DspiSlaveTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed DSPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to DSPI peripheral. @@ -98,7 +101,7 @@ class DspiSlaveTransport : public FramedTransport * @retval kErpcStatus_SendFailed DSPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_i2c_slave_transport.hpp b/erpc_c/transports/erpc_i2c_slave_transport.hpp index 425b2807..6cd23287 100644 --- a/erpc_c/transports/erpc_i2c_slave_transport.hpp +++ b/erpc_c/transports/erpc_i2c_slave_transport.hpp @@ -78,6 +78,9 @@ class I2cSlaveTransport : public FramedTransport #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from I2C peripheral. * @@ -87,7 +90,7 @@ class I2cSlaveTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed I2C failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to I2C peripheral. @@ -98,7 +101,7 @@ class I2cSlaveTransport : public FramedTransport * @retval kErpcStatus_SendFailed I2C failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_inter_thread_buffer_transport.hpp b/erpc_c/transports/erpc_inter_thread_buffer_transport.hpp index 907a92f0..655aba2d 100644 --- a/erpc_c/transports/erpc_inter_thread_buffer_transport.hpp +++ b/erpc_c/transports/erpc_inter_thread_buffer_transport.hpp @@ -57,8 +57,8 @@ class InterThreadBufferTransport : public Transport void linkWithPeer(InterThreadBufferTransport *peer); - virtual erpc_status_t receive(MessageBuffer *message); - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t receive(MessageBuffer *message)override; + virtual erpc_status_t send(MessageBuffer *message)override; virtual int32_t getAvailable(void) const { return 0; } diff --git a/erpc_c/transports/erpc_lpi2c_slave_transport.hpp b/erpc_c/transports/erpc_lpi2c_slave_transport.hpp index 407ed7ac..53ab6c9a 100644 --- a/erpc_c/transports/erpc_lpi2c_slave_transport.hpp +++ b/erpc_c/transports/erpc_lpi2c_slave_transport.hpp @@ -77,6 +77,9 @@ class LPI2cSlaveTransport : public FramedTransport #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from LPI2C peripheral. * @@ -86,7 +89,7 @@ class LPI2cSlaveTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed LPI2C failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to LPI2C peripheral. @@ -97,7 +100,7 @@ class LPI2cSlaveTransport : public FramedTransport * @retval kErpcStatus_SendFailed LPI2C failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_lpspi_slave_transport.hpp b/erpc_c/transports/erpc_lpspi_slave_transport.hpp index 7c5c726a..8e0bd40f 100644 --- a/erpc_c/transports/erpc_lpspi_slave_transport.hpp +++ b/erpc_c/transports/erpc_lpspi_slave_transport.hpp @@ -78,6 +78,9 @@ class LPSpiSlaveTransport : public FramedTransport #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from LPSPI peripheral. * @@ -87,7 +90,7 @@ class LPSpiSlaveTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed LPSPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to LPSPI peripheral. @@ -98,7 +101,7 @@ class LPSpiSlaveTransport : public FramedTransport * @retval kErpcStatus_SendFailed LPSPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_mu_transport.cpp b/erpc_c/transports/erpc_mu_transport.cpp index 15de63f8..e6c64a63 100644 --- a/erpc_c/transports/erpc_mu_transport.cpp +++ b/erpc_c/transports/erpc_mu_transport.cpp @@ -287,6 +287,11 @@ erpc_status_t MUTransport::send(MessageBuffer *message) return status; } +bool MUTransport::hasMessage(void) +{ + return m_newMessage; +} + extern "C" { #if ERPC_TRANSPORT_MU_USE_MCMGR diff --git a/erpc_c/transports/erpc_mu_transport.hpp b/erpc_c/transports/erpc_mu_transport.hpp index 16a819e1..2c3602ec 100644 --- a/erpc_c/transports/erpc_mu_transport.hpp +++ b/erpc_c/transports/erpc_mu_transport.hpp @@ -127,7 +127,7 @@ class MUTransport : public Transport * * @return kErpcStatus_Success */ - virtual erpc_status_t receive(MessageBuffer *message); + virtual erpc_status_t receive(MessageBuffer *message) override; /*! * @brief Function to send prepared message. @@ -137,7 +137,7 @@ class MUTransport : public Transport * @retval kErpcStatus_SendFailed Failed to send message buffer. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t send(MessageBuffer *message) override; /*! * @brief Function to check if is new message to receive. @@ -146,7 +146,7 @@ class MUTransport : public Transport * * @return True if exist new message, else false. */ - virtual bool hasMessage(void) { return m_newMessage; } + virtual bool hasMessage(void) override; #if ERPC_TRANSPORT_MU_USE_MCMGR /*! diff --git a/erpc_c/transports/erpc_rpmsg_linux_transport.hpp b/erpc_c/transports/erpc_rpmsg_linux_transport.hpp index ce13725c..b66dc8ab 100644 --- a/erpc_c/transports/erpc_rpmsg_linux_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_linux_transport.hpp @@ -56,7 +56,7 @@ class RPMsgLinuxTransport : public Transport * @retval kErpcStatus_Success When message was received successfully. * @retval kErpcStatus_Fail When message wasn't received successfully. */ - virtual erpc_status_t receive(MessageBuffer *message); + virtual erpc_status_t receive(MessageBuffer *message) override; /*! * @brief This function sends the eRPC messages. @@ -66,7 +66,7 @@ class RPMsgLinuxTransport : public Transport * @retval kErpcStatus_Success When message was sent successfully. * @retval kErpcStatus_Fail When message wasn't sent successfully. */ - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t send(MessageBuffer *message) override; private: RPMsgEndpoint *m_endPoint; /*!< Object operating with endpoints. */ diff --git a/erpc_c/transports/erpc_rpmsg_lite_base_transport.hpp b/erpc_c/transports/erpc_rpmsg_lite_base.hpp similarity index 87% rename from erpc_c/transports/erpc_rpmsg_lite_base_transport.hpp rename to erpc_c/transports/erpc_rpmsg_lite_base.hpp index 32433d52..bc30c4dc 100755 --- a/erpc_c/transports/erpc_rpmsg_lite_base_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_lite_base.hpp @@ -8,15 +8,14 @@ * SPDX-License-Identifier: BSD-3-Clause */ -#ifndef _EMBEDDED_RPC__RPMSG_LITE_BASE_TRANSPORT_H_ -#define _EMBEDDED_RPC__RPMSG_LITE_BASE_TRANSPORT_H_ +#ifndef _EMBEDDED_RPC__RPMSG_LITE_BASE_H_ +#define _EMBEDDED_RPC__RPMSG_LITE_BASE_H_ #include "erpc_config_internal.h" -#include "erpc_transport.hpp" extern "C" { -#include "rpmsg_lite.h" #include "rpmsg_env_specific.h" +#include "rpmsg_lite.h" } #if ERPC_ALLOCATION_POLICY == ERPC_ALLOCATION_POLICY_STATIC @@ -47,13 +46,12 @@ namespace erpc { * @ingroup rpmsg_lite_transport * @ingroup rpmsg_lite_rtos_transport */ -class RPMsgBaseTransport : public Transport +class RPMsgBase { public: - RPMsgBaseTransport(void) - : Transport(){}; + RPMsgBase(void){}; - virtual ~RPMsgBaseTransport(void) {} + virtual ~RPMsgBase(void) {} /*! * @brief This function returns pointer to instance of RPMSG lite @@ -82,4 +80,4 @@ class RPMsgBaseTransport : public Transport /*! @} */ -#endif // _EMBEDDED_RPC__RPMSG_LITE_BASE_TRANSPORT_H_ +#endif // _EMBEDDED_RPC__RPMSG_LITE_BASE_H_ diff --git a/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.cpp b/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.cpp index 76858d91..8eb1350b 100644 --- a/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.cpp +++ b/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.cpp @@ -9,6 +9,7 @@ */ #include "erpc_rpmsg_lite_rtos_transport.hpp" + #include "erpc_config_internal.h" extern "C" { @@ -20,15 +21,16 @@ using namespace erpc; //////////////////////////////////////////////////////////////////////////////// // Variables //////////////////////////////////////////////////////////////////////////////// -uint8_t RPMsgBaseTransport::s_initialized = 0U; -struct rpmsg_lite_instance *RPMsgBaseTransport::s_rpmsg; +uint8_t RPMsgBase::s_initialized = 0U; +struct rpmsg_lite_instance *RPMsgBase::s_rpmsg; //////////////////////////////////////////////////////////////////////////////// // Code //////////////////////////////////////////////////////////////////////////////// RPMsgRTOSTransport::RPMsgRTOSTransport(void) -: RPMsgBaseTransport() +: RPMsgBase() +, Transport() , m_rdev(NULL) , m_app_rp_chnl(NULL) , m_dst_addr(0) @@ -71,17 +73,6 @@ RPMsgRTOSTransport::~RPMsgRTOSTransport(void) } } -void RPMsgRTOSTransport::setCrc16(Crc16 *crcImpl) -{ - erpc_assert(crcImpl != NULL); - m_crcImpl = crcImpl; -} - -Crc16 *RPMsgRTOSTransport::getCrc16(void) -{ - return m_crcImpl; -} - erpc_status_t RPMsgRTOSTransport::init(uint32_t src_addr, uint32_t dst_addr, void *base_address, uint32_t length, uint32_t rpmsg_link_id) { @@ -288,3 +279,19 @@ erpc_status_t RPMsgRTOSTransport::send(MessageBuffer *message) return status; } + +bool RPMsgRTOSTransport::hasMessage(void) +{ + return ((rpmsg_queue_get_current_size(m_rpmsg_queue) > 0) ? true : false); +} + +void RPMsgRTOSTransport::setCrc16(Crc16 *crcImpl) +{ + erpc_assert(crcImpl != NULL); + m_crcImpl = crcImpl; +} + +Crc16 *RPMsgRTOSTransport::getCrc16(void) +{ + return m_crcImpl; +} diff --git a/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.hpp b/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.hpp index f237d0b0..8bbd6547 100644 --- a/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_lite_rtos_transport.hpp @@ -12,7 +12,8 @@ #include "erpc_crc16.hpp" #include "erpc_message_buffer.hpp" -#include "erpc_rpmsg_lite_base_transport.hpp" +#include "erpc_rpmsg_lite_base.hpp" +#include "erpc_transport.hpp" extern "C" { #include "rpmsg_lite.h" @@ -39,7 +40,7 @@ namespace erpc { * * @ingroup rpmsg_lite_rtos_transport */ -class RPMsgRTOSTransport : public RPMsgBaseTransport +class RPMsgRTOSTransport : public Transport, public RPMsgBase { public: /*! @@ -96,7 +97,7 @@ class RPMsgRTOSTransport : public RPMsgBaseTransport * @retval kErpcStatus_ReceiveFailed Failed to receive message buffer. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t receive(MessageBuffer *message); + virtual erpc_status_t receive(MessageBuffer *message) override; /*! * @brief Function to send prepared message. @@ -106,29 +107,30 @@ class RPMsgRTOSTransport : public RPMsgBaseTransport * @retval kErpcStatus_SendFailed Failed to send message buffer. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t send(MessageBuffer *message) override; + + /*! + * @brief Function to check if is message in receive queue and wait for processing. + * + * This function should be called before function receive() to avoid waiting for new message. + * + * @return True if exist received message, else false. + */ + virtual bool hasMessage(void) override; /*! * @brief This functions sets the CRC-16 implementation. * * @param[in] crcImpl Object containing crc-16 compute function. */ - virtual void setCrc16(Crc16 *crcImpl); + virtual void setCrc16(Crc16 *crcImpl) override; /*! * @brief This functions gets the CRC-16 object. * * @return Crc16* Pointer to CRC-16 object containing crc-16 compute function. */ - virtual Crc16 *getCrc16(void); - /*! - * @brief Function to check if is message in receive queue and wait for processing. - * - * This function should be called before function receive() to avoid waiting for new message. - * - * @return True if exist received message, else false. - */ - virtual bool hasMessage(void) { return ((rpmsg_queue_get_current_size(m_rpmsg_queue) > 0) ? true : false); } + virtual Crc16 *getCrc16(void) override; protected: /* Remote device */ diff --git a/erpc_c/transports/erpc_rpmsg_lite_transport.cpp b/erpc_c/transports/erpc_rpmsg_lite_transport.cpp index 3211bc75..729c50ad 100644 --- a/erpc_c/transports/erpc_rpmsg_lite_transport.cpp +++ b/erpc_c/transports/erpc_rpmsg_lite_transport.cpp @@ -20,8 +20,8 @@ using namespace erpc; //////////////////////////////////////////////////////////////////////////////// // Variables //////////////////////////////////////////////////////////////////////////////// -uint8_t RPMsgBaseTransport::s_initialized = 0U; -struct rpmsg_lite_instance *RPMsgBaseTransport::s_rpmsg = NULL; +uint8_t RPMsgBase::s_initialized = 0U; +struct rpmsg_lite_instance *RPMsgBase::s_rpmsg = NULL; //////////////////////////////////////////////////////////////////////////////// // Code @@ -40,7 +40,8 @@ int32_t RPMsgTransport::rpmsg_read_cb(void *payload, uint32_t payload_len, uint3 } RPMsgTransport::RPMsgTransport(void) -: RPMsgBaseTransport() +: RPMsgBase() +, Transport() , m_dst_addr(0) , m_rpmsg_ept(NULL) , m_crcImpl(NULL) @@ -72,17 +73,6 @@ RPMsgTransport::~RPMsgTransport(void) } } -void RPMsgTransport::setCrc16(Crc16 *crcImpl) -{ - erpc_assert(crcImpl != NULL); - m_crcImpl = crcImpl; -} - -Crc16 *RPMsgTransport::getCrc16(void) -{ - return m_crcImpl; -} - erpc_status_t RPMsgTransport::init(uint32_t src_addr, uint32_t dst_addr, void *base_address, uint32_t length, uint32_t rpmsg_link_id) { @@ -227,3 +217,19 @@ erpc_status_t RPMsgTransport::send(MessageBuffer *message) return (ret_val != RL_SUCCESS) ? kErpcStatus_SendFailed : kErpcStatus_Success; } + +bool RPMsgTransport::hasMessage(void) +{ + return ((0UL < m_messageQueue.size()) ? true : false); +} + +void RPMsgTransport::setCrc16(Crc16 *crcImpl) +{ + erpc_assert(crcImpl != NULL); + m_crcImpl = crcImpl; +} + +Crc16 *RPMsgTransport::getCrc16(void) +{ + return m_crcImpl; +} diff --git a/erpc_c/transports/erpc_rpmsg_lite_transport.hpp b/erpc_c/transports/erpc_rpmsg_lite_transport.hpp index 6537eae6..78738a8f 100644 --- a/erpc_c/transports/erpc_rpmsg_lite_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_lite_transport.hpp @@ -13,8 +13,9 @@ #include "erpc_config_internal.h" #include "erpc_crc16.hpp" #include "erpc_message_buffer.hpp" -#include "erpc_rpmsg_lite_base_transport.hpp" +#include "erpc_rpmsg_lite_base.hpp" #include "erpc_static_queue.hpp" +#include "erpc_transport.hpp" extern "C" { #include "rpmsg_lite.h" @@ -40,7 +41,7 @@ namespace erpc { * * @ingroup rpmsg_lite_transport */ -class RPMsgTransport : public RPMsgBaseTransport +class RPMsgTransport : public Transport, public RPMsgBase { public: /*! @@ -100,7 +101,7 @@ class RPMsgTransport : public RPMsgBaseTransport * * @return kErpcStatus_Success */ - virtual erpc_status_t receive(MessageBuffer *message); + virtual erpc_status_t receive(MessageBuffer *message) override; /*! * @brief Function to send prepared message. @@ -110,29 +111,30 @@ class RPMsgTransport : public RPMsgBaseTransport * @retval kErpcStatus_SendFailed Failed to send message buffer. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t send(MessageBuffer *message) override; + + /*! + * @brief Function to check if is message in receive queue and wait for processing. + * + * This function should be called before function receive() to avoid waiting for new message. + * + * @return True if exist received message, else false. + */ + virtual bool hasMessage(void) override; /*! * @brief This functions sets the CRC-16 implementation. * * @param[in] crcImpl Object containing crc-16 compute function. */ - virtual void setCrc16(Crc16 *crcImpl); + virtual void setCrc16(Crc16 *crcImpl) override; /*! * @brief This functions gets the CRC-16 object. * * @return Crc16* Pointer to CRC-16 object containing crc-16 compute function. */ - virtual Crc16 *getCrc16(void); - /*! - * @brief Function to check if is message in receive queue and wait for processing. - * - * This function should be called before function receive() to avoid waiting for new message. - * - * @return True if exist received message, else false. - */ - virtual bool hasMessage(void) { return ((0UL < m_messageQueue.size()) ? true : false); } + virtual Crc16 *getCrc16(void) override; protected: /*! diff --git a/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.cpp b/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.cpp index 6b5c4522..e7450629 100644 --- a/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.cpp +++ b/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.cpp @@ -11,7 +11,6 @@ #include "erpc_rpmsg_tty_rtos_transport.hpp" #include "erpc_config_internal.h" -#include "erpc_framed_transport.hpp" extern "C" { #include "rpmsg_ns.h" @@ -23,19 +22,19 @@ using namespace std; //////////////////////////////////////////////////////////////////////////////// // Variables //////////////////////////////////////////////////////////////////////////////// -uint8_t RPMsgBaseTransport::s_initialized = 0U; -struct rpmsg_lite_instance *RPMsgBaseTransport::s_rpmsg; +uint8_t RPMsgBase::s_initialized = 0U; +struct rpmsg_lite_instance *RPMsgBase::s_rpmsg; //////////////////////////////////////////////////////////////////////////////// // Code //////////////////////////////////////////////////////////////////////////////// RPMsgTTYRTOSTransport::RPMsgTTYRTOSTransport(void) -: RPMsgBaseTransport() +: FramedTransport() +, RPMsgBase() , m_dst_addr(0) , m_rpmsg_queue(NULL) , m_rpmsg_ept(NULL) -, m_crcImpl(NULL) { } @@ -72,17 +71,6 @@ RPMsgTTYRTOSTransport::~RPMsgTTYRTOSTransport(void) } } -void RPMsgTTYRTOSTransport::setCrc16(Crc16 *crcImpl) -{ - erpc_assert(crcImpl != NULL); - m_crcImpl = crcImpl; -} - -Crc16 *RPMsgTTYRTOSTransport::getCrc16(void) -{ - return m_crcImpl; -} - erpc_status_t RPMsgTTYRTOSTransport::init(uint32_t src_addr, uint32_t dst_addr, void *base_address, uint32_t length, uint32_t rpmsg_link_id) { @@ -252,101 +240,65 @@ erpc_status_t RPMsgTTYRTOSTransport::init(uint32_t src_addr, uint32_t dst_addr, return status; } -erpc_status_t RPMsgTTYRTOSTransport::receive(MessageBuffer *message) +erpc_status_t RPMsgTTYRTOSTransport::underlyingSend(MessageBuffer *message, uint32_t size, uint32_t offset) { - erpc_status_t status = kErpcStatus_Success; - FramedTransport::Header h; - char *buf = NULL; - char *buf2 = NULL; - uint32_t length = 0; - int32_t ret_val = rpmsg_queue_recv_nocopy(s_rpmsg, m_rpmsg_queue, &m_dst_addr, &buf, &length, RL_BLOCK); - uint16_t computedCrc; - - erpc_assert((m_crcImpl != NULL) && ("Uninitialized Crc16 object." != NULL)); + erpc_status_t status; + int32_t ret_val; + ret_val = rpmsg_lite_send_nocopy(s_rpmsg, m_rpmsg_ept, m_dst_addr, &message->get()[offset], size); if (ret_val == RL_SUCCESS) { - erpc_assert(buf != NULL); - if (length < sizeof(h)) - { - status = kErpcStatus_ReceiveFailed; - } - if (status == kErpcStatus_Success) - { - static_cast(memcpy(reinterpret_cast(&h), buf, sizeof(h))); - /* If header and body is sent in two packets, we need call receive again to get body part. */ - if (length == sizeof(h)) - { - ret_val = rpmsg_queue_recv_nocopy(s_rpmsg, m_rpmsg_queue, &m_dst_addr, &buf2, &length, RL_BLOCK); - if (ret_val == RL_SUCCESS) - { - erpc_assert(buf2 != NULL); - erpc_assert((length + sizeof(h)) <= ERPC_DEFAULT_BUFFER_SIZE); - static_cast(memcpy(&buf[sizeof(h)], buf2, length)); - } - static_cast(rpmsg_lite_release_rx_buffer(s_rpmsg, buf2)); - } - else - { - length -= sizeof(h); /* offset for MessageBuffer */ - } - buf = &buf[sizeof(h)]; /* offset for MessageBuffer */ - } + + message->set(NULL, 0); + status = kErpcStatus_Success; } - if (status == kErpcStatus_Success) + else { - if (ret_val == RL_SUCCESS) - { - message->set(reinterpret_cast(buf), length); - - /* Verify CRC. */ - computedCrc = m_crcImpl->computeCRC16(reinterpret_cast(buf), h.m_messageSize); - if (computedCrc != h.m_crc) - { - status = kErpcStatus_CrcCheckFailed; - } - else - { - message->setUsed(h.m_messageSize); - } - } - else - { - status = kErpcStatus_ReceiveFailed; - } + status = kErpcStatus_SendFailed; } return status; } -erpc_status_t RPMsgTTYRTOSTransport::send(MessageBuffer *message) +erpc_status_t RPMsgTTYRTOSTransport::underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset) { - erpc_status_t status = kErpcStatus_Success; - FramedTransport::Header h; - uint8_t *buf = message->get(); - uint32_t length = message->getLength(); - uint32_t used = message->getUsed(); - int32_t ret_val; - - erpc_assert((m_crcImpl != NULL) && ("Uninitialized Crc16 object." != NULL)); - message->set(NULL, 0); - - h.m_crc = m_crcImpl->computeCRC16(buf, used); - h.m_messageSize = used; - - static_cast(memcpy(&buf[-sizeof(h)], (uint8_t *)&h, sizeof(h))); - - ret_val = rpmsg_lite_send_nocopy(s_rpmsg, m_rpmsg_ept, m_dst_addr, &buf[-sizeof(h)], used + sizeof(h)); + char *buf = NULL; + uint32_t length = 0; + int32_t ret_val = rpmsg_queue_recv_nocopy(s_rpmsg, m_rpmsg_queue, &m_dst_addr, &buf, &length, RL_BLOCK); + erpc_status_t status; if (ret_val == RL_SUCCESS) { + if (offset == 0) + { + message->set(reinterpret_cast(buf), length); + message->setUsed(length); + } + else + { + erpc_assert(buf != NULL); + erpc_assert((length + offset) <= ERPC_DEFAULT_BUFFER_SIZE); + static_cast(memcpy(&message->get()[offset], buf, length)); + message->setUsed(length + offset); + static_cast(rpmsg_lite_release_rx_buffer(s_rpmsg, buf)); + } status = kErpcStatus_Success; } else { - message->set(buf, length); - message->setUsed(used); - status = kErpcStatus_SendFailed; + status = kErpcStatus_ReceiveFailed; } return status; } + +erpc_status_t RPMsgTTYRTOSTransport::underlyingReceive(uint8_t *data, uint32_t size) +{ + // unused as underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset) + return kErpcStatus_ReceiveFailed; +} + +erpc_status_t RPMsgTTYRTOSTransport::underlyingSend(const uint8_t *data, uint32_t size) +{ + // unused as underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset) + return kErpcStatus_SendFailed; +} diff --git a/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.hpp b/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.hpp index 30d3ee02..5d97ae49 100644 --- a/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_tty_rtos_transport.hpp @@ -11,8 +11,9 @@ #define _EMBEDDED_RPC__RPMSG_LITE_TTY_RTOS_TRANSPORT_H_ #include "erpc_crc16.hpp" +#include "erpc_framed_transport.hpp" #include "erpc_message_buffer.hpp" -#include "erpc_rpmsg_lite_base_transport.hpp" +#include "erpc_rpmsg_lite_base.hpp" extern "C" { #include "rpmsg_lite.h" @@ -40,7 +41,7 @@ namespace erpc { * * @ingroup rpmsg_tty_rtos_transport */ -class RPMsgTTYRTOSTransport : public RPMsgBaseTransport +class RPMsgTTYRTOSTransport : public FramedTransport, public RPMsgBase { public: /*! @@ -94,48 +95,63 @@ class RPMsgTTYRTOSTransport : public RPMsgBaseTransport virtual erpc_status_t init(uint32_t src_addr, uint32_t dst_addr, void *base_address, uint32_t rpmsg_link_id, void (*ready_cb)(void), char *nameservice_name); +protected: + uint32_t m_dst_addr; /*!< Destination address used by rpmsg. */ + rpmsg_queue_handle m_rpmsg_queue; /*!< Handle of RPMsg queue. */ + struct rpmsg_lite_endpoint *m_rpmsg_ept; /*!< Pointer to RPMsg Lite Endpoint structure. */ + + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! - * @brief Store incoming message to message buffer. + * @brief Adds ability to framed transport to overwrite MessageBuffer when receiving data. * - * In loop while no message come. + * Usually we don't want to do that. * - * @param[in] message Message buffer, to which will be stored incoming - * message. + * @param message MessageBuffer to send. + * @param size size of message to send. + * @param offset data start address offset * - * @retval kErpcStatus_ReceiveFailed Failed to receive message buffer. - * @retval kErpcStatus_Success Successfully received all data. + * @return erpc_status_t kErpcStatus_Success when it finished successful otherwise error. */ - virtual erpc_status_t receive(MessageBuffer *message); + virtual erpc_status_t underlyingReceive(MessageBuffer *message, uint32_t size, uint32_t offset) override; /*! - * @brief Function to send prepared message. + * @brief Adds ability to framed transport to overwrite MessageBuffer when sending data. + * + * Usually we don't want to do that. * - * @param[in] message Pass message buffer to send. + * @param message MessageBuffer to send. + * @param size size of message to send. + * @param offset data start address offset * - * @retval kErpcStatus_SendFailed Failed to send message buffer. - * @retval kErpcStatus_Success Successfully sent all data. + * @return erpc_status_t kErpcStatus_Success when it finished successful otherwise error. */ - virtual erpc_status_t send(MessageBuffer *message); + virtual erpc_status_t underlyingSend(MessageBuffer *message, uint32_t size, uint32_t offset) override; /*! - * @brief This functions sets the CRC-16 implementation. + * @brief This function read data. * - * @param[in] crcImpl Object containing crc-16 compute function. + * @param[inout] data Preallocated buffer for receiving data. + * @param[in] size Size of data to read. + * + * @retval #kErpcStatus_Success When data was read successfully. + * @retval #kErpcStatus_ReceiveFailed When reading data ends with error. + * @retval #kErpcStatus_ConnectionClosed Peer closed the connection. */ - virtual void setCrc16(Crc16 *crcImpl); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! - * @brief This functions gets the CRC-16 object. + * @brief This function writes data. + * + * @param[in] data Buffer to send. + * @param[in] size Size of data to send. * - * @return Crc16* Pointer to CRC-16 object containing crc-16 compute function. + * @retval #kErpcStatus_Success When data was written successfully. + * @retval #kErpcStatus_SendFailed When writing data ends with error. + * @retval #kErpcStatus_ConnectionClosed Peer closed the connection. */ - virtual Crc16 * getCrc16(void) override; - -protected: - uint32_t m_dst_addr; /*!< Destination address used by rpmsg. */ - rpmsg_queue_handle m_rpmsg_queue; /*!< Handle of RPMsg queue. */ - struct rpmsg_lite_endpoint *m_rpmsg_ept; /*!< Pointer to RPMsg Lite Endpoint structure. */ - Crc16 *m_crcImpl; //!< CRC object. + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_serial_transport.hpp b/erpc_c/transports/erpc_serial_transport.hpp index ea0033bb..6b41ae11 100644 --- a/erpc_c/transports/erpc_serial_transport.hpp +++ b/erpc_c/transports/erpc_serial_transport.hpp @@ -65,27 +65,30 @@ class SerialTransport : public FramedTransport erpc_status_t init(uint8_t vtime, uint8_t vmin); private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! - * @brief Write data to Serial peripheral. + * @brief Receive data from Serial peripheral. * - * @param[in] data Buffer to send. - * @param[in] size Size of data to send. + * @param[inout] data Preallocated buffer for receiving data. + * @param[in] size Size of data to read. * * @retval kErpcStatus_ReceiveFailed Serial failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! - * @brief Receive data from Serial peripheral. + * @brief Write data to Serial peripheral. * - * @param[inout] data Preallocated buffer for receiving data. - * @param[in] size Size of data to read. + * @param[in] data Buffer to send. + * @param[in] size Size of data to send. * * @retval kErpcStatus_ReceiveFailed Serial failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; private: int m_serialHandle; /*!< Serial handle id. */ diff --git a/erpc_c/transports/erpc_spi_master_transport.hpp b/erpc_c/transports/erpc_spi_master_transport.hpp index e90e27a2..e2de9bae 100644 --- a/erpc_c/transports/erpc_spi_master_transport.hpp +++ b/erpc_c/transports/erpc_spi_master_transport.hpp @@ -65,6 +65,9 @@ class SpiMasterTransport : public FramedTransport uint32_t m_srcClock_Hz; /*!< Source clock of SPI peripheral used in this transport layer */ private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from SPI peripheral. * @@ -74,7 +77,7 @@ class SpiMasterTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed SPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to SPI peripheral. @@ -85,7 +88,7 @@ class SpiMasterTransport : public FramedTransport * @retval kErpcStatus_SendFailed SPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_spi_slave_transport.hpp b/erpc_c/transports/erpc_spi_slave_transport.hpp index bc4e22b9..865cb2b9 100644 --- a/erpc_c/transports/erpc_spi_slave_transport.hpp +++ b/erpc_c/transports/erpc_spi_slave_transport.hpp @@ -79,6 +79,9 @@ class SpiSlaveTransport : public FramedTransport #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from SPI peripheral. * @@ -88,7 +91,7 @@ class SpiSlaveTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed SPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to SPI peripheral. @@ -99,7 +102,7 @@ class SpiSlaveTransport : public FramedTransport * @retval kErpcStatus_SendFailed SPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_spidev_master_transport.hpp b/erpc_c/transports/erpc_spidev_master_transport.hpp index 1af54c34..354af858 100644 --- a/erpc_c/transports/erpc_spidev_master_transport.hpp +++ b/erpc_c/transports/erpc_spidev_master_transport.hpp @@ -56,6 +56,9 @@ class SpidevMasterTransport : public FramedTransport uint32_t m_speed_Hz; /*!< SPI clock speed in Hz. */ private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from SPI peripheral. * @@ -65,7 +68,7 @@ class SpidevMasterTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed SPI failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to SPI peripheral. @@ -76,7 +79,7 @@ class SpidevMasterTransport : public FramedTransport * @retval kErpcStatus_SendFailed SPI failed to send data. * @retval kErpcStatus_Success Successfully sent all data. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_tcp_transport.hpp b/erpc_c/transports/erpc_tcp_transport.hpp index 8bb74d4f..1e171fbf 100644 --- a/erpc_c/transports/erpc_tcp_transport.hpp +++ b/erpc_c/transports/erpc_tcp_transport.hpp @@ -97,6 +97,10 @@ class TCPTransport : public FramedTransport Thread m_serverThread; /*!< Pointer to server thread. */ bool m_runServer; /*!< Thread is executed while this is true. */ + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + + /*! * @brief This function connect client to the server. * @@ -115,7 +119,7 @@ class TCPTransport : public FramedTransport * @retval #kErpcStatus_ReceiveFailed When reading data ends with error. * @retval #kErpcStatus_ConnectionClosed Peer closed the connection. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief This function writes data. @@ -127,7 +131,7 @@ class TCPTransport : public FramedTransport * @retval #kErpcStatus_SendFailed When writing data ends with error. * @retval #kErpcStatus_ConnectionClosed Peer closed the connection. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; /*! * @brief Server thread function. diff --git a/erpc_c/transports/erpc_uart_cmsis_transport.hpp b/erpc_c/transports/erpc_uart_cmsis_transport.hpp index 42e5e831..04fb5751 100644 --- a/erpc_c/transports/erpc_uart_cmsis_transport.hpp +++ b/erpc_c/transports/erpc_uart_cmsis_transport.hpp @@ -83,6 +83,9 @@ class UartTransport : public FramedTransport Semaphore m_txSemaphore; /*!< Semaphore used by RTOS to block task until the sending is not complete */ #endif private: + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from UART peripheral. * @@ -92,7 +95,7 @@ class UartTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed UART failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to UART peripheral. @@ -102,7 +105,7 @@ class UartTransport : public FramedTransport * * @retval kErpcStatus_Success Always returns success status. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_c/transports/erpc_usb_cdc_transport.hpp b/erpc_c/transports/erpc_usb_cdc_transport.hpp index ee4abf69..ccd7b5ab 100644 --- a/erpc_c/transports/erpc_usb_cdc_transport.hpp +++ b/erpc_c/transports/erpc_usb_cdc_transport.hpp @@ -96,6 +96,9 @@ class UsbCdcTransport : public FramedTransport uint8_t *m_usbRingBuffer; uint32_t m_usbRingBufferLength; + using FramedTransport::underlyingReceive; + using FramedTransport::underlyingSend; + /*! * @brief Receive data from USB CDC peripheral. * @@ -105,7 +108,7 @@ class UsbCdcTransport : public FramedTransport * @retval kErpcStatus_ReceiveFailed USB CDC failed to receive data. * @retval kErpcStatus_Success Successfully received all data. */ - virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size) override; /*! * @brief Write data to USB CDC peripheral. @@ -115,7 +118,7 @@ class UsbCdcTransport : public FramedTransport * * @retval kErpcStatus_Success Always returns success status. */ - virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size) override; }; } // namespace erpc diff --git a/erpc_python/erpc/transport.py b/erpc_python/erpc/transport.py index 725a0abb..00df5908 100644 --- a/erpc_python/erpc/transport.py +++ b/erpc_python/erpc/transport.py @@ -48,7 +48,7 @@ def receive(self): class FramedTransport(Transport): - HEADER_LEN = 4 + HEADER_LEN = 6 def __init__(self): super(FramedTransport, self).__init__() @@ -70,9 +70,12 @@ def send(self, message): try: self._sendLock.acquire() - crc = self._Crc16.computeCRC16(message) + crcBody = self._Crc16.computeCRC16(message) + messageLength = len(message) + crcHeader = self._Crc16.computeCRC16(bytearray(struct.pack('prepareServerBufferForSend(codec->getBuffer()); +{$serverIndent} {% if generateErrorChecks %}err = {% endif %}messageFactory->prepareServerBufferForSend(codec->getBufferRef(), transport->reserveHeaderSize()); {% if generateErrorChecks %} } @@ -126,7 +126,7 @@ extern bool nestingDetection; { {% endif -- generateErrorChecks %} {$serverIndent} // preparing codec for serializing data -{$serverIndent} codec->reset(); +{$serverIndent} codec->reset(transport->reserveHeaderSize()); {$serverIndent} // Build response message. {$serverIndent} codec->startWriteMessage(message_type_t::kReplyMessage, {$serverIDName}, {$functionIDName}, sequence); @@ -181,14 +181,14 @@ extern bool nestingDetection; {% for iface in group.interfaces %} {% for cb in iface.callbacksInt if (count(cb.callbacks) > 1) %} // Common function for serializing and deserializing callback functions of same type. -static erpc_status_t {$iface.interfaceClassName}_{$cb.name}_shim({$iface.interfaceClassName} *m_handler, uint32_t serviceID, uint32_t functionID, {$codecClass} * codec, MessageBufferFactory *messageFactory, uint32_t sequence); +static erpc_status_t {$iface.interfaceClassName}_{$cb.name}_shim({$iface.interfaceClassName} *m_handler, uint32_t serviceID, uint32_t functionID, {$codecClass} * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence); {% endfor %} {% endfor %} {% for iface in group.interfaces %} {% for cb in iface.callbacksInt if (count(cb.callbacks) > 1) %} // Common function for serializing and deserializing callback functions of same type. -static erpc_status_t {$iface.interfaceClassName}_{$cb.name}_shim({$iface.interfaceClassName} *m_handler, uint32_t serviceID, uint32_t functionID, {$codecClass} * codec, MessageBufferFactory *messageFactory, uint32_t sequence) +static erpc_status_t {$iface.interfaceClassName}_{$cb.name}_shim({$iface.interfaceClassName} *m_handler, uint32_t serviceID, uint32_t functionID, {$codecClass} * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence) { {$ serverShimCode(iface, "m_handler", cb.callbacksData, "serviceID", "functionID") >} } @@ -213,7 +213,7 @@ static erpc_status_t {$iface.interfaceClassName}_{$cb.name}_shim({$iface.interfa } // Call the correct server shim based on method unique ID. -erpc_status_t {$iface.serviceClassName}::handleInvocation(uint32_t methodId, uint32_t sequence, Codec * codec, MessageBufferFactory *messageFactory) +erpc_status_t {$iface.serviceClassName}::handleInvocation(uint32_t methodId, uint32_t sequence, Codec * codec, MessageBufferFactory *messageFactory, Transport * transport) { erpc_status_t erpcStatus; {% if codecClass != "Codec" %} @@ -224,7 +224,7 @@ erpc_status_t {$iface.serviceClassName}::handleInvocation(uint32_t methodId, uin {% for fn in iface.functions %} case {$iface.interfaceClassName}::{$getClassFunctionIdName(fn)}: { - erpcStatus = {$fn.name}_shim({%if codecClass == "Codec" %}codec{% else %}_codec{% endif %}, messageFactory, sequence); + erpcStatus = {$fn.name}_shim({%if codecClass == "Codec" %}codec{% else %}_codec{% endif %}, messageFactory, transport, sequence); break; } @@ -241,10 +241,10 @@ erpc_status_t {$iface.serviceClassName}::handleInvocation(uint32_t methodId, uin {% for fn in iface.functions %} // Server shim for {$fn.name} of {$iface.name} interface. -erpc_status_t {$iface.serviceClassName}::{$fn.name}_shim({$codecClass} * codec, MessageBufferFactory *messageFactory, uint32_t sequence) +erpc_status_t {$iface.serviceClassName}::{$fn.name}_shim({$codecClass} * codec, MessageBufferFactory *messageFactory, Transport * transport, uint32_t sequence) { {% if fn.isCallback %} - return {$iface.interfaceClassName}_{$fn.callbackFNameNoGroup}_shim(m_handler, {$iface.interfaceClassName}::m_serviceId, {$iface.interfaceClassName}::{$getClassFunctionIdName(fn)}, codec, messageFactory, sequence); + return {$iface.interfaceClassName}_{$fn.callbackFNameNoGroup}_shim(m_handler, {$iface.interfaceClassName}::m_serviceId, {$iface.interfaceClassName}::{$getClassFunctionIdName(fn)}, codec, messageFactory, transport, sequence); {% else -- fn.isCallback >%} {$ serverShimCode(iface, "m_handler", fn, iface.interfaceClassName & "::m_serviceId", iface.interfaceClassName & "::" & getClassFunctionIdName(fn)) >} {% endif -- fn.isCallback >%} diff --git a/erpcsniffer/src/Sniffer.cpp b/erpcsniffer/src/Sniffer.cpp index b517280c..585aaec5 100644 --- a/erpcsniffer/src/Sniffer.cpp +++ b/erpcsniffer/src/Sniffer.cpp @@ -64,7 +64,7 @@ erpc_status_t Sniffer::run() } Log::info("message received\n"); - m_codec->setBuffer(message); + m_codec->setBuffer(message, m_transport->reserveHeaderSize()); // Save time when message was received. time_t now = chrono::system_clock::to_time_t(currentTime); diff --git a/test/common/gtest/gtest.h b/test/common/gtest/gtest.h index e07c3371..ef9a6231 100644 --- a/test/common/gtest/gtest.h +++ b/test/common/gtest/gtest.h @@ -9910,6 +9910,8 @@ linked_ptr make_linked_ptr(T* ptr) { #if GTEST_OS_BARE_METAL #include +#else +#include #endif #if GTEST_HAS_STD_TUPLE_ diff --git a/test/common/unit_test_tcp_arbitrator_client.cpp b/test/common/unit_test_tcp_arbitrator_client.cpp index f29664d3..19c5f56a 100644 --- a/test/common/unit_test_tcp_arbitrator_client.cpp +++ b/test/common/unit_test_tcp_arbitrator_client.cpp @@ -64,7 +64,6 @@ void increaseWaitQuit() { Mutex::Guard lock(waitQuitMutex); waitQuit++; - Mutex::Guard unlock(waitQuitMutex); } void runServer(void *arg) @@ -90,7 +89,6 @@ void runClient(void *arg) { break; } - Mutex::Guard unlock(waitQuitMutex); } // send to ERPC second (server) app ready to quit state @@ -176,7 +174,6 @@ int main(int argc, char **argv) { break; } - Mutex::Guard unlock(waitQuitMutex); } // Close transport diff --git a/test/common/unit_test_tcp_arbitrator_server.cpp b/test/common/unit_test_tcp_arbitrator_server.cpp index b1956165..bf812acf 100644 --- a/test/common/unit_test_tcp_arbitrator_server.cpp +++ b/test/common/unit_test_tcp_arbitrator_server.cpp @@ -63,7 +63,6 @@ void increaseWaitQuit() { Mutex::Guard lock(waitQuitMutex); waitQuit++; - Mutex::Guard unlock(waitQuitMutex); } void runServer(void *arg) @@ -84,14 +83,14 @@ void runClient(void *arg) while (true) { isTestPassing = testClient(); - Mutex::Guard lock(waitQuitMutex); - if (waitQuit != 0 || isTestPassing != 0 || stopTest != 0) { - enableFirstSide(); - Mutex::Guard unlock(waitQuitMutex); - break; + Mutex::Guard lock(waitQuitMutex); + if (waitQuit != 0 || isTestPassing != 0 || stopTest != 0) + { + enableFirstSide(); + break; + } } - Mutex::Guard unlock(waitQuitMutex); } while (true) @@ -101,7 +100,6 @@ void runClient(void *arg) { break; } - Mutex::Guard unlock(waitQuitMutex); } // send to ERPC first (client) app ready to quit state @@ -166,7 +164,6 @@ int main(int argc, char **argv) { break; } - Mutex::Guard unlock(waitQuitMutex); } // Close transport