Merge branch 'develop' of github.com:EmbeddedRPC/erpc into feature/staticRPMSGApi

Author: Hadatko

.github/workflows/greetings.yml

@@ -5,6 +5,9 @@ on: [pull_request, issues]
 jobs:
   greeting:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
     steps:
     - uses: actions/first-interaction@v1
       with:

LICENSE

@@ -2,4 +2,36 @@ Copyright 2014-2016 Freescale Semiconductor, Inc.
 Copyright 2016-2021 NXP
 All rights reserved.
 
-SPDX-License-Identifier: BSD-3-Clause
+The BSD 3 Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -92,6 +92,14 @@ To get the board list with multicore support (eRPC included) use filtering based
 <MCUXpressoSDK_install_dir>/boards/<board_name>/multiprocessor_examples for eRPC multiprocessor examples (UART or SPI transports used).<br>
 eRPC examples use 'erpc_' name prefix. 
 
+## References
+
+This section provides links to interesting erpc-based projects, articles, blogs or guides:
+
+* [erpc (EmbeddedRPC) getting started notes](https://programmersought.com/article/37585084512/)
+* [ERPC Linux Local Environment Construction and Use](https://programmersought.com/article/88827920353/)
+* [The New Wio Terminal eRPC Firmware](https://www.hackster.io/Salmanfarisvp/the-new-wio-terminal-erpc-firmware-bfd8bd)
+
 ## Directories
 
 `doc` - Documentation.

erpc_c/Makefile

@@ -70,6 +70,7 @@ SOURCES += 	$(ERPC_C_ROOT)/infra/erpc_arbitrated_client_manager.cpp \
 			$(ERPC_C_ROOT)/setup/erpc_setup_mbf_static.cpp \
 			$(ERPC_C_ROOT)/setup/erpc_server_setup.cpp \
 			$(ERPC_C_ROOT)/setup/erpc_setup_serial.cpp \
+			$(ERPC_C_ROOT)/setup/erpc_setup_tcp.cpp \
 			$(ERPC_C_ROOT)/transports/erpc_inter_thread_buffer_transport.cpp \
 			$(ERPC_C_ROOT)/transports/erpc_serial_transport.cpp \
 			$(ERPC_C_ROOT)/transports/erpc_tcp_transport.cpp

erpc_c/infra/erpc_manually_constructed.h

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2014, Freescale Semiconductor, Inc.
  * Copyright 2016 NXP
+ * Copyright 2021 ACRIOS Systems s.r.o.
  * All rights reserved.
  *
  *
@@ -49,53 +50,93 @@ class ManuallyConstructed
 public:
     //! @name Object access
     //@{
-    T *get(void) { return reinterpret_cast<T *>(&m_storage); }
-    const T *get(void) const { return reinterpret_cast<const T *>(&m_storage); }
+    T *get(void) { return (m_isConstructed) ? reinterpret_cast<T *>(&m_storage) : nullptr; }
+    const T *get(void) const { return (m_isConstructed) ? reinterpret_cast<const T *>(&m_storage) : nullptr; }
     T *operator->(void) { return get(); }
     const T *operator->(void) const { return get(); }
-    T &operator*(void) { return *get(); }
-    const T &operator*(void) const { return *get(); }
+    T &operator*(void)
+    {
+        if (m_isConstructed)
+        {
+            return *get();
+        }
+        else
+        {
+            memset(&m_storage, 0, sizeof(m_storage) * 8);
+            return reinterpret_cast<T &>(m_storage);
+        };
+    }
+    const T &operator*(void) const
+    {
+        if (m_isConstructed)
+        {
+            return *get();
+        }
+        else
+        {
+            memset(&m_storage, 0, sizeof(m_storage) * 8);
+            return reinterpret_cast<const T &>(m_storage);
+        };
+    }
     operator T *(void) { return get(); }
     operator const T *(void) const { return get(); }
     //@}
 
     //! @name Explicit construction methods
     //@{
-    void construct(void) { new (m_storage) T; }
+    void construct(void)
+    {
+        destroy();
+        new (m_storage) T;
+        m_isConstructed = true;
+    }
+
     template <typename A1>
     void construct(const A1 &a1)
     {
+        destroy();
         new (m_storage) T(a1);
+        m_isConstructed = true;
     }
 
     template <typename A1, typename A2>
     void construct(const A1 &a1, const A2 &a2)
     {
+        destroy();
         new (m_storage) T(a1, a2);
+        m_isConstructed = true;
     }
 
     template <typename A1, typename A2, typename A3>
     void construct(const A1 &a1, const A2 &a2, const A3 &a3)
     {
+        destroy();
         new (m_storage) T(a1, a2, a3);
+        m_isConstructed = true;
     }
 
     template <typename A1, typename A2, typename A3, typename A4>
     void construct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
     {
+        destroy();
         new (m_storage) T(a1, a2, a3, a4);
+        m_isConstructed = true;
     }
 
     template <typename A1, typename A2, typename A3, typename A4, typename A5>
     void construct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
     {
+        destroy();
         new (m_storage) T(a1, a2, a3, a4, a5);
+        m_isConstructed = true;
     }
 
     template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
     void construct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
     {
+        destroy();
         new (m_storage) T(a1, a2, a3, a4, a5, a6);
+        m_isConstructed = true;
     }
     //@}
 
@@ -104,7 +145,14 @@ class ManuallyConstructed
      *
      * Behavior is undefined if the objected was not previously initialized.
      */
-    void destroy(void) { get()->~T(); }
+    void destroy(void)
+    {
+        if (m_isConstructed)
+        {
+            get()->~T();
+            m_isConstructed = false;
+        }
+    }
 
 protected:
     /*!
@@ -113,6 +161,13 @@ class ManuallyConstructed
      * An array of uint64 is used to get 8-byte alignment.
      */
     uint64_t m_storage[(sizeof(T) + sizeof(uint64_t) - 1) / sizeof(uint64_t)];
+
+    /*!
+     * @brief Track construct/destruct calls.
+     *
+     * Based on this variable we can allow or forbid construct/destruct calls.
+     */
+    bool m_isConstructed = false;
 };
 
 } // namespace erpc

erpc_c/setup/erpc_arbitrated_client_setup.cpp

@@ -32,8 +32,8 @@ using namespace erpc;
 
 // global client variables
 static ManuallyConstructed<ArbitratedClientManager> s_client;
-extern ClientManager *g_client;
-ClientManager *g_client = NULL;
+ClientManager *g_client;
+#pragma weak g_client
 
 static ManuallyConstructed<BasicCodecFactory> s_codecFactory;
 static ManuallyConstructed<TransportArbitrator> s_arbitrator;

erpc_c/setup/erpc_client_setup.cpp

@@ -30,8 +30,8 @@ using namespace erpc;
 
 // global client variables
 static ManuallyConstructed<ClientManager> s_client;
-extern ClientManager *g_client;
-ClientManager *g_client = NULL;
+ClientManager *g_client;
+#pragma weak g_client
 static ManuallyConstructed<BasicCodecFactory> s_codecFactory;
 static ManuallyConstructed<Crc16> s_crc16;
 

erpc_c/setup/erpc_setup_mbf_static.cpp

@@ -22,8 +22,8 @@
 
 using namespace erpc;
 
-#define ERPC_BUFFER_SIZE_UINT8 ((ERPC_DEFAULT_BUFFER_SIZE + sizeof(uint64_t) - 1))
-#define ERPC_BUFFER_SIZE_UINT64 (ERPC_BUFFER_SIZE_UINT8 / sizeof(uint64_t))
+#define ERPC_BUFFER_SIZE_UINT64 \
+    ((ERPC_DEFAULT_BUFFER_SIZE + sizeof(uint64_t) - 1) / sizeof(uint64_t))
 
 ////////////////////////////////////////////////////////////////////////////////
 // Classes
@@ -43,8 +43,8 @@ class StaticMessageBufferFactory : public MessageBufferFactory
     : m_semaphore(1)
 #endif
     {
-        (void)memset(m_freeBufferBitmap, 0xff, ERPC_DEFAULT_BUFFERS_COUNT >> 3);
-        (void)memset(m_buffers, 0, ERPC_DEFAULT_BUFFERS_COUNT * ERPC_BUFFER_SIZE_UINT8);
+        (void)memset(m_freeBufferBitmap, 0xff, sizeof(m_freeBufferBitmap));
+        (void)memset(m_buffers, 0, sizeof(m_buffers));
     }
 
     /*!
@@ -112,8 +112,12 @@ class StaticMessageBufferFactory : public MessageBufferFactory
     }
 
 protected:
-    uint8_t m_freeBufferBitmap[(ERPC_DEFAULT_BUFFERS_COUNT >> 3U) + 1U];     /*!< Bitmat of used/not used buffers. */
-    uint64_t m_buffers[ERPC_DEFAULT_BUFFERS_COUNT][ERPC_BUFFER_SIZE_UINT64]; /*!< Static buffers. */
+    //! Bitmap representing which buffers are in use. A bit value of 1 means free and 0 means in
+    //! use.
+    uint8_t m_freeBufferBitmap[(ERPC_DEFAULT_BUFFERS_COUNT >> 3U) +
+                               (ERPC_DEFAULT_BUFFERS_COUNT % 8 ? 1U : 0U)];
+    //! Static buffers
+    uint64_t m_buffers[ERPC_DEFAULT_BUFFERS_COUNT][ERPC_BUFFER_SIZE_UINT64];
 #if !ERPC_THREADS_IS(NONE)
     Semaphore m_semaphore; /*!< Semaphore.*/
 #endif

erpc_c/transports/erpc_i2c_slave_transport.cpp

@@ -26,6 +26,8 @@ using namespace erpc;
 #error "Please define the ERPC_BOARD_I2C_INT_GPIO used to notify when the I2C Slave is ready to transmit"
 #endif
 
+#define I2C_SLAVE_TRANSPORT_ADDR_7BIT (0x7EU)
+
 ////////////////////////////////////////////////////////////////////////////////
 // Variables
 ////////////////////////////////////////////////////////////////////////////////
@@ -41,7 +43,7 @@ typedef struct i2c_clb_user_data
     uint8_t *rx_buffer;
     uint32_t rx_size;
 } I2C_CLB_USER_DATA, *I2C_CLB_USER_DATA_PTR;
-static I2C_CLB_USER_DATA volatile s_callback_user_data = { NULL, 0 };
+static volatile I2C_CLB_USER_DATA s_callback_user_data = { NULL, 0, NULL, 0 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // Code
@@ -112,18 +114,26 @@ static void I2C_SlaveUserCallback(I2C_Type *base, volatile i2c_slave_transfer_t
             /*  Update information for transmit process */
             transfer->txData = ((I2C_CLB_USER_DATA *)userData)->tx_buffer;
             transfer->txSize = ((I2C_CLB_USER_DATA *)userData)->tx_size;
+            transfer->rxData = NULL;
+            transfer->rxSize = 0;
             break;
 
         /* Setup the slave receive buffer */
         case kI2C_SlaveReceiveEvent:
             /*  Update information for received process */
             transfer->rxData = ((I2C_CLB_USER_DATA *)userData)->rx_buffer;
             transfer->rxSize = ((I2C_CLB_USER_DATA *)userData)->rx_size;
+            transfer->txData = NULL;
+            transfer->txSize = 0;
             break;
 
         /* The master has sent a stop transition on the bus */
         case kI2C_SlaveCompletionEvent:
             transport->transfer_cb();
+            transfer->rxData = NULL;
+            transfer->rxSize = 0;
+            transfer->txData = NULL;
+            transfer->txSize = 0;
             break;
 
         default:
@@ -159,7 +169,7 @@ erpc_status_t I2cSlaveTransport::init(void)
     i2c_slave_config_t i2cConfig;
 
     I2C_SlaveGetDefaultConfig(&i2cConfig);
-    i2cConfig.address0.address = (0x7EU); // I2C_MASTER_SLAVE_ADDR_7BIT
+    i2cConfig.address0.address = (I2C_SLAVE_TRANSPORT_ADDR_7BIT);
 
     I2C_SlaveInit(m_i2cBaseAddr, &i2cConfig, m_srcClock_Hz);
     I2C_SlaveTransferCreateHandle(m_i2cBaseAddr, &s_handle, I2C_SlaveUserCallback, (void *)&s_callback_user_data);
@@ -177,6 +187,8 @@ erpc_status_t I2cSlaveTransport::underlyingReceive(uint8_t *data, uint32_t size)
 
     s_callback_user_data.rx_buffer = data;
     s_callback_user_data.rx_size = size;
+    s_callback_user_data.tx_buffer = NULL;
+    s_callback_user_data.tx_size = 0;
 
     status =
         I2C_SlaveTransferNonBlocking(m_i2cBaseAddr, &s_handle, kI2C_SlaveAddressMatchEvent | kI2C_SlaveCompletionEvent);
@@ -205,6 +217,8 @@ erpc_status_t I2cSlaveTransport::underlyingSend(const uint8_t *data, uint32_t si
     status_t status;
     s_isTransferCompleted = false;
 
+    s_callback_user_data.rx_buffer = NULL;
+    s_callback_user_data.rx_size = 0;
     s_callback_user_data.tx_buffer = (uint8_t *)data;
     s_callback_user_data.tx_size = size;
 

erpc_c/transports/erpc_mu_transport.cpp

@@ -150,8 +150,8 @@ void MUTransport::rx_cb(void)
         if (m_rxCntBytes >= m_rxMsgSize)
         {
             m_rxBuffer = NULL;
-            MU_DisableInterrupts(m_muBase, (1U << (MU_CR_RIEn_SHIFT + MU_RR_COUNT - MU_REG_COUNT)));
 #if !ERPC_THREADS_IS(NONE)
+            MU_DisableInterrupts(m_muBase, (1U << (MU_CR_RIEn_SHIFT + MU_RR_COUNT - MU_REG_COUNT)));
             m_rxSemaphore.putFromISR();
 #endif
         }