Initial Commit

1 files changed, 1711 insertions, 0 deletions

diff --git a/ucs2-lib/src/ucs_exc.c b/ucs2-lib/src/ucs_exc.c
new file mode 100644
index 0000000..5f5b5db
--- /dev/null
+++ b/ucs2-lib/src/ucs_exc.c
@@ -0,0 +1,1711 @@
+/*------------------------------------------------------------------------------------------------*/
+/* UNICENS V2.1.0-3491                                                                            */
+/* Copyright (c) 2017 Microchip Technology Germany II GmbH & Co. KG.                              */
+/*                                                                                                */
+/* This program is free software: you can redistribute it and/or modify                           */
+/* it under the terms of the GNU General Public License as published by                           */
+/* the Free Software Foundation, either version 2 of the License, or                              */
+/* (at your option) any later version.                                                            */
+/*                                                                                                */
+/* This program is distributed in the hope that it will be useful,                                */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of                                 */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                  */
+/* GNU General Public License for more details.                                                   */
+/*                                                                                                */
+/* You should have received a copy of the GNU General Public License                              */
+/* along with this program.  If not, see <http://www.gnu.org/licenses/>.                          */
+/*                                                                                                */
+/* You may also obtain this software under a propriety license from Microchip.                    */
+/* Please contact Microchip for further information.                                              */
+/*------------------------------------------------------------------------------------------------*/
+
+/*!
+ * \file
+ * \brief   Implementation of FBlock ExtendedNetworkControl
+ * \details Contains the housekeeping functions of INIC management
+ *
+ * \cond UCS_INTERNAL_DOC
+ * \addtogroup G_EXC
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "ucs_misc.h"
+#include "ucs_ret_pb.h"
+#include "ucs_exc.h"
+
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal definitions                                                                           */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Bitmask for API method Exc_PhyTestResult_Get() used by API locking manager */
+#define EXC_API_PHY_LAY_TEST_RESULT     0x01U
+/*! \brief Bitmask for API method Exc_MemSessionOpen_Sr() used by API locking manager */
+#define EXC_API_MEM_SESSION_OPEN        0x02U
+/*! \brief Bitmask for API method Exc_MemSessionClose_Sr() used by API locking manager */
+#define EXC_API_MEM_SESSION_CLOSE       0x04U
+/*! \brief Bitmask for API method Exc_MemoryRead_Sr() used by API locking manager */
+#define EXC_API_MEM_READ                0x08U
+/*! \brief Bitmask for API method Exc_MemoryWrite_Sr() used by API locking manager */
+#define EXC_API_MEM_WRITE               0x10U
+
+/*! \brief max. number of elements used in MemoryWrite and MemoryWrite messages */
+#define MAX_UNIT_LEN                    18U
+
+/*! \brief  length of signature (V1) */
+#define EXC_SIGNATURE_LEN_V1            26U
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Exc_DecodeMsg(CExc *self, Msg_MostTel_t *msg_rx_ptr);
+static void Exc_EnablePort_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_EnablePort_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Hello_Status(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Hello_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Welcome_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Welcome_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Signature_Status(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_Signature_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_DeviceInit_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_CableLinkDiag_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_CableLinkDiag_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_NwPhyTest_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_NwPhyTestResult_Status(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_NwPhyTestResult_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_BC_Diag_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_BC_Diag_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_BC_EnableTx_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_BC_EnableTx_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemoryRead_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemoryRead_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemoryWrite_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemoryWrite_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemSessionOpen_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemSessionOpen_Error(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemSessionClose_Result(void *self, Msg_MostTel_t *msg_ptr);
+static void Exc_MemSessionClose_Error(void *self, Msg_MostTel_t *msg_ptr);
+
+static void Exc_HandleApiTimeout(void *self, void *method_mask_ptr);
+
+static Ucs_StdResult_t Exc_TranslateError(CExc *self, uint8_t error_data[], uint8_t error_size);
+static void Exc_Read_Signature(Ucs_Signature_t *dest, uint8_t source[]);
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief List of all EXC messages */
+static const Dec_FktOpIsh_t exc_handler[] =       /* parasoft-suppress  MISRA2004-8_7 "Value shall be part of the module, not part of a function." */
+{
+    { DEC_FKTOP(EXC_FID_HELLO,                  UCS_OP_STATUS),  Exc_Hello_Status },
+    { DEC_FKTOP(EXC_FID_HELLO,                  UCS_OP_ERROR),   Exc_Hello_Error },
+    { DEC_FKTOP(EXC_FID_WELCOME,                UCS_OP_RESULT),  Exc_Welcome_Result },
+    { DEC_FKTOP(EXC_FID_WELCOME,                UCS_OP_ERROR),   Exc_Welcome_Error },
+    { DEC_FKTOP(EXC_FID_SIGNATURE,              UCS_OP_STATUS),  Exc_Signature_Status },
+    { DEC_FKTOP(EXC_FID_SIGNATURE,              UCS_OP_ERROR),   Exc_Signature_Error },
+    { DEC_FKTOP(EXC_FID_DEVICE_INIT,            UCS_OP_ERROR),   Exc_DeviceInit_Error },
+    { DEC_FKTOP(EXC_FID_ENABLEPORT,             UCS_OP_RESULT),  Exc_EnablePort_Result },
+    { DEC_FKTOP(EXC_FID_ENABLEPORT,             UCS_OP_ERROR),   Exc_EnablePort_Error },
+    { DEC_FKTOP(EXC_FID_CABLE_LINK_DIAG,        UCS_OP_RESULT),  Exc_CableLinkDiag_Result },
+    { DEC_FKTOP(EXC_FID_CABLE_LINK_DIAG,        UCS_OP_ERROR),   Exc_CableLinkDiag_Error },
+    { DEC_FKTOP(EXC_FID_PHY_LAY_TEST,           UCS_OP_ERROR),   Exc_NwPhyTest_Error },
+    { DEC_FKTOP(EXC_FID_PHY_LAY_TEST_RES,       UCS_OP_STATUS),  Exc_NwPhyTestResult_Status },
+    { DEC_FKTOP(EXC_FID_PHY_LAY_TEST_RES,       UCS_OP_ERROR),   Exc_NwPhyTestResult_Error },
+    { DEC_FKTOP(EXC_FID_BC_DIAG,                UCS_OP_RESULT),  Exc_BC_Diag_Result },
+    { DEC_FKTOP(EXC_FID_BC_DIAG,                UCS_OP_ERROR),   Exc_BC_Diag_Error },
+    { DEC_FKTOP(EXC_FID_BC_ENABLE_TX,           UCS_OP_RESULT),  Exc_BC_EnableTx_Result },
+    { DEC_FKTOP(EXC_FID_BC_ENABLE_TX,           UCS_OP_ERROR),   Exc_BC_EnableTx_Error },
+    { DEC_FKTOP(EXC_FID_MEM_SESSION_OPEN,       UCS_OP_RESULT),  Exc_MemSessionOpen_Result },
+    { DEC_FKTOP(EXC_FID_MEM_SESSION_OPEN,       UCS_OP_ERROR),   Exc_MemSessionOpen_Error },
+    { DEC_FKTOP(EXC_FID_MEM_SESSION_CLOSE,      UCS_OP_RESULT),  Exc_MemSessionClose_Result },
+    { DEC_FKTOP(EXC_FID_MEM_SESSION_CLOSE,      UCS_OP_ERROR),   Exc_MemSessionClose_Error },
+    { DEC_FKTOP(EXC_FID_MEMORY_READ,            UCS_OP_RESULT),  Exc_MemoryRead_Result },
+    { DEC_FKTOP(EXC_FID_MEMORY_READ,            UCS_OP_ERROR),   Exc_MemoryRead_Error },
+    { DEC_FKTOP(EXC_FID_MEMORY_WRITE,           UCS_OP_RESULT),  Exc_MemoryWrite_Result },
+    { DEC_FKTOP(EXC_FID_MEMORY_WRITE,           UCS_OP_ERROR),   Exc_MemoryWrite_Error },
+    { DEC_FKTOP_TERMINATION,                                     NULL }
+};
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief Constructor of class CExc.
+ *  \param self         Reference to CExc instance
+ *  \param base_ptr     Reference to a Base instance
+ *  \param rcm_ptr      Reference to Transceiver instance
+ */
+void Exc_Ctor(CExc *self, CBase *base_ptr, CTransceiver *rcm_ptr)
+{
+
+    MISC_MEM_SET((void *)self, 0, sizeof(*self));
+
+    self->base_ptr = base_ptr;
+    self->xcvr_ptr = rcm_ptr;
+
+    self->fkt_op_list_ptr = &exc_handler[0];
+
+
+    /* Initialize API locking mechanism */
+    Sobs_Ctor(&self->lock.observer, self, &Exc_HandleApiTimeout);
+    Al_Ctor(&self->lock.api, &self->lock.observer, self->base_ptr->ucs_user_ptr);
+    Alm_RegisterApi(&self->base_ptr->alm, &self->lock.api);
+
+}
+
+
+/*! \brief   Callback function to filter RCM Rx messages
+ *  \details Do not release the message object here
+ *  \param   self     reference to INIC object
+ *  \param   tel_ptr  received message
+ */
+void Exc_OnRcmRxFilter(void *self, Msg_MostTel_t *tel_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_DecodeMsg(self_, tel_ptr);
+
+}
+
+
+/*! \brief  Decode a message for FBlock EXC
+ *  \param  self        Instance pointer to FBlock EXC
+ *  \param  msg_rx_ptr  pointer to the MCM message to decode
+ */
+static void Exc_DecodeMsg(CExc *self, Msg_MostTel_t *msg_rx_ptr)
+{
+    Dec_Return_t result;
+    uint16_t     index;
+
+    result = Dec_SearchFktOpIsh(self->fkt_op_list_ptr, &index, msg_rx_ptr->id.function_id, msg_rx_ptr->id.op_type);
+
+    if (result == DEC_RET_SUCCESS)
+    {
+        self->fkt_op_list_ptr[index].handler_function_ptr(self, msg_rx_ptr);
+    }
+    else
+    {
+        /* no handling of decoding error for shadow OpTypes */
+    }
+}
+
+
+
+/*! \brief  Handles an API timeout
+ *  \param  self             Instance pointer
+ *  \param  method_mask_ptr  Bitmask to signal which API method has caused the timeout
+ */
+static void Exc_HandleApiTimeout(void *self, void *method_mask_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Alm_ModuleMask_t method_mask = *((Alm_ModuleMask_t *)method_mask_ptr);
+    Exc_StdResult_t res_data;
+
+    res_data.result.code      = UCS_RES_ERR_TIMEOUT;
+    res_data.result.info_ptr  = NULL;
+    res_data.result.info_size = 0U;
+    res_data.data_info        = NULL;
+
+    switch(method_mask)
+    {
+#if 0   /* System Diagnosis supervises timeouts for these functions  */
+        case EXC_API_ENABLE_PORT:
+            Ssub_Notify(&self_->ssubs.enableport, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_EnablePort_Sr().", 0U));
+            break;
+        case EXC_API_HELLO:
+            Ssub_Notify(&self_->ssubs.hello, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_Hello_Get().", 0U));
+            break;
+        case EXC_API_WELCOME:
+            Ssub_Notify(&self_->ssubs.welcome, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_Welcome_Sr().", 0U));
+            break;
+        case EXC_API_CABLE_LINK_DIAG:
+            Ssub_Notify(&self_->ssubs.cablelinkdiag, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_CableLinkDiagnosis_Start().", 0U));
+            break;
+#endif
+        case EXC_API_PHY_LAY_TEST_RESULT:
+            Ssub_Notify(&self_->ssubs.phylaytestresult, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_PhyTestResult_Get().", 0U));
+            break;
+        case EXC_API_MEM_SESSION_OPEN:
+            Ssub_Notify(&self_->ssubs.memsessionopen, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_MemSessionOpen_Sr().", 0U));
+            break;
+        case EXC_API_MEM_SESSION_CLOSE:
+            Ssub_Notify(&self_->ssubs.memsessionclose, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_MemSessionClose_Sr().", 0U));
+            break;
+        case EXC_API_MEM_READ:
+            Ssub_Notify(&self_->ssubs.memoryread, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_MemoryRead_Sr().", 0U));
+            break;
+        case EXC_API_MEM_WRITE:
+            Ssub_Notify(&self_->ssubs.memorywrite, &res_data, false);
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "API locking timeout occurred for method Exc_MemoryWrite_Sr().", 0U));
+            break;
+
+        default:
+            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[EXC]", "Unknown API locking bitmask detected. Mask: 0x%02X", 1U, method_mask));
+            break;
+    }
+}
+
+
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal API                                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  This method sends the Hello.Get message
+ *  \param  self            Reference to CExc instance
+ *  \param  target_address  Target address
+ *  \param  version_limit   Signature version limit 
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_Hello_Get(CExc *self, 
+                           uint16_t target_address, 
+                           uint8_t version_limit,
+                           CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);
+
+    if (msg_ptr != NULL)
+    {
+        if (version_limit > UCS_EXC_SIGNATURE_VERSION_LIMIT)
+        {
+            version_limit = UCS_EXC_SIGNATURE_VERSION_LIMIT;
+        }
+
+        msg_ptr->destination_addr    = target_address;
+
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_HELLO;
+        msg_ptr->id.op_type          = UCS_OP_GET;
+        msg_ptr->tel.tel_data_ptr[0] = version_limit;
+
+        msg_ptr->info_ptr = &self->ssubs.hello;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.hello, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief  This method send the Welcome.StartResult message
+ *  \param  self                Reference to CExc instance
+ *  \param  target_address      Target address
+ *  \param  admin_node_address  The node address used during system diagnosis
+ *  \param  version             Signature version 
+ *  \param  signature           Signature of the device
+ *  \param  obs_ptr             Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_Welcome_Sr(CExc *self, 
+                            uint16_t target_address, 
+                            uint16_t admin_node_address,
+                            uint8_t version,
+                            Ucs_Signature_t  signature,
+                            CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, EXC_SIGNATURE_LEN_V1 + 3U);    /* Signature v1 */
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr     = target_address;
+        msg_ptr->id.fblock_id         = FB_EXC;
+        msg_ptr->id.instance_id       = 0U;
+        msg_ptr->id.function_id       = EXC_FID_WELCOME;
+        msg_ptr->id.op_type           = UCS_OP_STARTRESULT;
+        msg_ptr->tel.tel_data_ptr[0]  = MISC_HB(admin_node_address);
+        msg_ptr->tel.tel_data_ptr[1]  = MISC_LB(admin_node_address);
+        msg_ptr->tel.tel_data_ptr[2]  = version;
+        msg_ptr->tel.tel_data_ptr[3]  = MISC_HB(signature.node_address);
+        msg_ptr->tel.tel_data_ptr[4]  = MISC_LB(signature.node_address);
+        msg_ptr->tel.tel_data_ptr[5]  = MISC_HB(signature.group_address);
+        msg_ptr->tel.tel_data_ptr[6]  = MISC_LB(signature.group_address);
+        msg_ptr->tel.tel_data_ptr[7]  = MISC_HB(signature.mac_47_32);
+        msg_ptr->tel.tel_data_ptr[8]  = MISC_LB(signature.mac_47_32);
+        msg_ptr->tel.tel_data_ptr[9]  = MISC_HB(signature.mac_31_16);
+        msg_ptr->tel.tel_data_ptr[10] = MISC_LB(signature.mac_31_16);
+        msg_ptr->tel.tel_data_ptr[11] = MISC_HB(signature.mac_15_0);
+        msg_ptr->tel.tel_data_ptr[12] = MISC_LB(signature.mac_15_0);
+        msg_ptr->tel.tel_data_ptr[13] = MISC_HB(signature.node_pos_addr);
+        msg_ptr->tel.tel_data_ptr[14] = MISC_LB(signature.node_pos_addr);
+        msg_ptr->tel.tel_data_ptr[15] = MISC_HB(signature.diagnosis_id);
+        msg_ptr->tel.tel_data_ptr[16] = MISC_LB(signature.diagnosis_id);
+        msg_ptr->tel.tel_data_ptr[17] = signature.num_ports;
+        msg_ptr->tel.tel_data_ptr[18] = signature.chip_id;
+        msg_ptr->tel.tel_data_ptr[19] = signature.fw_major;
+        msg_ptr->tel.tel_data_ptr[20] = signature.fw_minor;
+        msg_ptr->tel.tel_data_ptr[21] = signature.fw_release;
+        msg_ptr->tel.tel_data_ptr[22] = MISC_HB((signature.fw_build) >>16U);
+        msg_ptr->tel.tel_data_ptr[23] = MISC_LB((signature.fw_build) >>16U);
+        msg_ptr->tel.tel_data_ptr[24] = MISC_HB(signature.fw_build);
+        msg_ptr->tel.tel_data_ptr[25] = MISC_LB(signature.fw_build);
+        msg_ptr->tel.tel_data_ptr[26] = signature.cs_major;
+        msg_ptr->tel.tel_data_ptr[27] = signature.cs_minor;
+        msg_ptr->tel.tel_data_ptr[28] = signature.cs_release;
+/*        msg_ptr->tel.tel_data_ptr[29] = signature.uid_persistency;
+        msg_ptr->tel.tel_data_ptr[30] = MISC_HB((signature.uid) >>16U);
+        msg_ptr->tel.tel_data_ptr[31] = MISC_LB((signature.uid) >>16U);
+        msg_ptr->tel.tel_data_ptr[32] = MISC_HB(signature.uid);
+        msg_ptr->tel.tel_data_ptr[33] = MISC_LB(signature.uid);
+*/
+
+        msg_ptr->info_ptr = &self->ssubs.welcome;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.welcome, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief  This method sends the Signature.Get message
+ *  \param  self            Reference to CExc instance
+ *  \param  target_address  Target address
+ *  \param  version_limit   Signature version limit 
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_Signature_Get(CExc *self, 
+                               uint16_t target_address, 
+                               uint8_t version_limit, 
+                               CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);
+
+    if (msg_ptr != NULL)
+    {
+        if (version_limit > UCS_EXC_SIGNATURE_VERSION_LIMIT)
+        {
+            version_limit = UCS_EXC_SIGNATURE_VERSION_LIMIT;
+        }
+
+        msg_ptr->destination_addr  = target_address;
+
+        msg_ptr->id.fblock_id      = FB_EXC;
+        msg_ptr->id.instance_id    = 0U;
+        msg_ptr->id.function_id    = EXC_FID_SIGNATURE;
+        msg_ptr->id.op_type        = UCS_OP_GET;
+        msg_ptr->tel.tel_data_ptr[0] = version_limit;
+
+        msg_ptr->info_ptr = &self->ssubs.signature;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.signature, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief  This method sends the DeviceInit.Start message
+ *  \param  self            Reference to CExc instance
+ *  \param  target_address  Target address
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_DeviceInit_Start(CExc *self, 
+                                  uint16_t target_address, 
+                                  CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 0U);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr  = target_address;
+
+        msg_ptr->id.fblock_id      = FB_EXC;
+        msg_ptr->id.instance_id    = 0U;
+        msg_ptr->id.function_id    = EXC_FID_DEVICE_INIT;
+        msg_ptr->id.op_type        = UCS_OP_START;
+
+        msg_ptr->info_ptr = &self->ssubs.deviceinit;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.deviceinit, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief  This method enables a port
+ *  \param  self            Reference to CExc instance
+ *  \param  target_address  Target address
+ *  \param  port_number     PortNumber 
+ *  \param  enabled         Enabled 
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_EnablePort_Sr(CExc *self, 
+                               uint16_t target_address, 
+                               uint8_t port_number, 
+                               bool enabled, 
+                               CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U); 
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr    = target_address;
+
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_ENABLEPORT;
+        msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+        msg_ptr->tel.tel_data_ptr[0] = port_number;
+        msg_ptr->tel.tel_data_ptr[1] = (uint8_t)enabled;
+
+        msg_ptr->info_ptr = &self->ssubs.enableport;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.enableport, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+/*! \brief  This method starts the Cable Link Diagnosis
+ *  \param  self            Reference to CExc instance
+ *  \param  target_address  Target address
+ *  \param  port_number     PortNumber 
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_CableLinkDiagnosis_Start(CExc *self, 
+                                          uint16_t target_address, 
+                                          uint8_t port_number, 
+                                          CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr    = target_address;
+
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_CABLE_LINK_DIAG;
+        msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+        msg_ptr->tel.tel_data_ptr[0] = port_number;
+
+        msg_ptr->info_ptr = &self->ssubs.cablelinkdiag;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.cablelinkdiag, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+/*! \brief  This method starts the Physical Layer Test
+ *  \param  self            Reference to CExc instance
+ *  \param  port_number     PortNumber 
+ *  \param  type            Type
+ *  \param  lead_in         Lead-in
+ *  \param  duration        Duration
+ *  \param  lead_out        Lead-out
+ *  \param  obs_ptr         Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_PhyTest_Start(CExc *self, 
+                               uint8_t port_number, 
+                               Ucs_Diag_PhyTest_Type_t type, 
+                               uint16_t lead_in, 
+                               uint32_t duration, 
+                               uint16_t lead_out, 
+                               CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 10U);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr    = MSG_ADDR_INIC; 
+
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_PHY_LAY_TEST;
+        msg_ptr->id.op_type          = UCS_OP_START;
+        msg_ptr->tel.tel_data_ptr[0] = port_number; 
+        msg_ptr->tel.tel_data_ptr[1] = (uint8_t)type;
+        msg_ptr->tel.tel_data_ptr[2] = MISC_HB(lead_in);
+        msg_ptr->tel.tel_data_ptr[3] = MISC_LB(lead_in);
+        msg_ptr->tel.tel_data_ptr[4] = (uint8_t)((duration) >> 24);
+        msg_ptr->tel.tel_data_ptr[5] = (uint8_t)((duration) >> 16);
+        msg_ptr->tel.tel_data_ptr[6] = (uint8_t)((duration) >> 8);
+        msg_ptr->tel.tel_data_ptr[7] = (uint8_t)(duration & (uint32_t)0xFF);
+        msg_ptr->tel.tel_data_ptr[8] = MISC_HB(lead_out);
+        msg_ptr->tel.tel_data_ptr[9] = MISC_LB(lead_out);
+
+
+        msg_ptr->info_ptr = &self->ssubs.phylaytest;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.phylaytest, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief  Requests the EXC.PhysicalLayerTestResult.Status message
+ *  \param  self        Reference to CExc instance
+ *  \param  obs_ptr     Reference to an optional observer
+ *  \return UCS_RET_SUCCESS               message was created 
+ *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available 
+ *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
+ */
+Ucs_Return_t  Exc_PhyTestResult_Get(CExc *self, 
+                                    CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    if(Al_Lock(&self->lock.api, EXC_API_PHY_LAY_TEST_RESULT) != false)
+    {
+        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 0U);
+
+        if (msg_ptr != NULL)
+        {
+            msg_ptr->destination_addr  = MSG_ADDR_INIC;
+
+            msg_ptr->id.fblock_id      = FB_EXC;
+            msg_ptr->id.instance_id    = 0U;
+            msg_ptr->id.function_id    = EXC_FID_PHY_LAY_TEST_RES;
+            msg_ptr->id.op_type        = UCS_OP_GET;
+
+            msg_ptr->info_ptr = &self->ssubs.phylaytestresult;
+            Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+            (void)Ssub_AddObserver(&self->ssubs.phylaytestresult, obs_ptr);
+        }
+        else
+        {
+            Al_Release(&self->lock.api, EXC_API_PHY_LAY_TEST_RESULT);
+            result = UCS_RET_ERR_BUFFER_OVERFLOW;
+        }
+    }
+    else
+    {
+        result = UCS_RET_ERR_API_LOCKED;
+    }
+
+    return result;
+}
+
+
+
+/*! Sends the BCDiag.Startresult command
+ *
+ * \param *self         Reference to CExc instance
+ * \param position      Position of the segment to be checked.
+ * \param admin_na      Admin Node Address
+ * \param t_send        Timing parameter t_Send
+ * \param t_wait4dut    Timing parameter t_WaitForDUT
+ * \param t_switch      Timing parameter t_Switch
+ * \param t_back        Timing parameter t_Back
+ * \param autoback      TBD
+ * \param *obs_ptr      Reference to an optional observer
+ * \return UCS_RET_SUCCESS               message was created 
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_BCDiag_Start(CExc *self, 
+                              uint8_t position, 
+                              uint16_t admin_na,
+                              uint16_t t_send,
+                              uint16_t t_wait4dut, 
+                              uint16_t t_switch,
+                              uint16_t t_back,
+                              bool     autoback,
+                              CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 12U);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr    = UCS_ADDR_BROADCAST_BLOCKING; 
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_BC_DIAG;
+        msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+        msg_ptr->tel.tel_data_ptr[0] = position; 
+        msg_ptr->tel.tel_data_ptr[1] = MISC_HB(admin_na);
+        msg_ptr->tel.tel_data_ptr[2] = MISC_LB(admin_na);
+        msg_ptr->tel.tel_data_ptr[3] = MISC_HB(t_send);
+        msg_ptr->tel.tel_data_ptr[4] = MISC_LB(t_send);
+        msg_ptr->tel.tel_data_ptr[5] = MISC_HB(t_wait4dut);
+        msg_ptr->tel.tel_data_ptr[6] = MISC_LB(t_wait4dut);
+        msg_ptr->tel.tel_data_ptr[7] = MISC_HB(t_switch);
+        msg_ptr->tel.tel_data_ptr[8] = MISC_LB(t_switch);
+        msg_ptr->tel.tel_data_ptr[9] = MISC_HB(t_back);
+        msg_ptr->tel.tel_data_ptr[10] = MISC_LB(t_back);
+        msg_ptr->tel.tel_data_ptr[11] = (uint8_t)autoback;
+
+
+        msg_ptr->info_ptr = &self->ssubs.bcdiag;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.bcdiag, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! Enables the signal during backChannel Diagnosis
+ *
+ * \param *self         Reference to CExc instance
+ * \param port          Number of port which has to be enabled.
+ * \param *obs_ptr      Reference to an optional observer
+ * \return UCS_RET_SUCCESS               message was created 
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
+ */
+Ucs_Return_t Exc_BCEnableTx_StartResult(CExc *self, 
+                                        uint8_t port,
+                                        CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_addr    = UCS_ADDR_BROADCAST_BLOCKING; 
+        msg_ptr->id.fblock_id        = FB_EXC;
+        msg_ptr->id.instance_id      = 0U;
+        msg_ptr->id.function_id      = EXC_FID_BC_ENABLE_TX;
+        msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+        msg_ptr->tel.tel_data_ptr[0] = port;
+
+        msg_ptr->info_ptr = &self->ssubs.enabletx;
+        Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+        (void)Ssub_AddObserver(&self->ssubs.enabletx, obs_ptr);
+    }
+    else
+    {
+        result = UCS_RET_ERR_BUFFER_OVERFLOW;
+    }
+
+    return result;
+}
+
+
+/*! \brief This function is used to open a memory session. 
+ *
+ *  A memory session is used to control access to the memory resources. Before a memory could 
+ *  be read or written, a session of the appropriate type has to be opened.
+ *  Only a single memory session is supported. Once opened, the session must be first
+ *  closed before a new session of a different type could be used. Some session types
+ *  (0x01, 0x02 and 0x04) require a hardware reset after they were closed.
+ *  Function Exc_MemSessionOpen_Sr() also performs some preprocessing,
+ *  depending on the session_type. This includes clearing of the configuration
+ *  and identification strings before the error memory is programmed or erased.
+ *
+ * \param *self           Reference to CExc instance 
+ * \param target_address  Target address
+ * \param session_type    Defines the set of MemIDs and the memory access type(s) (read and/or write)
+ * \param *obs_ptr        Reference to an optional observer
+ *
+ * \return UCS_RET_SUCCESS message was created and sent to INIC
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available 
+ * \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
+ */
+Ucs_Return_t Exc_MemSessionOpen_Sr(CExc *self, 
+                                   uint16_t target_address, 
+                                   uint8_t session_type,
+                                   CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    if(Al_Lock(&self->lock.api, EXC_API_MEM_SESSION_OPEN) != false)
+    {
+        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);
+
+        if (msg_ptr != NULL)
+        {
+            msg_ptr->destination_addr  = target_address;
+
+            msg_ptr->id.fblock_id        = FB_EXC;
+            msg_ptr->id.instance_id      = 0U;
+            msg_ptr->id.function_id      = EXC_FID_MEM_SESSION_OPEN;
+            msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+            msg_ptr->tel.tel_data_ptr[0] = session_type; 
+
+            msg_ptr->info_ptr = &self->ssubs.memsessionopen;
+            Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+            (void)Ssub_AddObserver(&self->ssubs.memsessionopen, obs_ptr);
+        }
+        else
+        {
+            Al_Release(&self->lock.api, EXC_API_MEM_SESSION_OPEN);
+            result = UCS_RET_ERR_BUFFER_OVERFLOW;
+        }
+    }
+    else
+    {
+        result = UCS_RET_ERR_API_LOCKED;
+    }
+
+    return result;
+}
+
+
+/*! \brief This function is used to close an active memory session that was previously opened by
+ *         function Exc_MemSessionOpen_Sr(). 
+ *
+ *  In addition, the function performs some post-processing on given session types. This includes 
+ *  validation of the newly programmed configuration and identification strings as well as 
+ *  the deactivation of the current configuration and identification strings. In these cases, 
+ *  the new configuration becomes active after a hardware reset.
+ *
+ * \param *self             Reference to CExc instance 
+ * \param target_address    Target address
+ * \param session_handle    Unique number assigned to the active memory session
+ * \param *obs_ptr          Reference to an optional observer
+ *
+ * \return UCS_RET_SUCCESS message was created and sent to INIC
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available 
+ * \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
+ */
+Ucs_Return_t Exc_MemSessionClose_Sr(CExc *self, 
+                                    uint16_t target_address, 
+                                    uint16_t session_handle,
+                                    CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    if(Al_Lock(&self->lock.api, EXC_API_MEM_SESSION_CLOSE) != false)
+    {
+        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);
+
+        if (msg_ptr != NULL)
+        {
+            msg_ptr->destination_addr    = target_address;
+
+            msg_ptr->id.fblock_id        = FB_EXC;
+            msg_ptr->id.instance_id      = 0U;
+            msg_ptr->id.function_id      = EXC_FID_MEM_SESSION_CLOSE;
+            msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(session_handle); 
+            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(session_handle); 
+
+            msg_ptr->info_ptr = &self->ssubs.memsessionclose;
+            Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+            (void)Ssub_AddObserver(&self->ssubs.memsessionclose, obs_ptr);
+        }
+        else
+        {
+            Al_Release(&self->lock.api, EXC_API_MEM_SESSION_CLOSE);
+            result = UCS_RET_ERR_BUFFER_OVERFLOW;
+        }
+    }
+    else
+    {
+        result = UCS_RET_ERR_API_LOCKED;
+    }
+
+    return result;
+}
+
+
+/*! \brief This function provides read access to the memories described by parameter MemID.
+ *
+ *  In addition, the function can be used to retrieve the active Configuration String and 
+ *  Identification String.
+ *  Reading the memory can only be done within an active memory session. Parameter
+ *  session_handle authorizes the access to the memory resource defined by parameter
+ *  MemID. The session_handle is provided by function Exc_MemSessionOpen_Sr(),
+ *  which must be called in advance to memory access.
+ *
+ * \param *self             Reference to CExc instance 
+ * \param target_address    Target address
+ * \param session_handle    Unique number assigned to the active memory session
+ * \param mem_id            Represents the memory resource to be read
+ * \param address           Defines the memory location at which the reading operation starts
+ * \param unit_len          Sets the number of memory units to be read. Memory units can be 
+ *                          unsigned bytes, unsigned words or unsigned masked data depending 
+ *                          on the memory type.
+ * \param *obs_ptr          Reference to an optional observer
+ *
+ * \return UCS_RET_SUCCESS              message was created and sent to INIC
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW  no message buffer available 
+ * \return UCS_RET_ERR_PARAM            parameter ubit_len ist too big
+ * \return UCS_RET_ERR_API_LOCKED       Resource API is already used by another command
+ */
+Ucs_Return_t Exc_MemoryRead_Sr(CExc *self, 
+                               uint16_t target_address, 
+                               uint16_t session_handle,
+                               uint8_t  mem_id,
+                               uint32_t address,
+                               uint8_t  unit_len,
+                               CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    if(Al_Lock(&self->lock.api, EXC_API_MEM_READ) != false)
+    {
+        if (unit_len > MAX_UNIT_LEN)
+        {
+            result = UCS_RET_ERR_PARAM;
+        }
+
+        if (result == UCS_RET_SUCCESS)
+        {
+            Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 8U);
+
+            if (msg_ptr != NULL)
+            {
+                msg_ptr->destination_addr    = target_address;
+                msg_ptr->id.fblock_id        = FB_EXC;
+                msg_ptr->id.instance_id      = 0U;
+                msg_ptr->id.function_id      = EXC_FID_MEMORY_READ;
+                msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+                msg_ptr->tel.tel_data_ptr[0] = MISC_HB(session_handle); 
+                msg_ptr->tel.tel_data_ptr[1] = MISC_LB(session_handle); 
+                msg_ptr->tel.tel_data_ptr[2] = mem_id; 
+                msg_ptr->tel.tel_data_ptr[3] = (uint8_t)((address) >> 24);
+                msg_ptr->tel.tel_data_ptr[4] = (uint8_t)((address) >> 16);
+                msg_ptr->tel.tel_data_ptr[5] = (uint8_t)((address) >> 8);
+                msg_ptr->tel.tel_data_ptr[6] = (uint8_t)(address & (uint32_t)0xFF);
+                msg_ptr->tel.tel_data_ptr[7] = unit_len; 
+
+                msg_ptr->info_ptr = &self->ssubs.memoryread;
+                Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+                (void)Ssub_AddObserver(&self->ssubs.memoryread, obs_ptr);
+            }
+            else
+            {
+                Al_Release(&self->lock.api, EXC_API_MEM_READ);
+                result = UCS_RET_ERR_BUFFER_OVERFLOW;
+            }
+        }
+    }
+    else
+    {
+        result = UCS_RET_ERR_API_LOCKED;
+    }
+
+    return result;
+}
+
+
+/*! \brief This function provides write access to the memories described by parameter MemID. 
+ *
+ *  In addition, the function can be used to program a new Configuration String and Identification
+ *  String.
+ *  Writing the memory can only be done within an active memory session. Parameter
+ *  SessionHandle authorizes the access to the memory resource defined by parameter
+ *  MemID. The SessionHandle is provided by function ExtendedNetworkControl.MemorySessionOpen(),
+ *  which must be called in advance to memory access.
+ *
+ * \param *self             Reference to CExc instance 
+ * \param target_address    Target address
+ * \param session_handle    Unique number assigned to the active memory session
+ * \param mem_id            Represents the memory resource to be read
+ * \param address           Defines the memory location at which the reading operation starts
+ * \param unit_len          Sets the number of memory units to be read. Memory units can be 
+ *                          unsigned bytes, unsigned words or unsigned masked data depending 
+ *                          on the memory type.
+ * \param *unit_data        Contains the actual data written to the memory resource and formatted 
+ *                          as memory units
+ * \param *obs_ptr          Reference to an optional observer
+ *
+ * \return UCS_RET_SUCCESS              message was created and sent to INIC
+ * \return UCS_RET_ERR_BUFFER_OVERFLOW  no message buffer available 
+ * \return UCS_RET_ERR_PARAM            parameter ubit_len ist too big
+ * \return UCS_RET_ERR_API_LOCKED       Resource API is already used by another command
+ */
+Ucs_Return_t Exc_MemoryWrite_Sr(CExc *self, 
+                                uint16_t target_address, 
+                                uint16_t session_handle,
+                                uint8_t  mem_id,
+                                uint32_t address,
+                                uint8_t  unit_len,
+                                uint8_t  unit_data[],
+                                CSingleObserver *obs_ptr)
+{
+    Ucs_Return_t result = UCS_RET_SUCCESS;
+
+    if(Al_Lock(&self->lock.api, EXC_API_MEM_WRITE) != false)
+    {
+        if (unit_len > MAX_UNIT_LEN)
+        {
+            result = UCS_RET_ERR_PARAM;
+        }
+
+        if (result == UCS_RET_SUCCESS)
+        {
+            Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 8U + unit_len);
+
+            if (msg_ptr != NULL)
+            {
+                uint8_t i;
+
+                msg_ptr->destination_addr    = target_address;
+                msg_ptr->id.fblock_id        = FB_EXC;
+                msg_ptr->id.instance_id      = 0U;
+                msg_ptr->id.function_id      = EXC_FID_MEMORY_WRITE;
+                msg_ptr->id.op_type          = UCS_OP_STARTRESULT;
+                msg_ptr->tel.tel_data_ptr[0] = MISC_HB(session_handle); 
+                msg_ptr->tel.tel_data_ptr[1] = MISC_LB(session_handle); 
+                msg_ptr->tel.tel_data_ptr[2] = mem_id; 
+                msg_ptr->tel.tel_data_ptr[3] = (uint8_t)((address) >> 24);
+                msg_ptr->tel.tel_data_ptr[4] = (uint8_t)((address) >> 16);
+                msg_ptr->tel.tel_data_ptr[5] = (uint8_t)((address) >> 8);
+                msg_ptr->tel.tel_data_ptr[6] = (uint8_t)(address & (uint32_t)0xFF);
+                msg_ptr->tel.tel_data_ptr[7] = unit_len; 
+                for (i=0U; i<unit_len; ++i)
+                {
+                    msg_ptr->tel.tel_data_ptr[8U+i] = *(unit_data + i);
+                }
+
+                msg_ptr->info_ptr = &self->ssubs.memorywrite;
+                Trcv_TxSendMsg(self->xcvr_ptr, msg_ptr);
+
+                (void)Ssub_AddObserver(&self->ssubs.memorywrite, obs_ptr);
+            }
+            else
+            {
+                Al_Release(&self->lock.api, EXC_API_MEM_WRITE);
+                result = UCS_RET_ERR_BUFFER_OVERFLOW;
+            }
+        }
+    }
+    else
+    {
+        result = UCS_RET_ERR_API_LOCKED;
+    }
+
+    return result;
+}
+
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Handler functions                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Handler function for EXC.Hello.Status
+ *  \param  self        Reference to EXC object
+ *  \param  msg_ptr     Received message
+ */
+static void Exc_Hello_Status(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_HelloStatus_t hello_data; 
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len >= (EXC_SIGNATURE_LEN_V1  + 1U))
+    {
+        hello_data.version =    msg_ptr->tel.tel_data_ptr[0];
+        Exc_Read_Signature(&(hello_data.signature), &(msg_ptr->tel.tel_data_ptr[1]));
+
+        res_data.data_info        = &hello_data;
+        res_data.result.code      = UCS_RES_SUCCESS;
+        res_data.result.info_ptr  = NULL;
+        res_data.result.info_size = 0U;
+
+        /* Node Discovery sends the Hello.Get as broadcast message. So we will need the observer
+           several times. */ 
+        Ssub_Notify(&self_->ssubs.hello, &res_data, false); 
+    }
+}
+
+
+/*! \brief Handler function for EXC.Hello.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_Hello_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        /* Node Discovery sends the Hello.Get as broadcast message. So we will need the observer
+           several times. */ 
+        Ssub_Notify(&self_->ssubs.hello, &res_data, false);
+    }
+}
+
+
+/*! \brief Handler function for EXC.Welcome.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_Welcome_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.welcome, &res_data, true);
+    }
+}
+
+/*! \brief Handler function for the EXC.Welcome.Result message
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_Welcome_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_WelcomeResult_t welcome_data; 
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len >= (EXC_SIGNATURE_LEN_V1  + 2U))
+    {
+        welcome_data.res = msg_ptr->tel.tel_data_ptr[0];
+        welcome_data.version = msg_ptr->tel.tel_data_ptr[1];
+        Exc_Read_Signature(&(welcome_data.signature), &(msg_ptr->tel.tel_data_ptr[2]));
+        res_data.data_info       = &welcome_data;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.welcome, &res_data, true);
+    }
+}
+
+
+/*! Handler function for the EXC.Signature.Status message
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_Signature_Status(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_SignatureStatus_t signature_data; 
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len >= (EXC_SIGNATURE_LEN_V1  + 1U))
+    {
+        signature_data.version =    msg_ptr->tel.tel_data_ptr[0];
+        Exc_Read_Signature(&(signature_data.signature), &(msg_ptr->tel.tel_data_ptr[1]));
+
+        res_data.data_info       = &signature_data;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+        res_data.result.info_size = 0U;
+
+        Ssub_Notify(&self_->ssubs.signature, &res_data, true);
+    }
+}
+
+
+/*! Handler function for the EXC.Signature.Error message
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_Signature_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.signature, &res_data, true);
+    }
+}
+
+
+/*! Handler function for the EXC.DeviceInit.Error message
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_DeviceInit_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len >0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.deviceinit, &res_data, true);
+    }
+}
+
+
+/*! \brief Handler function for EXC.EnablePort.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_EnablePort_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.result = Exc_TranslateError(self_, 
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.enableport, &res_data, true);
+    }
+}
+
+/*! \brief Handler function for EXC.EnablePort.Result
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_EnablePort_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    MISC_UNUSED(msg_ptr);
+
+    res_data.result.code = UCS_RES_SUCCESS;
+    res_data.result.info_ptr = NULL;
+    Ssub_Notify(&self_->ssubs.enableport, &res_data, true);
+}
+
+
+/*! \brief Handler function for EXC.CableLinkDiag.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_CableLinkDiag_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)   
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0],
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.cablelinkdiag, &res_data, true);
+    }
+}
+
+/*! \brief Handler function for EXC.CableLinkDiag.Result
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_CableLinkDiag_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_CableLinkDiagResult_t cable_link_diag_result_data; 
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        cable_link_diag_result_data.port_number = msg_ptr->tel.tel_data_ptr[0];
+        cable_link_diag_result_data.result      = msg_ptr->tel.tel_data_ptr[1];
+        res_data.data_info       = &cable_link_diag_result_data;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.cablelinkdiag, &res_data, true);
+    }
+}
+
+
+/*! \brief Handler function for EXC.PhysicalLayerTest.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */static void Exc_NwPhyTest_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.phylaytest, &res_data, true);
+    }
+}
+
+
+/*! \brief Handler function for EXC.MOSTNetworkPhysicalLayerTestResult.Status
+ *  \param  self        Reference to EXC object
+ *  \param  msg_ptr     Received message
+ */
+static void Exc_NwPhyTestResult_Status(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_PhyTestResult_t phy_test_result;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        phy_test_result.port_number = msg_ptr->tel.tel_data_ptr[0];
+        phy_test_result.lock_status = (msg_ptr->tel.tel_data_ptr[1] != 0U) ? true : false;
+        MISC_DECODE_WORD(&(phy_test_result.err_count), &(msg_ptr->tel.tel_data_ptr[2]));
+        res_data.data_info       = &phy_test_result;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.phylaytestresult, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_PHY_LAY_TEST_RESULT);
+}
+
+
+/*! \brief Handler function for EXC.MOSTNetworkPhysicalLayerTestResult.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_NwPhyTestResult_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.phylaytestresult, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_PHY_LAY_TEST_RESULT);
+}
+
+
+
+/*! \brief Handler function for EXC.BCDiag.Status
+ *  \param  self        Reference to EXC object
+ *  \param  msg_ptr     Received message
+ */
+static void Exc_BC_Diag_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_BCDiagResult bcd_result;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 1U)
+    {
+        bcd_result.diag_result = (Exc_BCDiagResValue)(msg_ptr->tel.tel_data_ptr[0] >> 4U);
+        MISC_DECODE_WORD(&(bcd_result.admin_addr), &(msg_ptr->tel.tel_data_ptr[0]));
+        bcd_result.admin_addr   &= 0x0FFFU;
+        res_data.data_info       = &bcd_result;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.bcdiag, &res_data, true);
+    }
+}
+
+
+/*! \brief Handler function for EXC.BCDiag.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_BC_Diag_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.bcdiag, &res_data, true);
+    }
+}
+
+
+
+
+/*! \brief Handler function for EXC.BCEnableTx.Result
+ *  \param  self        Reference to EXC object
+ *  \param  msg_ptr     Received message
+ */
+static void Exc_BC_EnableTx_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    res_data.data_info       = NULL;
+    res_data.result.code     = UCS_RES_SUCCESS;
+    res_data.result.info_ptr = NULL;
+
+    Ssub_Notify(&self_->ssubs.enabletx, &res_data, true);
+
+    MISC_UNUSED(msg_ptr);
+}
+
+
+/*! \brief Handler function for EXC.BCEnableTx.Error
+ * \param  self     reference to EXC object
+ * \param  msg_ptr  received message
+ */
+static void Exc_BC_EnableTx_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.enabletx, &res_data, true);
+    }
+}
+
+
+/*! \brief Handler function for EXC.MemorySessionOpen.Result
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemSessionOpen_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    uint16_t session_handle;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        MISC_DECODE_WORD(&(session_handle),  &(msg_ptr->tel.tel_data_ptr[0]));
+        res_data.data_info       = &session_handle;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.memsessionopen, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_SESSION_OPEN);
+}
+
+
+/*! \brief Handler function for EXC.MemorySessionOpen.Error
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemSessionOpen_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.memsessionopen, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_SESSION_OPEN);
+}
+
+
+/*! \brief Handler function for EXC.MemorySessionClose.Result
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemSessionClose_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    uint8_t session_result;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        session_result = msg_ptr->tel.tel_data_ptr[0];
+        res_data.data_info       = &session_result;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.memsessionclose, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_SESSION_CLOSE);
+}
+
+/*! \brief Handler function for EXC.MemorySessionClose.Error
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemSessionClose_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.memsessionclose, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_SESSION_CLOSE);
+}
+
+/*! \brief Handler function for EXC.MemoryRead.Result
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemoryRead_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_MemReadResult_t mem_read_result; 
+    Exc_StdResult_t res_data;
+    uint8_t i;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        MISC_DECODE_WORD(&(mem_read_result.session_handle), &(msg_ptr->tel.tel_data_ptr[0]));
+        mem_read_result.mem_id = msg_ptr->tel.tel_data_ptr[2];
+        MISC_DECODE_DWORD(&(mem_read_result.address), &(msg_ptr->tel.tel_data_ptr[3]));
+        mem_read_result.unit_len = msg_ptr->tel.tel_data_ptr[7];
+        for (i=0U; (i<mem_read_result.unit_len) && (i<MAX_UNIT_LEN); ++i)
+        {
+            mem_read_result.unit_data[i] = msg_ptr->tel.tel_data_ptr[8U+i];
+        }
+
+        res_data.data_info       = &mem_read_result;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.memoryread, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_READ);
+}
+
+
+/*! \brief Handler function for EXC.MemoryRead.Error
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemoryRead_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.memoryread, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_READ);
+}
+
+
+/*! \brief Handler function for EXC.MemoryWrite.Result
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemoryWrite_Result(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_MemWriteResult_t mem_write_result; 
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        MISC_DECODE_WORD(&(mem_write_result.session_handle), &(msg_ptr->tel.tel_data_ptr[0]));
+        mem_write_result.mem_id = msg_ptr->tel.tel_data_ptr[2];
+
+        res_data.data_info       = &mem_write_result;
+        res_data.result.code     = UCS_RES_SUCCESS;
+        res_data.result.info_ptr = NULL;
+
+        Ssub_Notify(&self_->ssubs.memorywrite, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_WRITE);
+}
+
+
+/*! \brief Handler function for EXC.MemoryWrite.Error
+ *  \param  self     reference to EXC object
+ *  \param  msg_ptr  received message
+ */
+static void Exc_MemoryWrite_Error(void *self, Msg_MostTel_t *msg_ptr)
+{
+    CExc *self_ = (CExc *)self;
+    Exc_StdResult_t res_data;
+
+    if (msg_ptr->tel.tel_len > 0U)
+    {
+        res_data.data_info  = NULL;
+        res_data.result = Exc_TranslateError(self_,
+                                             &msg_ptr->tel.tel_data_ptr[0], 
+                                             (uint8_t)(msg_ptr->tel.tel_len));
+
+        Ssub_Notify(&self_->ssubs.memorywrite, &res_data, true);
+    }
+    Al_Release(&self_->lock.api, EXC_API_MEM_WRITE);
+}
+
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Helper functions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Translates EXC error codes into UNICENS error codes and wraps the raw INIC
+ *         error data to a byte stream.
+ *  \param self         Instance of CExc
+ *  \param error_data[] EXC error data
+ *  \param error_size   Size of EXC error data in bytes
+ *  \return             The formatted error
+ */
+static Ucs_StdResult_t Exc_TranslateError(CExc *self, uint8_t error_data[], uint8_t error_size)
+{
+    Ucs_StdResult_t ret_val;
+    MISC_UNUSED(self);
+
+    if(error_data[0] != 0x20U)
+    {
+        ret_val.code = UCS_RES_ERR_MOST_STANDARD;
+    }
+    else
+    {
+        ret_val.code = (Ucs_Result_t)(error_data[1] + 1U);
+    }
+
+    ret_val.info_ptr  = &error_data[0];
+    ret_val.info_size = error_size;
+
+    return ret_val;
+}
+
+
+/*! \brief  Reads a signature from a message's payload 
+ *
+ * \param dest      Pointer to signature 
+ * \param source    Pointer to start of signature inabyte array
+ */
+static void Exc_Read_Signature(Ucs_Signature_t *dest, uint8_t source[])
+{
+    MISC_DECODE_WORD(&(dest->node_address),  source);
+    MISC_DECODE_WORD(&(dest->group_address), &(source[2]));
+    MISC_DECODE_WORD(&(dest->mac_47_32),     &(source[4]));
+    MISC_DECODE_WORD(&(dest->mac_31_16),     &(source[6]));
+    MISC_DECODE_WORD(&(dest->mac_15_0),      &(source[8]));
+    MISC_DECODE_WORD(&(dest->node_pos_addr), &(source[10]));
+    MISC_DECODE_WORD(&(dest->diagnosis_id),  &(source[12]));
+    dest->num_ports  = source[14];
+    dest->chip_id    = source[15];
+    dest->fw_major   = source[16];
+    dest->fw_minor   = source[17];
+    dest->fw_release = source[18];
+    MISC_DECODE_DWORD(&(dest->fw_build),  &(source[19]));
+    dest->cs_major   = source[23];
+    dest->cs_minor   = source[24];
+    dest->cs_release = source[25];
+/*    dest->uid_persistency = source[26];*/                 /* Signature v1 */
+/*    MISC_DECODE_DWORD(&(dest->uid),  &(source[27]));*/
+
+}
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+