src: unicens: import sources

This patch adds the source tree of the NetworkManager v3.0.4.
Additionally, it provides the needed configuration scripts.

Change-Id: I23778b51423b51a4f87741957e0fb208bceb79b3
Signed-off-by: Christian Gromm <christian.gromm@microchip.com>

58 files changed, 13402 insertions, 0 deletions

diff --git a/mnsl/mns_alm.c b/mnsl/mns_alm.c
new file mode 100644
index 0000000..5c5e76d
--- /dev/null
+++ b/mnsl/mns_alm.c
@@ -0,0 +1,277 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the API locking manager.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_ALM
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_alm.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constant                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Interval for garbage collection */
+static const uint16_t ALM_GARBAGE_COLLECTOR_INTERVAL = 2600U;   /* parasoft-suppress  MISRA2004-8_7 "Value shall be part of the module, not part of a function." */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Alm_HandleInternalErrors(void *self, void *error_code_ptr);
+static void Alm_GarbageCollector(void *self);
+static bool Alm_CheckRegisteredApi(void *current_alm_ptr, void *alm_inst_ptr);
+static void Alm_StartTimeout(CApiLockingManager *self);
+static void Alm_ClearTimeout(CApiLockingManager *self);
+static bool Alm_SearchLockedApi(void *current_alm_ptr, void *alm_inst_ptr);
+static void Alm_ResetRegisteredApis(CApiLockingManager *self);
+static bool Alm_ResetApi(void *current_alm_ptr, void *alm_inst_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CApiLockingManager                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of the API locking manager class.
+ *  \param  self        Instance pointer
+ *  \param  tm_ptr      Reference to timer management instance
+ *  \param  eh_ptr      Reference to event handler instance
+ *  \param  mns_inst_id MOST NetServices instance ID
+ */
+void Alm_Ctor(CApiLockingManager *self,
+              CTimerManagement *tm_ptr,
+              CEventHandler *eh_ptr,
+              uint8_t mns_inst_id)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    T_Ctor(&self->garbage_collector);
+    self->tm_ptr = tm_ptr;
+    self->eh_ptr = eh_ptr;
+    self->mns_inst_id = mns_inst_id;
+
+    /* Observe internal errors and events */
+    Mobs_Ctor(&self->internal_error_obs, self, EH_M_TERMINATION_EVENTS, &Alm_HandleInternalErrors);
+    Eh_AddObsrvInternalEvent(self->eh_ptr, &self->internal_error_obs);
+}
+
+/*! \brief  Handles internal errors and events
+ *  \param  self            Instance pointer
+ *  \param  error_code_ptr  Reference to reported error code
+ */
+static void Alm_HandleInternalErrors(void *self, void *error_code_ptr)
+{
+    CApiLockingManager *self_ = (CApiLockingManager *)self;
+    MISC_UNUSED(error_code_ptr);
+
+    Tm_ClearTimer(self_->tm_ptr, &self_->garbage_collector);    /* Clear timeout */
+    Alm_ResetRegisteredApis(self_);                             /* Reset all registered APIs */
+}
+
+/*! \brief  Checks for API locking timeouts. This method is the callback function of timer 
+ *          \c garbage_collector.
+ *  \param  self    Instance pointer
+ */
+static void Alm_GarbageCollector(void *self)
+{
+    CApiLockingManager *self_ = (CApiLockingManager *)self;
+    (void)Dl_Foreach(&self_->api_list, &Alm_CheckRegisteredApi, self_);
+}
+
+/*! \brief  This method is used by Alm_GarbageCollector() to process each registered API.
+ *  \param  current_alm_ptr     Reference to the current API
+ *  \param  alm_inst_ptr        Instance of the API locking manager
+ *  \return \c false to process all registered APIs
+ */
+static bool Alm_CheckRegisteredApi(void *current_alm_ptr, void *alm_inst_ptr)
+{
+    CApiLockingManager *self = (CApiLockingManager *)alm_inst_ptr;
+    CApiLocking *alm_ptr_ = (CApiLocking *)current_alm_ptr;
+    MISC_UNUSED(self);
+
+    if(alm_ptr_->timeout_mask != 0U)
+    {
+        Alm_ModuleMask_t tmp_mask = 1U;
+        while(alm_ptr_->timeout_mask != 0U)
+        {
+            if(tmp_mask == (tmp_mask & alm_ptr_->timeout_mask))
+            {
+                Ssub_Notify(&alm_ptr_->subject, &tmp_mask, false);
+                alm_ptr_->method_mask &= ~tmp_mask;
+                alm_ptr_->timeout_mask &= ~tmp_mask;
+            }
+            tmp_mask <<= 1;
+        }
+        Alm_ClearTimeout(self);
+    }
+    if(alm_ptr_->method_mask != 0U)
+    {
+        alm_ptr_->timeout_mask = alm_ptr_->method_mask;
+    }
+    return false;
+}
+
+/*! \brief  Registers a new API locking object.
+ *  \param  self    Instance pointer
+ *  \param  al_ptr  Reference to the API to register
+ */
+void Alm_RegisterApi(CApiLockingManager *self, CApiLocking *al_ptr)
+{
+    Dl_InsertTail(&self->api_list, &al_ptr->node);
+    Dln_SetData(&al_ptr->node, al_ptr);
+    al_ptr->alm_ptr = self;
+}
+
+/*! \brief  Starts the garbage collecting timer.
+ *  \param  self    Instance pointer
+ */
+static void Alm_StartTimeout(CApiLockingManager *self)
+{
+    if(T_IsTimerInUse(&self->garbage_collector) == false)
+    {
+        Tm_SetTimer(self->tm_ptr,
+                    &self->garbage_collector,
+                    &Alm_GarbageCollector,
+                    self,
+                    ALM_GARBAGE_COLLECTOR_INTERVAL,
+                    ALM_GARBAGE_COLLECTOR_INTERVAL);
+    }
+}
+
+/*! \brief  Clears the garbage collecting timer. The timer is clear if no API locking flag is 
+ *          currently pending.
+ *  \param  self    Instance pointer
+ */
+static void Alm_ClearTimeout(CApiLockingManager *self)
+{
+    if(NULL == Dl_Foreach(&self->api_list, &Alm_SearchLockedApi, self))
+    {
+        Tm_ClearTimer(self->tm_ptr, &self->garbage_collector);
+    }
+}
+
+/*! \brief  Used by Alm_ClearTimeout() to check if at least one registered API is locked.
+ *  \param  current_alm_ptr     Reference to the current API locking object
+ *  \param  alm_inst_ptr        Instance of the API locking manager
+ *  \return \c true if a locked API was found, otherwise \c false
+ */
+static bool Alm_SearchLockedApi(void *current_alm_ptr, void *alm_inst_ptr)
+{
+    CApiLocking *alm_ptr_ = (CApiLocking *)current_alm_ptr;
+    bool ret_val = false;
+    MISC_UNUSED(alm_inst_ptr);
+
+    if(alm_ptr_->method_mask != 0U)
+    {
+        ret_val = true;
+    }
+    return ret_val;
+}
+
+/*! \brief  Resets all registered APIs. Called if an internal error has been occurred.
+ *  \param  self    Instance pointer
+ */
+static void Alm_ResetRegisteredApis(CApiLockingManager *self)
+{
+    (void)Dl_Foreach(&self->api_list, &Alm_ResetApi, self);
+}
+
+/*! \brief  Used by Alm_ResetRegisteredApis() to reset all registered APIs.
+ *  \param  current_alm_ptr     Reference to the current API locking object
+ *  \param  alm_inst_ptr        Instance of the API locking manager
+ *  \return \c false (process all registered APIs)
+ */
+static bool Alm_ResetApi(void *current_alm_ptr, void *alm_inst_ptr)
+{
+    CApiLocking *alm_ptr_ = (CApiLocking *)current_alm_ptr;
+    MISC_UNUSED(alm_inst_ptr);
+
+    alm_ptr_->method_mask = 0U;
+    alm_ptr_->timeout_mask = 0U;
+
+    return false;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CApiLocking                                                            */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of the API locking class.
+ *  \param  self            Instance pointer
+ *  \param  obs_ptr         Observer to signal locked API methods
+ *  \param  mns_inst_id     MOST NetServices instance ID
+ */
+void Al_Ctor(CApiLocking *self, CSingleObserver *obs_ptr, uint8_t mns_inst_id)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->mns_inst_id = mns_inst_id;
+    Dln_Ctor(&self->node, NULL);
+    if(obs_ptr != NULL)
+    {
+        Ssub_Ctor(&self->subject, self->mns_inst_id);
+        (void)Ssub_AddObserver(&self->subject, obs_ptr);
+    }
+}
+
+/*! \brief  Locks the given API method.
+ *  \param  self    Instance pointer
+ *  \param  method  Bitmask of method to lock
+ *  \return \c true if the API has been locked successfully
+ *  \return \c false if the API was already locked
+ */
+bool Al_Lock(CApiLocking *self, Alm_ModuleMask_t method)
+{
+    bool ret_val = false;
+    if((self->method_mask & method) == 0U)
+    {
+        ret_val = true;
+        self->method_mask |= method;
+        self->timeout_mask &= ~method;
+        Alm_StartTimeout(self->alm_ptr);
+    }
+    return ret_val;
+}
+
+/*! \brief  Releases the lock of the given API method.
+ *  \param  self    Instance pointer
+ *  \param  method  Bitmask of method to lock
+ */
+void Al_Release(CApiLocking *self, Alm_ModuleMask_t method)
+{
+    self->method_mask &= ~method;
+    self->timeout_mask &= ~method;
+    Alm_ClearTimeout(self->alm_ptr);
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_alm.h b/mnsl/mns_alm.h
new file mode 100644
index 0000000..92e3e46
--- /dev/null
+++ b/mnsl/mns_alm.h
@@ -0,0 +1,113 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the API locking module.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_ALM
+ * @{
+ */
+
+#ifndef MNS_ALM_H
+#define MNS_ALM_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_eh.h"
+#include "mns_timer.h"
+#include "mns_obs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Type definitions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Bitmask used to store locked API methods */
+typedef uint32_t Alm_ModuleMask_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Class structure of the API locking manager */
+typedef struct CApiLockingManager_
+{
+    CTimerManagement *tm_ptr;           /*!< \brief Reference to timer management instance */
+    CEventHandler *eh_ptr;              /*!< \brief Reference to event handler instance */
+    CTimer garbage_collector;           /*!< \brief Timer for garbage collection */
+    CDlList api_list;                   /*!< \brief List of registered APIs */
+    uint8_t mns_inst_id;                /*!< \brief MOST NetServices instance ID */
+    CMaskedObserver internal_error_obs; /*!< \brief Error observer to handle internal errors and 
+                                                    events */
+
+} CApiLockingManager;
+
+/*! \brief  Class structure of the API locking */
+typedef struct CApiLocking_
+{
+    CDlNode node;                       /*!< \brief Node of the doubly linked (API-) list */
+    CApiLockingManager *alm_ptr;        /*!< \brief Reference to CApiLockingManager instance */
+    Alm_ModuleMask_t method_mask;       /*!< \brief Bitmask which holds locked API methods */
+    Alm_ModuleMask_t timeout_mask;      /*!< \brief Bitmask to report timeouts */
+    CSingleSubject subject;             /*!< \brief Subject to update registered observer */
+    uint8_t mns_inst_id;                /*!< \brief MOST NetServices instance ID */
+
+} CApiLocking;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CApiLockingManager                                                         */
+/*------------------------------------------------------------------------------------------------*/
+extern void Alm_Ctor(CApiLockingManager *self,
+                     CTimerManagement *tm_ptr,
+                     CEventHandler *eh_ptr,
+                     uint8_t mns_inst_id);
+extern void Alm_RegisterApi(CApiLockingManager *self, CApiLocking *al_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CApiLocking                                                                */
+/*------------------------------------------------------------------------------------------------*/
+extern void Al_Ctor(CApiLocking *self, CSingleObserver *obs_ptr, uint8_t mns_inst_id);
+extern bool Al_Lock(CApiLocking *self, Alm_ModuleMask_t method);
+extern void Al_Release(CApiLocking *self, Alm_ModuleMask_t method);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_ALM_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_ams.c b/mnsl/mns_ams.c
new file mode 100644
index 0000000..338047b
--- /dev/null
+++ b/mnsl/mns_ams.c
@@ -0,0 +1,665 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Application Message Service
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_AMSC
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_ams.h"
+#include "mns_amsmessage.h"
+#include "mns_dl.h"
+#include "mns_misc.h"
+#include "mns_pmp.h"
+#include "mns_encoder.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Priority of the Application Message Service */
+static const uint8_t     AMS_SRV_PRIO       = 253U; /* parasoft-suppress  MISRA2004-8_7 "configuration property" */
+/*! \brief Event which triggers the Rx service */
+static const Srv_Event_t AMS_EV_RX_SERVICE  = 1U;
+/*! \brief Event which triggers the Tx service */
+static const Srv_Event_t AMS_EV_TX_SERVICE  = 2U;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Ams_Cleanup(CAms *self);
+static void Ams_Service(void *self);
+static void Ams_OnEhEvent(void *self, void *error_code_ptr);
+
+static void Ams_TxService(CAms *self);
+static void Ams_TxOnStatus(void *self, Msg_MostTel_t *tel_ptr, Mns_MsgTxStatus_t status);
+static uint8_t Ams_TxGetNextFollowerId(CAms *self);
+
+static void Ams_RxOnTelComplete(CAms *self, Msg_MostTel_t *tel_ptr);
+static void Ams_RxReleaseTel(CAms *self, Msg_MostTel_t *tel_ptr);
+static void Ams_RxProcessWaitingQ(CAms *self);
+static void Ams_RxOnSegError(void *self, Msg_MostTel_t *tel_ptr, Segm_Error_t error);
+static void Ams_RxOnFreedMsg(void *self, void *data_ptr);
+static void Ams_RxFlush(CAms *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Initialization Methods                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of class CAms
+ *  \param self              The instance
+ *  \param base_ptr          Reference to base services
+ *  \param mcm_trcv_ptr      Reference to the MCM transceiver
+ *  \param rcm_trcv_ptr      Reference to the RCM transceiver
+ *  \param pool_ptr          Reference to the pool for application message handles
+ *  \param rx_def_payload_sz Default memory size that is allocated when receiving segmented messages 
+ *                           without size prefix
+ */
+void Ams_Ctor(CAms *self, CBase *base_ptr, CTransceiver *mcm_trcv_ptr, CTransceiver *rcm_trcv_ptr,
+              CAmsMsgPool *pool_ptr, uint16_t rx_def_payload_sz)
+{
+    MISC_UNUSED(rcm_trcv_ptr);
+    MISC_MEM_SET((void *)self, 0, sizeof(*self));                           /* reset members to "0" */
+    self->trcv_mcm_ptr = mcm_trcv_ptr;
+    self->trcv_rcm_ptr = rcm_trcv_ptr;
+    self->base_ptr = base_ptr;
+    self->pool_ptr = pool_ptr;
+
+    self->tx.default_llrbc = AMS_LLRBC_DEFAULT;                             /* set initial retries */
+    self->tx.next_follower_id = 1U;                                         /* set initial follower id */
+                                                                            /* init pools */
+    Obs_Ctor(&self->rx.message_freed_observer, self, &Ams_RxOnFreedMsg);
+    Amsp_AssignRxFreedObs(self->pool_ptr, &self->rx.message_freed_observer);
+    Telq_Ctor(&self->rx.waiting_queue, self->base_ptr->mns_inst_id);        /* init Rx waiting queue */
+
+    Dl_Ctor(&self->tx.queue, self->base_ptr->mns_inst_id);
+
+    Srv_Ctor(&self->service, AMS_SRV_PRIO, self, &Ams_Service);             /* register service */
+    (void)Scd_AddService(&self->base_ptr->scd, &self->service);
+
+    Segm_Ctor(&self->segmentation, self->base_ptr,  self->pool_ptr, rx_def_payload_sz);
+    Segm_AssignRxErrorHandler(&self->segmentation, &Ams_RxOnSegError, self);
+
+    if (self->trcv_mcm_ptr != NULL)
+    {
+        Trcv_RxAssignReceiver(self->trcv_mcm_ptr, &Ams_RxOnMcmTelComplete, self);
+    }
+    if (self->trcv_rcm_ptr != NULL)
+    {
+        Trcv_RxAssignReceiver(self->trcv_rcm_ptr, &Ams_RxOnRcmTelComplete, self);
+    }    
+
+    Mobs_Ctor(&self->unsync_result_observer, self, EH_M_TERMINATION_EVENTS, &Ams_OnEhEvent);     /* register error observer */
+    Eh_AddObsrvInternalEvent(&self->base_ptr->eh, &self->unsync_result_observer);
+}
+
+/*! \brief Sets the default retry values used for Application Messages
+ *  \param self         The instance
+ *  \param llrbc        The default low level retry block count
+ */
+void Ams_TxSetDefaultRetries(CAms* self, uint8_t llrbc)
+{
+    self->tx.default_llrbc = llrbc;
+}
+
+/*! \brief  Assigns a function of another class to receive application messages 
+ *  \param  self            The instance
+ *  \param  cb_fptr         Callback function
+ *  \param  inst_ptr        The instance of the receiver class
+ */
+void Ams_RxAssignReceiver(CAms *self, Amsg_RxCompleteCb_t cb_fptr, void *inst_ptr)
+{
+    self->rx.complete_fptr = cb_fptr;
+    self->rx.complete_inst_ptr = inst_ptr;
+}
+
+/*! \brief   Assigns an observer which is invoked if a Tx application message is freed.
+ *  \details The observer is only notified a previous allocation of a Tx object has failed.
+ *           The data_ptr of the update callback function is not used (always \c NULL).
+ *           See \ref Obs_UpdateCb_t.
+ *  \param   self            The instance
+ *  \param   observer_ptr    The observer
+ */
+void Ams_TxAssignMsgFreedObs(CAms *self, CObserver *observer_ptr)
+{
+    Amsp_AssignTxFreedObs(self->pool_ptr, observer_ptr);
+}
+
+/*! \brief   Assigns a callback function that selects FIFO routing for a Tx message.
+ *  \details If no callback function is assigned, then all Tx messages are routed to RCM FIFO.
+ *  \param   self       The instance
+ *  \param   cb_fptr    The callback function
+ */
+void Ams_TxAssignTrcvSelector(CAms *self, Ams_TxIsRcmMsgCb_t cb_fptr)
+{
+    self->tx.is_rcm_fptr = cb_fptr;
+}
+
+/*! \brief  Performs a cleanup of the Tx message queue and notifies 
+ *          the transmission error MNS_AMSTX_RES_NOT_AVAILABLE.
+ *  \param  self    The instance
+ */
+static void Ams_Cleanup(CAms *self)
+{
+    Mns_AmsTx_Msg_t *tx_ptr = NULL;
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Starting AMS Cleanup", 0U));
+                                                    /* cleanup Tx queue */
+    for (tx_ptr = Amsg_TxDequeue(&self->tx.queue); tx_ptr != NULL; tx_ptr = Amsg_TxDequeue(&self->tx.queue))
+    {
+        /* just just notify completion, the object is automatically freed to the pool */
+        Amsg_TxNotifyComplete(tx_ptr, MNS_AMSTX_RES_ERR_NOT_AVAILABLE, MNS_AMSTX_I_ERR_UNSYNCED);
+    }
+
+    Segm_Cleanup(&self->segmentation);              /* cleanup Rx */
+    Ams_RxFlush(self);
+    Amsp_Cleanup(self->pool_ptr);                   /* final cleanup of pool */
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Finished AMS Cleanup", 0U));
+}
+
+/*! \brief  Callback function which is invoked by the event handler
+ *          on any termination event.
+ *  \param  self            The instance
+ *  \param  error_code_ptr  Reference to the error code
+ */
+static void Ams_OnEhEvent(void *self, void *error_code_ptr)
+{
+    CAms *self_ = (CAms*)self;
+    MISC_UNUSED(error_code_ptr);
+    Ams_Cleanup(self_);
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Service                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief The AMS service function 
+ *  \param self The instance
+ */
+static void Ams_Service(void *self)
+{
+    CAms *self_ = (CAms*)self;
+    Srv_Event_t event_mask;
+    Srv_GetEvent(&self_->service, &event_mask);
+
+    if (AMS_EV_TX_SERVICE == (event_mask & AMS_EV_TX_SERVICE))     /* Is event pending? */
+    {
+        Srv_ClearEvent(&self_->service, AMS_EV_TX_SERVICE);
+        Ams_TxService(self_);
+    }
+
+    if (AMS_EV_RX_SERVICE == (event_mask & AMS_EV_RX_SERVICE))     /* Is event pending? */
+    {
+        Srv_ClearEvent(&self_->service, AMS_EV_RX_SERVICE);
+        Ams_RxProcessWaitingQ(self_);
+    }
+}
+
+/*! \brief Allocates and transmits MCMs for the dedicated Application Messages 
+ *  \param self The instance
+ */
+static void Ams_TxService(CAms *self)
+{
+    CDlNode *node1_ptr;
+                                                                    /* run as long as messages are available in Tx queue */
+    for (node1_ptr = Dl_PeekHead(&self->tx.queue); node1_ptr != NULL; node1_ptr = Dl_PeekHead(&self->tx.queue))
+    {
+    Msg_MostTel_t *tel_ptr = NULL;
+        CTransceiver *trcv_ptr = self->trcv_mcm_ptr;
+        Mns_AmsTx_Msg_t *tx_ptr = (Mns_AmsTx_Msg_t*)Dln_GetData(node1_ptr);
+
+        if (self->tx.is_rcm_fptr != NULL)
+        {
+            if (self->tx.is_rcm_fptr(tx_ptr) != false)
+            {
+                trcv_ptr = self->trcv_rcm_ptr;
+            }
+        }
+                                                                    /* allocate telegram object with 2 bytes for TelId 4 */
+        tel_ptr = Trcv_TxAllocateMsg(trcv_ptr, 2U);                 /* remaining message payload is attached as external memory */
+
+        if (tel_ptr != NULL)                                    /* transmit message if telegram object is available */
+        {
+            bool done;
+            CDlNode *node2_ptr = Dl_PopHead(&self->tx.queue);                   /* get application message from queue */
+ 
+            TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (node1_ptr == node2_ptr));
+            tx_ptr = (Mns_AmsTx_Msg_t*)Dln_GetData(node2_ptr);
+            done = Segm_TxBuildSegment(&self->segmentation, tx_ptr, tel_ptr); /* run segmentation */
+            Trcv_TxSendMsgExt(trcv_ptr, tel_ptr, &Ams_TxOnStatus, self);        /* transmit telegram */
+            TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Ams_TxService(tel_ptr=0x%p)", 1U, tel_ptr));
+
+            if (done == false)
+            {
+                Dl_InsertHead(&self->tx.queue, node2_ptr);
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* AMS Tx handles                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Retrieves a message Tx handle
+ *  \details The payload provided is limited the supported size of the memory management.
+ *           The application may also attach own payload to a message object. Therefore, 
+ *           Ams_TxGetMsg() shall be called with size "0".
+ *  \param   self   The instance
+ *  \param   size   Payload size in bytes or "0" to use application provided payload.
+ *                  The payload provided by MNS is limited to a size of 45 bytes.
+ *                  Valid values: 0..45.
+ *  \return  A Tx message object or \c NULL if no message object is available.
+ */
+Mns_AmsTx_Msg_t * Ams_TxGetMsg(CAms *self, uint16_t size)
+{
+    Mns_AmsTx_Msg_t * msg_ptr = Amsp_AllocTxObj(self->pool_ptr, size);
+
+    if (msg_ptr != NULL)
+    {
+        msg_ptr->destination_address = AMS_ADDR_RSVD_RANGE; /* set invalid address to prevent internal transmission*/
+        msg_ptr->llrbc = self->tx.default_llrbc;
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Frees an unused or completed Tx message to the pool
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the related message object
+ */
+void Ams_TxFreeUnusedMsg(CAms *self, Mns_AmsTx_Msg_t *msg_ptr)
+{
+    MISC_UNUSED(self);
+    Amsg_TxFreeUnused(msg_ptr);     /* the object is automatically freed to the pool */
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* AMS Transmission                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Transmits a MOST Application Message 
+ *  \details    After the transmission completed the function will call one callback function. Therefore
+ *              the caller is able to assign one of two different callback function. The difference between
+ *              the callback function is that tx_complete_sia_fptr does no provide a self pointer whether 
+ *              tx_complete_fptr and tx_complete_inst_ptr allow to invoke a class method.
+ *  \param  self                    The instance
+ *  \param  msg_ptr                 Reference to the related message object
+ *  \param  tx_complete_sia_fptr    Single instance API callback function which is invoked as soon as 
+ *                                  the transmission was finished.
+ *  \param  tx_complete_fptr        Multi instance callback function which is invoked as soon as 
+ *                                  the transmission was finished.
+ *  \param  tx_complete_inst_ptr    Instance pointer which is referred when tx_complete_fptr is invoked. 
+ *  \return Possible return values are
+ *          - \c MNS_RET_SUCCESS if the transmission was started successfully
+ *          - \c MNS_RET_ERR_PARAM if the transmission was refused due to an invalid parameter
+ */
+Mns_Return_t Ams_TxSendMsg(CAms *self, Mns_AmsTx_Msg_t *msg_ptr, Amsg_TxCompleteSiaCb_t tx_complete_sia_fptr, 
+                           Amsg_TxCompleteCb_t tx_complete_fptr, void* tx_complete_inst_ptr)
+{
+    Mns_Return_t ret_val = MNS_RET_ERR_PARAM;
+
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Called Ams_TxSendMsg(0x%p)", 1U, msg_ptr));
+
+    if (Ams_TxIsValidMessage(msg_ptr))                      /* prevent application messages to loc. INIC */
+    {                                                       /* do not set both callback pointers */
+        TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (((tx_complete_sia_fptr != NULL) && (tx_complete_fptr != NULL)) == false))
+        Amsg_TxSetCompleteCallback(msg_ptr, tx_complete_sia_fptr, tx_complete_fptr, tx_complete_inst_ptr);
+        Ams_TxSendMsgDirect(self, msg_ptr);
+        ret_val = MNS_RET_SUCCESS;
+    }
+
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (ret_val == MNS_RET_SUCCESS));
+
+    return ret_val;
+}
+
+/*! \brief          Transmits a MOST Application Message without attributes check
+ *  \details        This method shall be only be used by AMD and AMS internally
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the related message object
+ */
+void Ams_TxSendMsgDirect(CAms *self, Mns_AmsTx_Msg_t *msg_ptr)
+{
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Called Ams_TxSendMsg(0x%p)", 1U, msg_ptr));
+
+    if (msg_ptr->data_size > SEGM_MAX_SIZE_TEL)                         /* set follower id to be used for all segments */
+    {
+        Amsg_TxSetFollowerId(msg_ptr, Ams_TxGetNextFollowerId(self));
+    }
+
+    Amsg_TxEnqueue(msg_ptr, &self->tx.queue);                           /* schedule transmission */
+    Srv_SetEvent(&self->service, AMS_EV_TX_SERVICE);
+}
+
+/*! \brief  Callback function which is invoked as soon as MCM transmission
+ *          was finished in PMS. 
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the telegram
+ *  \param  status  Transmission status
+ */
+static void Ams_TxOnStatus(void *self, Msg_MostTel_t *tel_ptr, Mns_MsgTxStatus_t status)
+{ 
+    CAms *self_ = (CAms*)self;
+    Mns_AmsTx_Msg_t* msg_ptr = (Mns_AmsTx_Msg_t*)tel_ptr->info_ptr;
+
+    TR_INFO((self_->base_ptr->mns_inst_id, "[AMS]", "Ams_TxOnStatus(tel_ptr=0x%p, %d)", 2U, tel_ptr, status));
+
+    if (msg_ptr != NULL)                                                                                      /* MOST Telegram has AMS parent? */
+    {
+        Amsg_TxUpdateResult(msg_ptr, status);
+ 
+        if ((0U == tel_ptr->tel.tel_id) || (3U == tel_ptr->tel.tel_id))                                       /* is finished? */
+        {                                                                                                     /* just just notify completion, the object is */
+            Amsg_TxNotifyComplete(msg_ptr, Amsg_TxGetResultCode(msg_ptr), Amsg_TxGetResultInfo(msg_ptr));     /* automatically freed to the pool */
+        }
+        else if (status != MNS_MSG_STAT_OK)                                                                     /* check transmission needs termination before transmission end */
+        {
+            TR_ASSERT(self_->base_ptr->mns_inst_id, "[AMS]", (Amsg_TxGetFollowerId(msg_ptr) != 0U));
+ 
+            if (((uint8_t)Amsg_TxGetNextSegmCnt(msg_ptr) == (uint8_t)(tel_ptr->tel.tel_cnt + 1U))             /* is last transmitted segment */
+                || ((Amsg_TxGetNextSegmCnt(msg_ptr) == 0U) && (4U == tel_ptr->tel.tel_id)))                   /* or TelId 4 and the first segment is pending */
+            {
+                Amsg_TxRemoveFromQueue(msg_ptr, &self_->tx.queue);
+                Amsg_TxNotifyComplete(msg_ptr, Amsg_TxGetResultCode(msg_ptr), Amsg_TxGetResultInfo(msg_ptr)); /* just just notify completion, the object is */
+            }                                                                                                 /* automatically freed to the pool */
+        }
+    }
+    Trcv_TxReleaseMsg(tel_ptr);                                                                               /* release message object to pool */
+
+    if ((Dl_GetSize(&self_->tx.queue) > 0U) && (status != MNS_MSG_STAT_ERROR_SYNC))                             /* Application Messages are available for Tx */
+    {
+        Srv_SetEvent(&self_->service, AMS_EV_TX_SERVICE);
+    }
+}
+
+/*! \brief   Checks if the destination address of the Tx message is valid and payload is consistent
+ *  \param   msg_ptr    Reference to the Tx message object
+ *  \return  Returns \c true if the destination is correct, otherwise \c false.
+ */
+bool Ams_TxIsValidMessage(Mns_AmsTx_Msg_t *msg_ptr)
+{
+    bool ret = false;
+ 
+    if (msg_ptr != NULL)
+    {
+        if ((msg_ptr->destination_address == MNS_ADDR_INTERNAL)
+           ||(msg_ptr->destination_address > AMS_ADDR_RSVD_RANGE))    /* is not reserved address? */
+        {
+            if (((msg_ptr->destination_address & 0xFF00U) !=  0x0300U)/* is single-cast? */
+               || (msg_ptr->data_size <= SEGM_MAX_SIZE_TEL))          /* or not segmented */ 
+            {
+                if (!((msg_ptr->data_size > 0U) && (msg_ptr->data_ptr == NULL)))
+                {
+                    ret = true;
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+/*! \brief   Retrieves the next follower id to use for segmented transfer 
+ *  \param   self   The instance
+ *  \return  The follower id
+ */
+static uint8_t Ams_TxGetNextFollowerId(CAms *self)
+{
+    uint8_t ret;
+    ret = self->tx.next_follower_id;
+    self->tx.next_follower_id++;
+
+    if (self->tx.next_follower_id == 0U)    /* skip zero since it means */
+    {                                       /* "no follower" */
+        self->tx.next_follower_id = 1U;
+    }
+ 
+    return ret;
+}
+
+/*! \brief   Retrieves the number of messages that are queued for transmission 
+ *  \param   self   The instance
+ *  \return  The number of messages in the Tx queue
+ */
+uint16_t Ams_TxGetMsgCnt(CAms *self)
+{
+    return Dl_GetSize(&self->tx.queue);
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* AMS Reception                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Rx callback function that can be assigned to the MCM transceiver
+ *  \details The associated transceiver reference will be stored in the telegrams \c info_ptr.
+ *           Later on the telegram must be released via Ams_RxReleaseTel().
+ *  \param  self    The instance
+ *  \param   tel_ptr Reference to the Rx telegram object
+ */
+void Ams_RxOnMcmTelComplete(void *self, Msg_MostTel_t *tel_ptr)
+{
+    CAms *self_ = (CAms*)self;
+    TR_ASSERT(self_->base_ptr->mns_inst_id, "[AMS]", (tel_ptr->info_ptr == NULL));
+    tel_ptr->info_ptr = self_->trcv_mcm_ptr;
+    Ams_RxOnTelComplete(self_, tel_ptr);
+}
+
+/*! \brief   Rx callback function that can be assigned to the RCM transceiver
+ *  \details The associated transceiver reference will be stored in the telegrams \c info_ptr.
+ *           Later on the telegram must be released via Ams_RxReleaseTel().
+ *  \param   self    The instance
+ *  \param   tel_ptr Reference to the Rx telegram object
+ */
+void Ams_RxOnRcmTelComplete(void *self, Msg_MostTel_t *tel_ptr)
+{
+    CAms *self_ = (CAms*)self;
+    TR_ASSERT(self_->base_ptr->mns_inst_id, "[AMS]", (tel_ptr->info_ptr == NULL));
+    tel_ptr->info_ptr = self_->trcv_rcm_ptr;
+    Ams_RxOnTelComplete(self_, tel_ptr);
+}
+
+/*! \brief   Releases an Rx telegram to the associated transceiver
+ *  \details The associated transceiver reference is stored in the telegrams \c info_ptr
+ *  \param   self    The instance
+ *  \param   tel_ptr Reference to the Rx telegram object
+ */
+static void Ams_RxReleaseTel(CAms *self, Msg_MostTel_t *tel_ptr)
+{
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", ((tel_ptr != NULL) && (tel_ptr->info_ptr != NULL)));
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", ((tel_ptr->info_ptr == self->trcv_mcm_ptr)||(tel_ptr->info_ptr == self->trcv_rcm_ptr)));
+
+    if (tel_ptr->info_ptr != NULL)
+    {
+        Trcv_RxReleaseMsg((CTransceiver*)tel_ptr->info_ptr, tel_ptr);
+    }
+
+    MISC_UNUSED(self);
+}
+
+/*! \brief  Internal callback function which is invoked as soon as the transceiver
+ *          reference is stored to the telegrams info_ptr.
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the Rx telegram object
+ */
+static void Ams_RxOnTelComplete(CAms *self, Msg_MostTel_t *tel_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Ams_RxOnComplete(0x%p)", 1U, tel_ptr));
+
+    if (self->rx.complete_fptr == NULL)
+    {
+        /* no processing required, tel_ptr shall be freed */
+        msg_ptr = NULL;
+    }
+    else if (Telq_GetSize(&self->rx.waiting_queue) > 0U)    /* asynchronous Rx is running */
+    {                                                       /* queue Rx telegram for later processing */
+        Telq_Enqueue(&self->rx.waiting_queue, tel_ptr);
+        tel_ptr = NULL;                                     /* do not free Rx telegram */
+        msg_ptr = NULL;
+    }
+    else
+    {
+        Segm_Result_t result;                               /* synchronous processing is possible now */
+        msg_ptr = Segm_RxExecuteSegmentation(&self->segmentation, tel_ptr, &result);
+
+        if (result == SEGM_RES_RETRY)
+        {
+            TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (msg_ptr == NULL));
+            Telq_Enqueue(&self->rx.waiting_queue, tel_ptr);
+            tel_ptr = NULL;                                 /* do not free Rx telegram */
+        }
+    }
+
+    if (msg_ptr != NULL)
+    {
+        self->rx.complete_fptr(self->rx.complete_inst_ptr, (Mns_AmsRx_Msg_t*)(void*)msg_ptr);
+    }
+
+    if (tel_ptr != NULL)
+    {
+        Ams_RxReleaseTel(self, tel_ptr);                    /* free Rx telegram */
+    }
+}
+
+/*! \brief   Processes all telegrams in waiting queue
+ *  \details Stops if allocation of Rx messages fails
+ *  \param   self    The instance
+ */
+static void Ams_RxProcessWaitingQ(CAms *self)
+{
+    Msg_MostTel_t *tel_ptr;
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+
+    for (tel_ptr = Telq_Peek(&self->rx.waiting_queue); tel_ptr != NULL; tel_ptr = Telq_Peek(&self->rx.waiting_queue))
+    {
+        Segm_Result_t result;
+        msg_ptr = Segm_RxExecuteSegmentation(&self->segmentation, tel_ptr, &result);
+
+        if (result == SEGM_RES_OK)                                              /* segmentation process succeeded */
+        {
+            (void)Telq_Dequeue(&self->rx.waiting_queue);                        /* remove telegram from waitingQ */
+            Ams_RxReleaseTel(self, tel_ptr);                                    /* free telegram */
+            tel_ptr = NULL;                                                     /* parasoft-suppress  MISRA2004-13_6 "variable is not used as a counter" */
+
+            if (msg_ptr != NULL)
+            {
+                self->rx.complete_fptr(self->rx.complete_inst_ptr, (Mns_AmsRx_Msg_t*)(void*)msg_ptr);
+            }
+        }
+        else
+        {
+            TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (msg_ptr == NULL));
+            break;                                                              /* wait until further Rx messages can be allocated - abort loop */
+        }
+    }
+}
+
+/*! \brief  Callback function which is invoked by segmentation process to notify a segmentation error 
+ *  \param  self    The instance
+ *  \param  tel_ptr The related Rx telegram which caused the segmentation error
+ *  \param  error   The segmentation error number
+ */
+static void Ams_RxOnSegError(void *self, Msg_MostTel_t *tel_ptr, Segm_Error_t error)
+{
+    const uint8_t ERR_SZ = 2U;
+    CAms *self_ = (CAms*)self; 
+    Msg_MostTel_t* error_tel_ptr = NULL;
+
+    TR_ERROR((self_->base_ptr->mns_inst_id, "[AMS]", "Ams_RxOnComplete(0x%p, %d)", 2U, tel_ptr, error));
+
+    if (tel_ptr->source_addr != MSG_ADDR_INIC)
+    {                                                                       /* only generate segmentation errors */
+        error_tel_ptr = Trcv_TxAllocateMsg(self_->trcv_mcm_ptr, ERR_SZ);    /* for messages which are NOT locally routed by the INIC */
+    }
+
+    if (error_tel_ptr != NULL)
+    {
+        error_tel_ptr->destination_addr     = tel_ptr->source_addr;
+        error_tel_ptr->id                   = tel_ptr->id;
+        error_tel_ptr->id.op_type           = MNS_OP_ERROR;
+        error_tel_ptr->tel.tel_data_ptr[0]  = 0x0CU;
+        error_tel_ptr->tel.tel_data_ptr[1]  = (uint8_t)error;
+        error_tel_ptr->opts.llrbc           = 0U;
+
+        Trcv_TxSendMsg(self_->trcv_mcm_ptr, error_tel_ptr);      /* just fire the message */
+    }
+}
+
+/*! \brief Callback function that is invoked if application Rx messages are available again
+ *  \param self     The instance
+ *  \param data_ptr Unused parameter of observer callback
+ */
+static void Ams_RxOnFreedMsg(void *self, void *data_ptr)
+{
+    CAms *self_ = (CAms*) self;
+    Srv_SetEvent(&self_->service, AMS_EV_RX_SERVICE);
+    MISC_UNUSED(data_ptr);
+}
+
+/*! \brief   Removes and frees a message from the Rx queue
+ *  \details The application must not access the passed 
+ *           message any more.
+ *  \param   self       The instance
+ *  \param   msg_ptr    Reference to the message, or \c NULL for the front-most
+ *                      message in the Rx queue. 
+ */
+void Ams_RxFreeMsg(CAms *self, Mns_AmsRx_Msg_t *msg_ptr)
+{
+    TR_INFO((self->base_ptr->mns_inst_id, "[AMS]", "Ams_RxFreeMsg(msg_ptr=0x%p)", 1U, msg_ptr));
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[AMS]", (msg_ptr != NULL));
+
+    if (msg_ptr != NULL)
+    {
+        Amsp_FreeRxPayload(self->pool_ptr, msg_ptr);            /* free external payload */
+        Amsp_FreeRxObj(self->pool_ptr, msg_ptr);                /* return message to Rx pool */
+    }
+}
+
+/*! \brief   Removes all messages located in Rx queues
+ *  \param   self   The instance
+ */
+static void Ams_RxFlush(CAms *self)
+{
+    Msg_MostTel_t *tel_ptr;
+
+    for (tel_ptr = Telq_Dequeue(&self->rx.waiting_queue); tel_ptr != NULL; tel_ptr = Telq_Dequeue(&self->rx.waiting_queue))
+    {
+        Ams_RxReleaseTel(self, tel_ptr);
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_ams.h b/mnsl/mns_ams.h
new file mode 100644
index 0000000..fb291c1
--- /dev/null
+++ b/mnsl/mns_ams.h
@@ -0,0 +1,163 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Application Message Service
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_AMSC
+ * @{
+ */
+
+#ifndef MNS_AMS_H
+#define MNS_AMS_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_ams_pb.h"
+#include "mns_amsmessage.h"
+#include "mns_amspool.h"
+#include "mns_pool.h"
+#include "mns_transceiver.h"
+#include "mns_pmchannel.h"
+#include "mns_ret.h"
+#include "mns_segmentation.h"
+#include "mns_message.h"
+#include "mns_telqueue.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Defines the default LLR number for Application Messages */
+#define AMS_LLRBC_DEFAULT         (MSG_LLRBC_DEFAULT)
+/*! \brief Defines the maximum LLR number for Application Messages */
+#define AMS_LLRBC_MAX             (MSG_LLRBC_MAX)
+/*! \brief Default memory size that is allocated when receiving segmented messages 
+ *         without size prefix */
+#define AMS_RX_DEF_SIZE_PAYLOAD   400U
+/*! \brief Maximum destination address which is reserved for internal transmission */
+#define AMS_ADDR_RSVD_RANGE       0x000FU
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Callback function type to request FIFO routing for a Tx message.
+ *  \param  msg_ptr  Reference to a Tx message object
+ *  \return Returns \c true if a Tx message shall be routed to RCM FIFO, otherwise returns \c false.
+ */
+typedef bool (*Ams_TxIsRcmMsgCb_t)(Mns_AmsTx_Msg_t *msg_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief      Application Message Service Class
+ *  \details    Allows transmission and reception of MOST Application Messages
+ */
+typedef struct CAms_
+{
+    CService                service;                    /*!< \brief  Service object */
+    CSegmentation           segmentation;               /*!< \brief  Segmentation object */
+    CMaskedObserver         unsync_result_observer;     /*!< \brief  Observes un-sync result */
+
+    CBase                  *base_ptr;                   /*!< \brief  Reference to basic services */
+    CAmsMsgPool            *pool_ptr;                   /*!< \brief  Pool providing Rx and Tx objects/payload */
+    CTransceiver           *trcv_mcm_ptr;               /*!< \brief  Reference to MCM transceiver */
+    CTransceiver           *trcv_rcm_ptr;               /*!< \brief  Reference to RCM transceiver */
+
+    struct Ams_tx_
+    {
+        CDlList             queue;                      /*!< \brief  Input queue of Tx Application Messages */
+        uint8_t             default_llrbc;              /*!< \brief Default LowLevelRetryBlockCount. Valid values: 0..100 */
+        Ams_TxIsRcmMsgCb_t  is_rcm_fptr;                /*!< \brief  Assignable callback function to request the correct transceiver */
+        uint8_t             next_follower_id;           /*!< \brief  The follower id for the next segmented
+                                                         *           message 
+                                                         */
+    } tx;
+
+    struct Ams_rx_
+    {
+        CObserver               message_freed_observer; /*!< \brief Observes message freed event */
+
+        Amsg_RxCompleteCb_t     complete_fptr;          /*!< \brief Callback function which is invoked on 
+                                                         *          message reception 
+                                                         */
+        void                   *complete_inst_ptr;      /*!< \brief Instance which is notified on 
+                                                         *          message reception 
+                                                         */
+        CTelQueue               waiting_queue;          /*!< \brief Queue of unprocessed single telegrams */
+
+    } rx;
+
+} CAms;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Initialization Methods                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+extern void Ams_Ctor(CAms *self, CBase *base_ptr, CTransceiver *mcm_trcv_ptr, CTransceiver *rcm_trcv_ptr,
+                     CAmsMsgPool *pool_ptr, uint16_t rx_def_payload_sz);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Public methods / Tx                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Ams_TxSetDefaultRetries(CAms *self, uint8_t llrbc);
+extern void Ams_TxAssignMsgFreedObs(CAms *self, CObserver *observer_ptr);
+extern void Ams_TxAssignTrcvSelector(CAms *self, Ams_TxIsRcmMsgCb_t cb_fptr);
+extern Mns_AmsTx_Msg_t* Ams_TxGetMsg(CAms *self, uint16_t size);
+extern void Ams_TxFreeUnusedMsg(CAms *self, Mns_AmsTx_Msg_t *msg_ptr);
+extern uint16_t Ams_TxGetMsgCnt(CAms *self);
+extern bool Ams_TxIsValidMessage(Mns_AmsTx_Msg_t *msg_ptr);
+extern void Ams_TxSendMsgDirect(CAms *self, Mns_AmsTx_Msg_t *msg_ptr);
+extern Mns_Return_t Ams_TxSendMsg(CAms *self, Mns_AmsTx_Msg_t *msg_ptr, Amsg_TxCompleteSiaCb_t tx_complete_sia_fptr, 
+                                  Amsg_TxCompleteCb_t tx_complete_fptr, void* tx_complete_inst_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Public methods / Rx                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Ams_RxAssignReceiver(CAms *self, Amsg_RxCompleteCb_t cb_fptr, void *inst_ptr);
+extern void Ams_RxFreeMsg(CAms *self, Mns_AmsRx_Msg_t *msg_ptr);
+extern void Ams_RxOnMcmTelComplete(void *self, Msg_MostTel_t *tel_ptr);
+extern void Ams_RxOnRcmTelComplete(void *self, Msg_MostTel_t *tel_ptr);
+
+#ifdef __cplusplus
+}               /* extern "C" */
+#endif
+
+#endif          /* MNS_AMS_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_ams_pb.h b/mnsl/mns_ams_pb.h
new file mode 100644
index 0000000..a559c94
--- /dev/null
+++ b/mnsl/mns_ams_pb.h
@@ -0,0 +1,262 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Public header file of Application Message Service
+ */
+/*!
+ * \addtogroup G_MNS_AMS_TYPES
+ * @{
+ */
+
+#ifndef MNS_AMS_PB_H
+#define MNS_AMS_PB_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_message_pb.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*! \brief   Defines which address type was used by the transmitter of a message. */
+typedef enum Mns_AmsRx_ReceiveType_
+{
+    MNS_AMSRX_RCT_SINGLECAST    = 0U,           /*!< \brief Message was transmitted as singlecast */
+    MNS_AMSRX_RCT_GROUPCAST     = 1U,           /*!< \brief Message was transmitted as groupcast */
+    MNS_AMSRX_RCT_BROADCAST     = 2U            /*!< \brief Message was transmitted as broadcast */
+
+} Mns_AmsRx_ReceiveType_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Application message Tx type */
+typedef struct Mns_AmsTx_Msg_
+{
+    uint16_t        destination_address;        /*!< \brief   Destination address. Find some predefined addresses \ref G_MNS_AMS "here". */
+    uint8_t         fblock_id;                  /*!< \brief   Function block ID (MOST FBlockID). */
+    uint8_t         instance_id;                /*!< \brief   Instance ID (MOST InstID). */
+    uint16_t        function_id;                /*!< \brief   Function ID (MOST FktID). */
+    Mns_OpType_t    op_type;                    /*!< \brief   Operation type (MOST OpType). */
+    uint8_t         llrbc;                      /*!< \brief   Specifies the "Low-Level Retry Block Count" (LLRBC)
+                                                 *   \details Valid values: 0..100. Default value: configurable via \ref Mns_AmsTx_InitData_t "default_llrbc"
+                                                 *            of the initialization structure \ref Mns_AmsTx_InitData_t.
+                                                 *            \mns_ic_inic{ See also <i>INIC API User's Guide</i>, section \ref SEC_OS81118_19. }
+                                                 */
+    uint8_t        *data_ptr;                   /*!< \brief   Payload data */
+    uint16_t        data_size;                  /*!< \brief   The size of payload data in bytes */
+    void           *custom_info_ptr;            /*!< \brief   Customer specific reference 
+                                                 *   \details The application is allowed to use this attribute to assign an
+                                                 *            own reference to the message object. The reference is initialized 
+                                                 *            by MOST NetServices with \c NULL and will not alter until the 
+                                                 *            transmission has finished.
+                                                 */
+} Mns_AmsTx_Msg_t;
+
+/*! \brief Application message Rx type */
+typedef struct Mns_AmsRx_Msg_
+{
+    uint16_t        source_address;             /*!< \brief Source address */
+    uint8_t         fblock_id;                  /*!< \brief Function block ID (MOST FBlockID). */
+    uint8_t         instance_id;                /*!< \brief Instance ID (MOST InstID). */
+    uint16_t        function_id;                /*!< \brief Function ID (MOST FktID). */
+    Mns_OpType_t    op_type;                    /*!< \brief Operation type (MOST OpType). */
+    uint8_t        *data_ptr;                   /*!< \brief Reference to payload */
+    uint16_t        data_size;                  /*!< \brief Payload size in bytes */
+    void           *custom_info_ptr;            /*!< \brief Customer specific reference */
+    Mns_AmsRx_ReceiveType_t receive_type;       /*!< \brief Defines which address type was used by the transmitter of this message */
+
+} Mns_AmsRx_Msg_t;
+
+/*! \brief Transmission result of an application message */
+typedef enum Mns_AmsTx_Result_
+{
+    MNS_AMSTX_RES_SUCCESS             = 0x00U,/*!< \brief   The transmission succeeded. */
+
+    MNS_AMSTX_RES_ERR_RETRIES_EXP     = 0x01U,/*!< \brief   The transmission including all retries have failed.
+                                               *   \details The following issues may have caused the failure:
+                                               *            - message corruption
+                                               *            - transmission timeouts
+                                               *            - full receive buffers of the destination device
+                                               *            - full receive buffers of the local device if the
+                                               *              destination was the own address, own group or broadcast
+                                               *              address
+                                               *            .
+                                               */
+    MNS_AMSTX_RES_ERR_INVALID_TGT     = 0x02U,/*!< \brief   The transmission failed because the specified destination 
+                                               *            address is not found or not valid.
+                                               *   \details The following issues may have caused the failure:
+                                               *            - device with the given destination address is not found 
+                                               *            - destination address is reserved (for future use) 
+                                               *            - destination address is 0xFFFF (un-initialized logical 
+                                               *              node address is not supported)
+                                               *            .
+                                               */
+    MNS_AMSTX_RES_ERR_NOT_AVAILABLE   = 0x03U,/*!< \brief   The transmission failed since the network or the INIC
+                                               *            is not available.
+                                               */
+    MNS_AMSTX_RES_ERR_BUF_INTERNAL    = 0xFEU,/*!< \brief   The transmission failed because the allocation of an Rx message object failed.
+                                               *            The Rx message object is required to receive the message via the own Rx message queue.
+                                               *   \details This is possible in the following cases:
+                                               *            - A message is transmitted to the own node address and the allocation 
+                                               *              of an Rx message object failed.
+                                               *            - The network transmission to the own group address or broadcast address
+                                               *              succeeded but the allocation of an Rx message object failed. The application
+                                               *              has to decide whether to retransmit the message to the own address again.
+                                               */
+    MNS_AMSTX_RES_ERR_UNEXPECTED      = 0xFFU /*!< \brief   The transmission failed due to an unexpected error.
+                                               *            The cause of this failure may be an invalid INIC configuration,
+                                               *            or an INIC to MOST NetServices incompatibility issue.
+                                               */
+} Mns_AmsTx_Result_t;
+
+
+/*! \brief  Detailed INIC transmission information which might be useful for debugging purposes. */
+typedef enum Mns_AmsTx_Info_
+{
+    MNS_AMSTX_I_SUCCESS             = 0x00U, /*!< \brief   The transmission succeeded.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_SUCCESS. 
+                                              */
+    MNS_AMSTX_I_ERR_CFG_NORECEIVER  = 0x01U, /*!< \brief   The transmission failed because the MOST network is not accessible for
+                                              *            MCM in the current attach state or for ICM in general.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_UNEXPECTED. 
+                                              */
+    MNS_AMSTX_I_ERR_BF              = 0x08U, /*!< \brief   The transmission failed because the receivers buffer is full.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_RETRIES_EXP. 
+                                              */ 
+    MNS_AMSTX_I_ERR_CRC             = 0x09U, /*!< \brief   The transmission failed because of a failed CRC.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_RETRIES_EXP. 
+                                              */ 
+    MNS_AMSTX_I_ERR_ID              = 0x0AU, /*!< \brief   The transmission failed because of corrupted identifiers.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_RETRIES_EXP. 
+                                              */ 
+    MNS_AMSTX_I_ERR_ACK             = 0x0BU, /*!< \brief   The transmission failed because of corrupted PACK or CACK.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_RETRIES_EXP. 
+                                              */ 
+    MNS_AMSTX_I_ERR_TIMEOUT         = 0x0CU, /*!< \brief   The transmission failed because of a transmission timeout.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_RETRIES_EXP. 
+                                              */
+    MNS_AMSTX_I_ERR_FATAL_WT        = 0x10U, /*!< \brief   The transmission failed because of destination is not available.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_INVALID_TGT. 
+                                              */ 
+    MNS_AMSTX_I_ERR_FATAL_OA        = 0x11U, /*!< \brief   The transmission failed because of the destination is the own node address. 
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_INVALID_TGT. 
+                                              */
+    MNS_AMSTX_I_ERR_UNAVAIL_TRANS   = 0x18U, /*!< \brief   The transmission canceled during the transition from network interface state
+                                              *            "available" to "not available".
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_NOT_AVAILABLE. 
+                                              */ 
+    MNS_AMSTX_I_ERR_UNAVAIL_OFF     = 0x19U, /*!< \brief   The transmission failed because the network interface state is "not available".
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_NOT_AVAILABLE. 
+                                              */
+    MNS_AMSTX_I_ERR_UNKNOWN         = 0xFEU, /*!< \brief   The transmission failed because of an unknown INIC error code.
+                                              *   \details The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_UNEXPECTED.
+                                              *            Please check if the MNS version is compatible with the applied INIC firmware version.
+                                              */
+    MNS_AMSTX_I_ERR_UNSYNCED        = 0xFFU  /*!< \brief   The transmission failed because the communication between the EHC (MOST NetServices) 
+                                              *            and the INIC is lost. 
+                                              *   \details The reason can be a communication error between the EHC and the INIC or that 
+                                              *            the application has called Mns_Stop().\n
+                                              *            The corresponding transmission result is \ref MNS_AMSTX_RES_ERR_NOT_AVAILABLE. 
+                                              */
+} Mns_AmsTx_Info_t;
+
+
+/*! \brief  Defines the usage of a requested memory chunk */
+typedef enum Mns_Ams_MemUsage_
+{
+    MNS_AMS_RX_OBJECT,              /*!< \brief  Memory is required to allocate an Rx message object */
+    MNS_AMS_RX_PAYLOAD,             /*!< \brief  Memory is required to allocate Rx message payload */
+    MNS_AMS_TX_OBJECT,              /*!< \brief  Memory is required to allocate a Tx message object */
+    MNS_AMS_TX_PAYLOAD              /*!< \brief  Memory is required to allocate Tx message payload */
+
+} Mns_Ams_MemUsage_t;
+
+/*! \brief  Callback function type that is invoked to allocate external payload for a segmented Rx message
+ *  \param  inst_ptr            Reference to the (external) memory management
+ *  \param  mem_size            Reference to the required memory size in bytes. Valid values: 0..65535.
+ *  \param  type                Declares how the memory is used by the MOST NetServices 
+ *  \param  custom_info_pptr    Reference which is related to the memory chunk and can be set by 
+ *                              the application.
+ *  \return Pointer to the provided memory chunk. The application has to guarantee that the memory size
+ *          is equal or greater than \c mem_size. The application has to return \c NULL if it is not able 
+ *          to allocate the required memory at this moment.
+ */
+typedef void* (*Mns_Ams_AllocMemCb_t)(void *inst_ptr, uint16_t mem_size, Mns_Ams_MemUsage_t type, void** custom_info_pptr);
+
+/*! \brief  Callback function type that is invoked to free external payload for a segmented Rx message
+ *  \param  inst_ptr        Reference to the (external) memory management
+ *  \param  mem_ptr         Reference to the external payload memory
+ *  \param  type            Declares how the memory is used by the MOST NetServices 
+ *  \param  custom_info_ptr Reference to memory related information which was set by the application 
+ *                          during memory allocation
+ */
+typedef void (*Mns_Ams_FreeMemCb_t)(void *inst_ptr, void *mem_ptr, Mns_Ams_MemUsage_t type, void* custom_info_ptr);
+
+/*! \brief   Type of a callback function that is invoked by the MOST NetServices as soon as a 
+ *           message transmission was finished
+ *  \details The callback function notifies the result of a completed transmission. If
+ *           the message has external payload, the application must decide whether
+ *           to re-use or to free the external payload.
+ *  \param   msg_ptr Reference to the related Tx message object. When the callback function returns
+ *                   the reference is no longer valid.
+ *  \param   result  The transmission result.
+ *  \param   info    Detailed INIC transmission result, which might be helpful for debug purposes.
+ */
+typedef void (*Mns_AmsTx_CompleteCb_t)(Mns_AmsTx_Msg_t* msg_ptr, Mns_AmsTx_Result_t result, Mns_AmsTx_Info_t info);
+
+/*!
+ * @}
+ * \addtogroup G_MNS_AMS
+ * @{
+ */
+
+/*! \brief  Type of a callback function that is invoked by MOST NetServices to notify that
+ *          a Tx application message object is available again while a previous
+ *          allocation using Mns_AmsTx_AllocMsg() has failed.
+ */
+typedef void (*Mns_AmsTx_MsgFreedCb_t)(void);
+
+/*! \brief  Callback function type that is invoked if the MOST NetServices has received a message 
+ *          completely and appended to the Rx message queue.
+ */
+typedef void (*Mns_AmsRx_MsgReceivedCb_t)(void);
+
+#ifdef __cplusplus
+}               /* extern "C" */
+#endif
+
+#endif  /* ifndef MNS_AMS_PB_H */
+
+/*! @} */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_amsmessage.c b/mnsl/mns_amsmessage.c
new file mode 100644
index 0000000..11ba985
--- /dev/null
+++ b/mnsl/mns_amsmessage.c
@@ -0,0 +1,656 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Application Message Classes
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_AMSMSG
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_amsmessage.h"
+#include "mns_dl.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+#define SELF_RX     ((Amsg_IntMsgRx_t*)(void*)(self))
+#define SELF_TX     ((Amsg_IntMsgTx_t*)(void*)(self))
+
+#define AMSG_TX_BACKUP_ADDR_NONE    0U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+static Mns_AmsRx_ReceiveType_t Amsg_RxGetReceiveType(uint16_t destination_address);
+static void Amsg_TxRestoreDestinationAddr(Mns_AmsTx_Msg_t *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tx Message                                                                                      */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Initializes aggregated objects
+ *  \details    Needs to be called once before first usage. Call Amsg_TxHandleSetup() before 
+ *              repeated usage. 
+ *  \param      self          Reference to an internal Application Message Tx handle
+ *  \param      info_ptr      Memory information required to free the object
+ *  \param      free_fptr     Callback function which is invoked when the object is freed
+ *  \param      free_inst_ptr The instance which is passed to free_fptr 
+ */
+void Amsg_TxCtor(Mns_AmsTx_Msg_t *self, void *info_ptr, Amsg_TxFreedCb_t free_fptr, void *free_inst_ptr)
+{
+    /* cleanup complete object */
+    MISC_MEM_SET((void*)self, 0, sizeof(Amsg_IntMsgTx_t));
+
+    /* reset default references
+    SELF_TX->memory_ptr        = NULL;
+    SELF_TX->memory_sz         = NULL;
+    SELF_TX->memory_info_ptr   = NULL;
+
+    SELF_TX->complete_fptr     = NULL; 
+    SELF_TX->complete_inst_ptr = NULL;
+    SELF_TX->complete_sia_fptr = NULL; 
+    
+    SELF_TX->backup_dest_address = AMSG_TX_BACKUP_ADDR_NONE;*/
+
+    SELF_TX->info_ptr = info_ptr;
+    SELF_TX->free_fptr = free_fptr;
+    SELF_TX->free_inst_ptr = free_inst_ptr;
+    SELF_TX->next_segment_cnt = 0xFFFFU;            /* start with TelId "4" */
+    SELF_TX->temp_result = MNS_MSG_STAT_OK;
+    SELF_TX->internal_status = AMSG_TX_INTRES_NONE;
+    SELF_TX->ignore_wrong_target = false;
+
+    Dln_Ctor(&SELF_TX->node, self);                 /* initialize node */
+}
+
+/*! \brief  Sets payload memory provided by memory management and updates data pointer and size
+ *  \param  self            The instance
+ *  \param  mem_ptr         Reference to the provided memory chunk
+ *  \param  mem_size        Size of the provided memory chunk
+ *  \param  mem_info_ptr    Optional reference for memory management
+ */
+void Amsg_TxSetInternalPayload(Mns_AmsTx_Msg_t *self, uint8_t *mem_ptr, uint16_t mem_size, void *mem_info_ptr)
+{
+    SELF_TX->memory_ptr        = mem_ptr;
+    SELF_TX->memory_sz         = mem_size;
+    SELF_TX->memory_info_ptr   = mem_info_ptr;
+
+    SELF_TX->pb_msg.data_ptr   = mem_ptr;
+    SELF_TX->pb_msg.data_size  = mem_size;
+}
+
+/*! \brief   Prepares the message object for re-usage
+ *  \details The public message structure is re-initialized. The internal payload
+ *           is assigned to the public data reference.
+ *  \param   self            The instance
+ */
+void Amsg_TxReuse(Mns_AmsTx_Msg_t *self)
+{
+    MISC_MEM_SET((void *)&SELF_TX->pb_msg, 0, sizeof(SELF_TX->pb_msg));  /* cleanup public object */
+    /* SELF_TX->backup_dest_address = AMSG_TX_BACKUP_ADDR_NONE; */
+
+    SELF_TX->pb_msg.data_ptr   = SELF_TX->memory_ptr;   /* reset public payload */
+    SELF_TX->pb_msg.data_size  = SELF_TX->memory_sz;
+
+    SELF_TX->next_segment_cnt  = 0xFFFFU;               /* start with TelId "4" */
+    SELF_TX->temp_result       = MNS_MSG_STAT_OK;
+    SELF_TX->internal_status   = AMSG_TX_INTRES_NONE;
+}
+
+/*! \brief   Assigns a Tx complete callback function
+ *  \details It is not possible to assign the single and multiple instance callback
+ *           at the same time. This function shall be called before message transmission. 
+ *  \param   self     The instance
+ *  \param   compl_sia_fptr  Reference to the single instance callback function
+ *  \param   compl_fptr      Reference to a multiple instance callback function
+ *  \param   compl_inst_ptr  Instance which is invoked by compl_fptr()
+ */
+void Amsg_TxSetCompleteCallback(Mns_AmsTx_Msg_t *self, Amsg_TxCompleteSiaCb_t compl_sia_fptr, 
+                                Amsg_TxCompleteCb_t compl_fptr, void* compl_inst_ptr)
+{
+    SELF_TX->complete_sia_fptr = compl_sia_fptr;
+    SELF_TX->complete_fptr     = compl_fptr;
+    SELF_TX->complete_inst_ptr = compl_inst_ptr;
+}
+
+/*! \brief  Invokes the correct callback function to notify the transmission result
+ *          and frees the memory
+ *  \param  self    Reference to the related message object
+ *  \param  result  The transmission result
+ *  \param  info    The INIC transmission result
+ */
+void Amsg_TxNotifyComplete(Mns_AmsTx_Msg_t *self, Mns_AmsTx_Result_t result, Mns_AmsTx_Info_t info)
+{
+    Amsg_TxRestoreDestinationAddr(self); 
+
+    if (SELF_TX->complete_sia_fptr != NULL)                      /* invoke single instance API callback */
+    {
+        SELF_TX->complete_sia_fptr(self, result, info);
+    }
+    else if (SELF_TX->complete_fptr != NULL)
+    {
+        SELF_TX->complete_fptr(SELF_TX->complete_inst_ptr, self, result, info);
+    }
+
+    TR_ASSERT(0xFU, "[AMSG_TX]", (SELF_TX->free_fptr != NULL));
+    if (SELF_TX->free_fptr != NULL)
+    {
+        SELF_TX->free_fptr(SELF_TX->free_inst_ptr, self);
+    }
+}
+
+/*! \brief  Frees an unused message object to the owning pool
+ *  \param  self    Reference to the message object
+ */
+void Amsg_TxFreeUnused(Mns_AmsTx_Msg_t *self)
+{
+    TR_ASSERT(0xFU, "[AMSG_TX]", (SELF_TX->free_fptr != NULL));
+    if (SELF_TX->free_fptr != NULL)
+    {
+        SELF_TX->free_fptr(SELF_TX->free_inst_ptr, self);
+    }
+}
+
+/*! \brief    Updates the transmission result
+ *  \param    self    Reference to the related message object
+ *  \param    result  The latest MCM transmission result
+ *  \details  Since the transmission result of an application message may
+ *            consist of multiple telegram transmission results, it is 
+ *            important to store the final transmission error. An error cannot
+ *            be overwritten by a success.
+ */
+void Amsg_TxUpdateResult(Mns_AmsTx_Msg_t *self, Mns_MsgTxStatus_t result)
+{
+    if (result != MNS_MSG_STAT_OK)            /* store the latest error and do not overwrite with success */
+    {
+        SELF_TX->temp_result = result;
+    }
+}
+
+/*! \brief    Updates the internal transmission result
+ *  \param    self    Reference to the related message object
+ *  \param    result  The internal transmission result
+ *  \details  The internal transmission result must be updated if the 
+ *            the message is transmitted to the internal Rx queue.
+ */
+void Amsg_TxUpdateInternalResult(Mns_AmsTx_Msg_t *self, Amsg_TxIntStatus_t result)
+{
+    SELF_TX->internal_status = result;
+}
+
+/*! \brief  Returns the latest AMS transmission result code
+ *  \param  self    Reference to the related message object
+ *  \return Returns the transmission result which shall be notified to the application
+ */
+Mns_AmsTx_Result_t Amsg_TxGetResultCode(Mns_AmsTx_Msg_t *self)
+{
+    Mns_AmsTx_Result_t res = MNS_AMSTX_RES_SUCCESS;                 /* success is the expected result */
+
+    switch (SELF_TX->temp_result)
+    {
+        case MNS_MSG_STAT_OK:
+            if (SELF_TX->internal_status == AMSG_TX_INTRES_ERRBUF)
+            {
+                res = MNS_AMSTX_RES_ERR_BUF_INTERNAL;               /* internal transmission error overrules network success */
+            }
+            break;
+        case MNS_MSG_STAT_ERROR_BF: 
+        case MNS_MSG_STAT_ERROR_CRC: 
+        case MNS_MSG_STAT_ERROR_ID: 
+        case MNS_MSG_STAT_ERROR_ACK: 
+        case MNS_MSG_STAT_ERROR_TIMEOUT:
+            res = MNS_AMSTX_RES_ERR_RETRIES_EXP;                    /* transmission failed, retries are possible */
+            break;
+        case MNS_MSG_STAT_ERROR_FATAL_WT:
+        case MNS_MSG_STAT_ERROR_FATAL_OA:
+            if (SELF_TX->internal_status == AMSG_TX_INTRES_ERRBUF)
+            {
+                res = MNS_AMSTX_RES_ERR_BUF_INTERNAL;               /* internal transmission error and network node not found */
+            }
+            else if (SELF_TX->internal_status == AMSG_TX_INTRES_NONE)
+            {
+                res = MNS_AMSTX_RES_ERR_INVALID_TGT;                /* not transmitted internally and no network node found */
+            }
+            /* else -> internal success -> target node was found locally */
+            break;
+        case MNS_MSG_STAT_ERROR_NA_TRANS:
+        case MNS_MSG_STAT_ERROR_NA_OFF:
+            if (SELF_TX->internal_status != AMSG_TX_INTRES_SUCCESS)
+            {
+                res = MNS_AMSTX_RES_ERR_NOT_AVAILABLE;              /* successful if internal transmission succeeded, otherwise "not available" */
+            }
+            break;
+        case MNS_MSG_STAT_ERROR_SYNC:
+            res = MNS_AMSTX_RES_ERR_NOT_AVAILABLE;
+            break;
+        default:
+            res = MNS_AMSTX_RES_ERR_UNEXPECTED;                     /* unexpected network transmission state */
+            break;
+    }
+
+    return res;
+}
+
+/*! \brief  Returns the latest MCM transmission error
+ *  \param  self    Reference to the related message object
+ *  \return Returns the INIC transmission result which is provided as additional info
+ */
+Mns_AmsTx_Info_t Amsg_TxGetResultInfo(Mns_AmsTx_Msg_t *self)
+{
+    Mns_AmsTx_Info_t res = (Mns_AmsTx_Info_t)SELF_TX->temp_result;
+
+    if ((SELF_TX->temp_result == MNS_MSG_STAT_ERROR_FATAL_WT) && (SELF_TX->ignore_wrong_target != false))
+    {
+        res = MNS_AMSTX_I_SUCCESS;
+    }
+
+    return res;
+}
+
+/*! \brief  Queues a Tx message at the tail of a list
+ *  \param  self     The instance
+ *  \param  list_ptr Reference to the list
+ */
+void Amsg_TxEnqueue(Mns_AmsTx_Msg_t* self, CDlList* list_ptr)
+{
+    Dl_InsertTail(list_ptr, &SELF_TX->node);
+}
+
+/*! \brief  Retrieves the next segment count
+ *  \param  self     The instance
+ *  \return The next segment count as uint16_t
+ */
+uint16_t Amsg_TxGetNextSegmCnt(Mns_AmsTx_Msg_t *self)
+{
+    return SELF_TX->next_segment_cnt;
+}
+
+/*! \brief  Increments the next segment count
+ *  \param  self     The instance
+ */
+void Amsg_TxIncrementNextSegmCnt(Mns_AmsTx_Msg_t *self)
+{
+    SELF_TX->next_segment_cnt++;
+}
+
+/*! \brief  Retrieves the follower id which labels all telegrams of a segmented message
+ *  \param  self     The instance
+ *  \return The follower id
+ */
+uint8_t Amsg_TxGetFollowerId(Mns_AmsTx_Msg_t *self)
+{
+    return SELF_TX->follower_id;
+}
+
+/*! \brief  Sets the follower id which labels all telegrams of a segmented message
+ *  \param  self     The instance
+ *  \param  id       The follower id
+ */
+void Amsg_TxSetFollowerId(Mns_AmsTx_Msg_t *self, uint8_t id)
+{
+    SELF_TX->follower_id = id;
+}
+
+/*! \brief   Replaces the current destination address by a new one. 
+ *  \details The current destination address can be restore by Amsg_TxRestoreDestinationAddr().
+ *  \param   self               The instance
+ *  \param   new_destination    The new destination address
+ */
+void Amsg_TxReplaceDestinationAddr(Mns_AmsTx_Msg_t *self, uint16_t new_destination)
+{
+    SELF_TX->backup_dest_address = self->destination_address;    /* internal backup of current destination address */
+    self->destination_address = new_destination;                 /* replace public destination address */
+}
+
+/*! \brief   Restores the destination address which was saved by calling Amsg_TxReplaceDestinationAddr().
+ *  \param   self               The instance
+ */
+static void Amsg_TxRestoreDestinationAddr(Mns_AmsTx_Msg_t *self)
+{
+    if (SELF_TX->backup_dest_address != AMSG_TX_BACKUP_ADDR_NONE)
+    {
+        self->destination_address = SELF_TX->backup_dest_address;/* restore public destination address */ 
+    }
+}
+
+/*! \brief  Removes a message from a given queue
+ *  \param  self     The instance
+ *  \param  list_ptr The queue that contains the message
+ */
+void Amsg_TxRemoveFromQueue(Mns_AmsTx_Msg_t *self, CDlList *list_ptr)
+{
+    (void)Dl_Remove(list_ptr, &SELF_TX->node);
+}
+
+/*! \brief  Peeks a Tx message from the head of a list
+ *  \param  list_ptr Reference to the list
+ *  \return Reference to the Tx message
+ */
+Mns_AmsTx_Msg_t* Amsg_TxPeek(CDlList* list_ptr)
+{
+    Mns_AmsTx_Msg_t *msg_ptr = NULL;
+    CDlNode *node_ptr = Dl_PeekHead(list_ptr);
+
+    if (node_ptr != NULL)
+    {
+        msg_ptr = (Mns_AmsTx_Msg_t*)Dln_GetData(node_ptr);
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Removes a Tx message from the head of a list
+ *  \param  list_ptr Reference to the list
+ *  \return Reference to the Tx message
+ */
+Mns_AmsTx_Msg_t* Amsg_TxDequeue(CDlList* list_ptr)
+{
+    Mns_AmsTx_Msg_t *msg_ptr = NULL;
+    CDlNode *node_ptr = Dl_PopHead(list_ptr);
+
+    if (node_ptr != NULL)
+    {
+        msg_ptr = (Mns_AmsTx_Msg_t*)Dln_GetData(node_ptr);
+    }
+
+    return msg_ptr;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Rx Message                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Initializes aggregated objects
+ *  \details    Needs to be called once before first usage. Call Amsg_RxHandleSetup() before 
+ *              repeated usage. 
+ *  \param      self     Reference to an internal Application Message Rx handle
+ *  \param      info_ptr Memory information required to free the object
+ */
+void Amsg_RxCtor(Mns_AmsRx_Msg_t *self, void *info_ptr)
+{
+    Dln_Ctor(&SELF_RX->node, SELF_RX);
+    SELF_RX->info_ptr          = info_ptr;                              /* reset memory information */
+    SELF_RX->memory_sz         = 0U;
+    SELF_RX->memory_ptr        = NULL;
+    SELF_RX->memory_info_ptr   = NULL;
+}
+
+/*! \brief      Copies all attributes and payload from a Tx message to the Rx message
+ *  \details    The caller has to ensure that the payload size of the Rx message is equal
+ *              or greater than the payload size of the Tx message.
+ *  \param      self           Reference to an Rx message object
+ *  \param      tx_ptr         Reference to an Tx message object
+ *  \param      source_address The source address that shall be set in the Rx message
+ */
+void Amsg_RxBuildFromTx(Mns_AmsRx_Msg_t *self, Mns_AmsTx_Msg_t *tx_ptr, uint16_t source_address)
+{
+    TR_ASSERT(0xFU,"[AMSG]", (SELF_RX->memory_sz >= tx_ptr->data_size));
+
+    self->receive_type      = Amsg_RxGetReceiveType(tx_ptr->destination_address);
+    self->source_address    = source_address;
+    self->fblock_id         = tx_ptr->fblock_id;
+    self->instance_id       = tx_ptr->instance_id;
+    self->function_id       = tx_ptr->function_id;
+    self->op_type           = tx_ptr->op_type;
+    self->data_size         = tx_ptr->data_size;
+
+    Misc_MemCpy(self->data_ptr, tx_ptr->data_ptr, (size_t)self->data_size);
+}
+
+/*! \brief      Sets all attributes of an internal Rx message to valid values
+ *  \param      self    Reference to an internal Rx message object
+ *  \details    Assigned payload memory has to be freed before calling this function
+ */
+void Amsg_RxHandleSetup(Mns_AmsRx_Msg_t *self)
+{
+    MISC_MEM_SET((void *)&SELF_RX->pb_msg, 0, sizeof(SELF_RX->pb_msg)); /* cleanup public message object */
+    SELF_RX->pb_msg.data_ptr   = SELF_RX->memory_ptr;                   /* set data to valid memory */
+    SELF_RX->gc_marker         = false;                                 /* reset garbage collector flag */
+    SELF_RX->exp_tel_cnt       = 0U;                                    /* reset TelCnt */
+}
+
+/*! \brief  Evaluates if an Application Message has the same functional address
+ *          as a MOST telegram
+ *  \param  self    Reference to an internal Application Message Rx handle
+ *  \param  tel_ptr Reference to a MOST message object
+ *  \return Returns \c true if both message objects have the same functional address,
+ *          otherwise \c false.
+ */
+bool Amsg_RxHandleIsIdentical(Mns_AmsRx_Msg_t *self, Msg_MostTel_t *tel_ptr)
+{
+    bool result;
+
+    if ((self->source_address == tel_ptr->source_addr)
+        && (self->fblock_id == tel_ptr->id.fblock_id)
+        && (self->instance_id == tel_ptr->id.instance_id)
+        && (self->function_id == tel_ptr->id.function_id)
+        && (self->op_type == tel_ptr->id.op_type))
+    {
+        result = true;
+    }
+    else
+    {
+        result = false;
+    }
+
+    return result;
+}
+
+/*! \brief  Copies the Rx message signature from a MOST message object to an 
+ *          internal Application message object
+ *  \param  self    Reference to an internal Application Message Rx handle
+ *  \param  src_ptr Reference to a MOST message object
+ */
+void Amsg_RxCopySignatureFromTel(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* src_ptr)
+{
+    self->source_address   = src_ptr->source_addr;
+    self->receive_type     = Amsg_RxGetReceiveType(src_ptr->destination_addr);
+    self->fblock_id        = src_ptr->id.fblock_id;
+    self->instance_id      = src_ptr->id.instance_id;
+    self->function_id      = src_ptr->id.function_id;
+    self->op_type          = src_ptr->id.op_type;
+}
+
+/*! \brief  Copies the Rx message signature from an internal Application
+ *          message object to a MOST message object
+ *  \param  self     Reference to an internal Application Message Rx handle
+ *  \param  target_ptr  Reference to a MOST message object
+ */
+void Amsg_RxCopySignatureToTel(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* target_ptr)
+{
+    target_ptr->source_addr        = self->source_address;
+    target_ptr->destination_addr   = MNS_ADDR_DEBUG;
+    target_ptr->id.fblock_id       = self->fblock_id;
+    target_ptr->id.instance_id     = self->instance_id;
+    target_ptr->id.function_id     = self->function_id;
+    target_ptr->id.op_type         = self->op_type;
+}
+
+/*! \brief  Retrieves the addressing type related to a destination_address of an Rx message
+ *  \param  destination_address  The destination address of an Rx message
+ *  \return The receive type related to the destination address
+ */
+static Mns_AmsRx_ReceiveType_t Amsg_RxGetReceiveType(uint16_t destination_address)
+{
+    Mns_AmsRx_ReceiveType_t ret = MNS_AMSRX_RCT_SINGLECAST;
+
+    if ((destination_address == MNS_ADDR_BROADCAST_BLOCKING) ||
+        (destination_address == MNS_ADDR_BROADCAST_UNBLOCKING))
+    {
+        ret = MNS_AMSRX_RCT_BROADCAST;
+    }
+    else if ((destination_address >= 0x0300U) &&        /* 0x300..0x3FF is reserved for group cast */
+             (destination_address <  0x0400U))
+    {
+        ret = MNS_AMSRX_RCT_GROUPCAST;
+    }
+
+    return ret;
+}
+
+/*! \brief  Appends payload of an Rx MOST message object to internal Application
+ *          message object
+ *  \param  self    Reference to an internal Application Message Rx handle
+ *  \param  src_ptr Reference to a MOST message object
+ *  \return Returns \c true if the payload was appended successfully, 
+ *          otherwise \c false.
+ */
+bool Amsg_RxAppendPayload(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* src_ptr)
+{
+    uint8_t cnt;
+    bool ret = false;
+    const uint16_t curr_size = SELF_RX->pb_msg.data_size;                /* get current message size */
+
+    if ((SELF_RX->memory_sz - src_ptr->tel.tel_len) >= SELF_RX->pb_msg.data_size) /* is size sufficient */
+    {
+        for (cnt = 0U; cnt < src_ptr->tel.tel_len; cnt++)
+        {
+             SELF_RX->pb_msg.data_ptr[curr_size + (uint16_t)cnt] = src_ptr->tel.tel_data_ptr[cnt];
+        }
+
+         SELF_RX->pb_msg.data_size = curr_size + src_ptr->tel.tel_len;    /* update message size */
+         SELF_RX->exp_tel_cnt++;
+        ret = true;
+    }
+
+    return ret;
+}
+
+/*! \brief   Copies data to allocated payload buffer 
+ *  \param   self       The instance
+ *  \param   data       Reference to external payload data
+ *  \param   data_sz    Size of external payload data 
+ */
+void Amsg_RxCopyToPayload(Mns_AmsRx_Msg_t *self, uint8_t data[], uint8_t data_sz)
+{
+    MISC_MEM_CPY(&self->data_ptr[0], &data[0], (size_t)data_sz); /* parasoft-suppress  MISRA2004-20_3 "data_sz is limited and checked via Msg_VerifyContent()" */
+    self->data_size = data_sz;         /* remember payload size */
+}
+
+/*! \brief   Checks if the message has externally allocated payload memory
+ *  \param   self       The instance
+ *  \return  Returns \c true if external payload is assigned to the message, otherwise \c false.
+ */
+bool Amsg_RxHasExternalPayload(Mns_AmsRx_Msg_t *self)
+{
+    return (SELF_RX->memory_sz > 0U);
+}
+
+/*! \brief  Sets payload memory provided by memory management and updates data pointer and size
+ *  \param  self     The instance
+ *  \param  mem_ptr  Reference to the provided memory chunk
+ *  \param  mem_size Size of the provided memory chunk
+ *  \param  info_ptr Optional reference for memory management
+ */
+void Amsg_RxHandleSetMemory(Mns_AmsRx_Msg_t *self, uint8_t *mem_ptr, uint16_t mem_size, void *info_ptr)
+{
+    SELF_RX->memory_ptr        = mem_ptr;
+    SELF_RX->memory_info_ptr   = info_ptr;
+    SELF_RX->memory_sz         = mem_size;
+
+    SELF_RX->pb_msg.data_ptr   = mem_ptr;
+    SELF_RX->pb_msg.data_size  = 0U;
+}
+
+/*! \brief  Queues an Rx message at the tail of a list
+ *  \param  self     The instance
+ *  \param  list_ptr Reference to the list
+ */
+void Amsg_RxEnqueue(Mns_AmsRx_Msg_t* self, CDlList* list_ptr)
+{
+    Dl_InsertTail(list_ptr, &SELF_RX->node);
+}
+
+/*! \brief  Sets or resets the garbage collector flag
+ *  \param  self    The instance
+ *  \param  value   New value of the flag
+ */
+void Amsg_RxSetGcMarker(Mns_AmsRx_Msg_t* self, bool value)
+{
+    SELF_RX->gc_marker = value; 
+}
+
+/*! \brief  Retrieves the value of the garbage collector flag
+ *  \param  self    The instance
+ *  \return The current value of the flag
+ */
+bool Amsg_RxGetGcMarker(Mns_AmsRx_Msg_t* self)
+{
+    return SELF_RX->gc_marker;
+}
+
+/*! \brief  Retrieves the next expected telegram count
+ *  \param  self    The instance
+ *  \return The next  expected telegram count as uint8_t
+ */
+uint8_t Amsg_RxGetExpTelCnt(Mns_AmsRx_Msg_t* self)
+{
+    return SELF_RX->exp_tel_cnt;
+}
+
+/*! \brief  Peeks an Rx message from the head of a list
+ *  \param  list_ptr Reference to the list
+ *  \return Reference to the Rx message
+ */
+Mns_AmsRx_Msg_t* Amsg_RxPeek(CDlList* list_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+    CDlNode *node_ptr = Dl_PeekHead(list_ptr);
+
+    if (node_ptr != NULL)
+    {
+        msg_ptr = (Mns_AmsRx_Msg_t*)Dln_GetData(node_ptr);
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Removes an Rx message from the head of a list
+ *  \param  list_ptr Reference to the list
+ *  \return Reference to the Rx message
+ */
+Mns_AmsRx_Msg_t* Amsg_RxDequeue(CDlList* list_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+    CDlNode *node_ptr = Dl_PopHead(list_ptr);
+
+    if (node_ptr != NULL)
+    {
+        msg_ptr = (Mns_AmsRx_Msg_t*)Dln_GetData(node_ptr);
+    }
+
+    return msg_ptr;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_amsmessage.h b/mnsl/mns_amsmessage.h
new file mode 100644
index 0000000..b1faa65
--- /dev/null
+++ b/mnsl/mns_amsmessage.h
@@ -0,0 +1,217 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Application Message Classes
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_AMSMSG
+ * @{
+ */
+
+#ifndef MNS_AMSMESSAGE_H
+#define MNS_AMSMESSAGE_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_ams_pb.h"
+#include "mns_message.h"
+#include "mns_dl.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+#define AMSG_TX_OBJECT_SZ   (sizeof(Amsg_IntMsgTx_t))
+#define AMSG_RX_OBJECT_SZ   (sizeof(Amsg_IntMsgRx_t))
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal types                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Internal transmission result of an application message */
+typedef enum Amsg_TxIntStatus_
+{
+    AMSG_TX_INTRES_NONE     = 0x00U,  /*!< \brief   The internal transmission is not applicable. */
+    AMSG_TX_INTRES_SUCCESS  = 0x01U,  /*!< \brief   The internal transmission succeeded. */
+    AMSG_TX_INTRES_ERRBUF   = 0x02U   /*!< \brief   The internal transmission failed. */
+
+} Amsg_TxIntStatus_t;
+
+/*! \brief  Assignable function which is invoked as soon as an application message is received 
+ *          completely and available in the Rx message queue
+ *  \param  self            The instance (optional)
+ *  \param  msg_ptr         Reference to the received message
+ */
+typedef void (*Amsg_RxCompleteCb_t)(void* self, Mns_AmsRx_Msg_t* msg_ptr);
+
+/*! \brief  Callback function type which is fired as soon as an AMS transmission was finished 
+ *  \param  self            The instance (optional)
+ *  \param  msg_ptr         Reference to the related message object
+ *  \param  result          Transmission result
+ *  \param  info            Detailed INIC transmission result
+ */
+typedef void (*Amsg_TxCompleteCb_t)(void* self, Mns_AmsTx_Msg_t* msg_ptr, Mns_AmsTx_Result_t result, Mns_AmsTx_Info_t info);
+
+/*! \brief  Single instance API callback function type which is fired as soon as an AMS transmission was finished 
+ *  \param  msg_ptr         Reference to the related message object
+ *  \param  result          Transmission result
+ *  \param  info            Detailed INIC transmission result
+ */
+typedef void (*Amsg_TxCompleteSiaCb_t)(Mns_AmsTx_Msg_t* msg_ptr, Mns_AmsTx_Result_t result, Mns_AmsTx_Info_t info);
+
+/*! \brief  Callback function which is invoked to free a Tx message object to the owning pool 
+ *  \param  owner_ptr       The owning pool of the message object
+ *  \param  msg_ptr         Reference to the related message object
+ */
+typedef void (*Amsg_TxFreedCb_t)(void *owner_ptr, Mns_AmsTx_Msg_t* msg_ptr);
+
+/*! \brief Keeps callback functions to an external memory management for Rx payload  */
+typedef struct Ams_MemAllocator_
+{
+    void *inst_ptr;                    /*!< \brief The instance of the (external) memory management */
+    Mns_Ams_AllocMemCb_t alloc_fptr;   /*!< \brief This function is invoked to allocate Rx user payload */
+    Mns_Ams_FreeMemCb_t  free_fptr;    /*!< \brief This function is invoked to free Rx user payload */
+
+} Ams_MemAllocator_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Internal Tx message structure */
+typedef struct Amsg_IntMsgTx_
+{
+    Mns_AmsTx_Msg_t     pb_msg;                 /*!< \brief Public message struct must be the first member */
+    void               *info_ptr;               /*!< \brief Custom object information required by memory management */
+
+    void               *free_inst_ptr;          /*!< \brief Reference which is passed to free_ptr */
+    Amsg_TxFreedCb_t    free_fptr;              /*!< \brief Callback function which is called to free the object */
+
+    uint8_t            *memory_ptr;             /*!< \brief Reference to payload provided by memory management */
+    void               *memory_info_ptr;        /*!< \brief Custom payload information required by memory management */
+    uint16_t            memory_sz;              /*!< \brief Size of the payload that is provided by memory management */
+
+    uint16_t            next_segment_cnt;       /*!< \brief Specifies the next segment count. '0xFF' means size prefixed */
+    uint8_t             follower_id;            /*!< \brief Identifier of segmented messages and corresponding telegrams  */
+    Mns_MsgTxStatus_t   temp_result;            /*!< \brief Stores the temporary result that is notified when then transmission
+                                                 *          has completed 
+                                                 */
+    uint16_t            backup_dest_address;    /*!< \brief Backup of replaced target address. */
+    Amsg_TxIntStatus_t  internal_status;        /*!< \brief Stores the internal transmission status */
+    bool                ignore_wrong_target;    /*!< \brief Forces the message to report transmission result "success", although 
+                                                 *          the INIC has reported transmission error "wrong target"
+                                                 */
+    CDlNode             node;                   /*!< \brief Node required for message pool */
+
+    Amsg_TxCompleteSiaCb_t complete_sia_fptr;   /*!< \brief Single instance API Callback function which is invoked
+                                                 *          after transmission completed
+                                                 */
+    Amsg_TxCompleteCb_t    complete_fptr;       /*!< \brief Callback function which is invoked after transmission
+                                                 *          completed 
+                                                 */
+    void                  *complete_inst_ptr;   /*!< \brief Instance pointer which is required to invoke complete_fptr */
+
+} Amsg_IntMsgTx_t;
+
+/*! \brief Internal Rx message structure */
+typedef struct Amsg_IntMsgRx_
+{
+    Mns_AmsRx_Msg_t     pb_msg;                 /*!< \brief Public message structure must be the first member */
+    void               *info_ptr;               /*!< \brief Custom object information required by memory management */
+
+    uint8_t            *memory_ptr;             /*!< \brief Reference to payload provided by memory management */
+    void               *memory_info_ptr;        /*!< \brief Custom payload information required by memory management */
+    uint16_t            memory_sz;              /*!< \brief The size of the allocated user payload in bytes */
+
+    CDlNode             node;                   /*!< \brief Node required for message pool */
+ 
+    uint8_t             exp_tel_cnt;            /*!< \brief The expected TelCnt used for segmented transfer */
+    bool                gc_marker;              /*!< \brief Identifies message objects that were already
+                                                 *          marked by the garbage collector. 
+                                                 */
+} Amsg_IntMsgRx_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class methods                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/* Tx */
+extern void Amsg_TxCtor(Mns_AmsTx_Msg_t *self, void *info_ptr, Amsg_TxFreedCb_t free_fptr, void *free_inst_ptr);
+extern void Amsg_TxSetInternalPayload(Mns_AmsTx_Msg_t *self, uint8_t *mem_ptr, uint16_t mem_size, void *mem_info_ptr);
+extern void Amsg_TxReuse(Mns_AmsTx_Msg_t *self);
+extern void Amsg_TxSetCompleteCallback(Mns_AmsTx_Msg_t *self, Amsg_TxCompleteSiaCb_t compl_sia_fptr, 
+                                Amsg_TxCompleteCb_t compl_fptr, void* compl_inst_ptr);
+extern void Amsg_TxNotifyComplete(Mns_AmsTx_Msg_t *self, Mns_AmsTx_Result_t result, Mns_AmsTx_Info_t info);
+extern void Amsg_TxFreeUnused(Mns_AmsTx_Msg_t *self);
+extern void Amsg_TxUpdateInternalResult(Mns_AmsTx_Msg_t *self, Amsg_TxIntStatus_t result);
+extern void Amsg_TxUpdateResult(Mns_AmsTx_Msg_t *self, Mns_MsgTxStatus_t result);
+extern Mns_AmsTx_Result_t Amsg_TxGetResultCode(Mns_AmsTx_Msg_t *self);
+extern Mns_AmsTx_Info_t Amsg_TxGetResultInfo(Mns_AmsTx_Msg_t *self);
+extern uint16_t Amsg_TxGetNextSegmCnt(Mns_AmsTx_Msg_t *self);
+extern void Amsg_TxIncrementNextSegmCnt(Mns_AmsTx_Msg_t *self);
+extern uint8_t Amsg_TxGetFollowerId(Mns_AmsTx_Msg_t *self);
+extern void Amsg_TxSetFollowerId(Mns_AmsTx_Msg_t *self, uint8_t id);
+extern void Amsg_TxReplaceDestinationAddr(Mns_AmsTx_Msg_t *self, uint16_t new_destination);
+extern void Amsg_TxRemoveFromQueue(Mns_AmsTx_Msg_t *self, CDlList *list_ptr);
+extern void Amsg_TxEnqueue(Mns_AmsTx_Msg_t* self, CDlList* list_ptr);
+extern Mns_AmsTx_Msg_t* Amsg_TxPeek(CDlList* list_ptr);
+extern Mns_AmsTx_Msg_t* Amsg_TxDequeue(CDlList* list_ptr);
+
+/* Rx */
+extern void Amsg_RxCtor(Mns_AmsRx_Msg_t *self, void *info_ptr);
+extern void Amsg_RxBuildFromTx(Mns_AmsRx_Msg_t *self, Mns_AmsTx_Msg_t *tx_ptr, uint16_t source_address);
+extern void Amsg_RxHandleSetup(Mns_AmsRx_Msg_t *self);
+extern void Amsg_RxHandleSetMemory(Mns_AmsRx_Msg_t *self, uint8_t *mem_ptr, uint16_t mem_size, void *info_ptr);
+extern bool Amsg_RxHandleIsIdentical(Mns_AmsRx_Msg_t *self, Msg_MostTel_t *tel_ptr);
+extern void Amsg_RxCopySignatureFromTel(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* src_ptr);
+extern void Amsg_RxCopySignatureToTel(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* target_ptr);
+extern void Amsg_RxCopyToPayload(Mns_AmsRx_Msg_t *self, uint8_t data[], uint8_t data_sz);
+extern bool Amsg_RxAppendPayload(Mns_AmsRx_Msg_t *self, Msg_MostTel_t* src_ptr);
+extern bool Amsg_RxHasExternalPayload(Mns_AmsRx_Msg_t *self);
+extern void Amsg_RxEnqueue(Mns_AmsRx_Msg_t* self, CDlList* list_ptr);
+extern void Amsg_RxSetGcMarker(Mns_AmsRx_Msg_t* self, bool value);
+extern bool Amsg_RxGetGcMarker(Mns_AmsRx_Msg_t* self);
+extern uint8_t Amsg_RxGetExpTelCnt(Mns_AmsRx_Msg_t* self);
+/* Rx helpers */
+extern Mns_AmsRx_Msg_t* Amsg_RxPeek(CDlList* list_ptr);
+extern Mns_AmsRx_Msg_t* Amsg_RxDequeue(CDlList* list_ptr);
+
+#ifdef __cplusplus
+}               /* extern "C" */
+#endif
+
+#endif          /* MNS_AMSMESSAGE_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_amspool.c b/mnsl/mns_amspool.c
new file mode 100644
index 0000000..3ce89ae
--- /dev/null
+++ b/mnsl/mns_amspool.c
@@ -0,0 +1,336 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Application Message Pool
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_AMSPOOL
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_amspool.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal macros                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+#define INT_RX(ptr) ((Amsg_IntMsgRx_t*)(void*)(ptr)) /* parasoft-suppress  MISRA2004-19_7 "common definition of type cast improves code" */
+#define INT_TX(ptr) ((Amsg_IntMsgTx_t*)(void*)(ptr)) /* parasoft-suppress  MISRA2004-19_7 "common definition of type cast improves code" */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Amsp_FreeTxObj(void *self, Mns_AmsTx_Msg_t* msg_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Initialization                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of application message pool class 
+ *  \param  self                The instance
+ *  \param  mem_allocator_ptr   Reference to memory allocator
+ *  \param  mns_inst_id         MOST NetServices instance ID
+ */
+void Amsp_Ctor(CAmsMsgPool *self, Ams_MemAllocator_t *mem_allocator_ptr, uint8_t mns_inst_id)
+{
+    self->mns_inst_id = mns_inst_id;
+    self->allocator_ptr = mem_allocator_ptr;
+    self->rx_rsvd_msg_ptr = Amsp_AllocRxObj(self, 45U);
+    self->rx_rsvd_msg_ref = self->rx_rsvd_msg_ptr;
+    self->terminated = false;
+    self->tx_notify_freed = false;
+    self->rx_notify_freed = false;
+    Sub_Ctor(&self->tx_freed_subject, self->mns_inst_id);
+    Sub_Ctor(&self->rx_freed_subject, self->mns_inst_id);
+ 
+    TR_ASSERT(self->mns_inst_id, "[AMSP]", (self->rx_rsvd_msg_ptr != NULL));
+}
+
+/*! \brief  Frees pre-allocated message memory
+ *  \param  self    The instance
+ */
+void Amsp_Cleanup(CAmsMsgPool *self)
+{
+    Amsg_IntMsgRx_t *msg_ptr = INT_RX(self->rx_rsvd_msg_ptr);
+    TR_INFO((self->mns_inst_id, "[AMSP]", "Amsp_Cleanup: rx_rsvd_msg_ptr=0x%p", 1U, self->rx_rsvd_msg_ptr));
+
+    self->terminated = true;
+    self->tx_notify_freed = false;
+    self->rx_notify_freed = false;
+
+    if (msg_ptr != NULL)
+    {
+        self->allocator_ptr->free_fptr(self->allocator_ptr->inst_ptr, msg_ptr->memory_ptr, MNS_AMS_RX_PAYLOAD, msg_ptr->memory_info_ptr);
+        self->allocator_ptr->free_fptr(self->allocator_ptr->inst_ptr, msg_ptr, MNS_AMS_RX_OBJECT, msg_ptr->info_ptr);
+        self->rx_rsvd_msg_ref = NULL;
+        self->rx_rsvd_msg_ptr = NULL;
+    }
+}
+
+/*! \brief  Assigns an observer which is invoked as soon as memory dedicated to a Tx message is 
+ *          freed.The data_ptr of the update callback function is not used (always \c NULL). 
+ *          See \ref Obs_UpdateCb_t. 
+ *  \param  self            The instance
+ *  \param  observer_ptr    The observer
+ */
+void Amsp_AssignTxFreedObs(CAmsMsgPool *self, CObserver *observer_ptr)
+{
+    (void)Sub_AddObserver(&self->tx_freed_subject, observer_ptr);
+}
+
+/*! \brief  Assigns an observer which is invoked as soon as memory dedicated to a Tx message is 
+ *          freed.The data_ptr of the update callback function is not used (always \c NULL). 
+ *          See \ref Obs_UpdateCb_t. 
+ *  \param  self            The instance
+ *  \param  observer_ptr    The observer
+ */
+void Amsp_AssignRxFreedObs(CAmsMsgPool *self, CObserver *observer_ptr)
+{
+    (void)Sub_AddObserver(&self->rx_freed_subject, observer_ptr);
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tx allocations                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Allocates an internal Tx message object (without payload)
+ *  \param  self        The instance
+ *  \param  payload_sz  The required payload size in bytes 
+ *  \return Reference to the Tx message object if the allocation succeeds. Otherwise \c NULL.
+ */
+Mns_AmsTx_Msg_t* Amsp_AllocTxObj(CAmsMsgPool *self, uint16_t payload_sz)
+{
+    void *payload_info_ptr = NULL;
+    void *payload_ptr = NULL;
+    void *obj_info_ptr = NULL;
+    Mns_AmsTx_Msg_t *msg_ptr = (Mns_AmsTx_Msg_t*)self->allocator_ptr->alloc_fptr(self->allocator_ptr->inst_ptr, AMSG_TX_OBJECT_SZ, MNS_AMS_TX_OBJECT, &obj_info_ptr);
+    TR_INFO((self->mns_inst_id, "[AMSP]", "Allocating TxObject: msg_ptr=0x%p, size=%d, info_ptr=0x%p", 3U, msg_ptr, AMSG_TX_OBJECT_SZ, obj_info_ptr));
+
+    if (msg_ptr != NULL)
+    {
+        if (payload_sz > 0U)
+        {
+            payload_ptr = self->allocator_ptr->alloc_fptr(self->allocator_ptr->inst_ptr, payload_sz, MNS_AMS_TX_PAYLOAD, &payload_info_ptr);
+            TR_INFO((self->mns_inst_id, "[AMSP]", "Allocating TxPayload: msg_ptr=0x%p, mem_ptr=0x%p, size=%d, info_ptr=0x%p", 4U, msg_ptr, payload_ptr, payload_sz, payload_info_ptr));
+
+            if (payload_ptr == NULL)
+            {
+                TR_INFO((self->mns_inst_id, "[AMSP]", "Freeing TxObject: msg_ptr=0x%p, info_ptr=0x%p", 2U, msg_ptr, obj_info_ptr));
+                self->allocator_ptr->free_fptr(self->allocator_ptr->inst_ptr, msg_ptr, MNS_AMS_TX_OBJECT, obj_info_ptr);
+                msg_ptr = NULL;
+            }
+        }
+    }
+
+    if (msg_ptr != NULL)
+    {
+        Amsg_TxCtor(msg_ptr, obj_info_ptr, &Amsp_FreeTxObj, self);
+
+        if (payload_ptr != NULL)
+        {
+            Amsg_TxSetInternalPayload(msg_ptr, (uint8_t*)payload_ptr, payload_sz, payload_info_ptr);
+        }
+    }
+    else
+    {
+        self->tx_notify_freed = true;
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief      Frees an internal Tx message object including its payload
+ *  \param      self        The instance
+ *  \param      msg_ptr     Reference to the internal Tx message object
+ */
+static void Amsp_FreeTxObj(void *self, Mns_AmsTx_Msg_t* msg_ptr)
+{
+    CAmsMsgPool *self_ = (CAmsMsgPool*)self;
+    Amsg_IntMsgTx_t *obj_ptr = INT_TX(msg_ptr);
+
+    if (obj_ptr->memory_ptr != NULL)
+    {
+        TR_INFO((self_->mns_inst_id, "[AMSP]", "Freeing TxPayload: msg_ptr=0x%p, mem_ptr=0x%p, info_ptr=0x%p", 3U, msg_ptr, obj_ptr->memory_ptr, obj_ptr->memory_info_ptr));
+        self_->allocator_ptr->free_fptr(self_->allocator_ptr->inst_ptr, obj_ptr->memory_ptr, MNS_AMS_TX_PAYLOAD, obj_ptr->memory_info_ptr);
+        Amsg_TxSetInternalPayload(msg_ptr, NULL, 0U, NULL);
+    }
+
+    TR_INFO((self_->mns_inst_id, "[AMSP]", "Freeing TxObject: msg_ptr=0x%p, info_ptr=0x%p", 2U, msg_ptr, obj_ptr->info_ptr));
+    self_->allocator_ptr->free_fptr(self_->allocator_ptr->inst_ptr, msg_ptr, MNS_AMS_TX_OBJECT, obj_ptr->info_ptr);
+
+    if (self_->tx_notify_freed)
+    {
+        Sub_Notify(&self_->tx_freed_subject, NULL);
+        self_->tx_notify_freed = false;
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Rx allocations                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Allocates an internal Rx message object (optionally with payload)
+ *  \param  self        The instance
+ *  \param  payload_sz  The required payload size that shall be allocated and assigned to the object.
+ *                      Value "0" means that no payload memory shall be allocated in the same turn.
+ *  \return Reference to the Rx message object if the allocation succeeds. Otherwise \c NULL.
+ */
+Mns_AmsRx_Msg_t* Amsp_AllocRxObj(CAmsMsgPool *self, uint16_t payload_sz)
+{
+    void *info_ptr = NULL;
+    Mns_AmsRx_Msg_t *msg_ptr = (Mns_AmsRx_Msg_t*)self->allocator_ptr->alloc_fptr(self->allocator_ptr->inst_ptr, AMSG_RX_OBJECT_SZ, MNS_AMS_RX_OBJECT, &info_ptr);
+
+    TR_INFO((self->mns_inst_id, "[AMSP]", "Allocating RxObject: msg_ptr=0x%p, size=%d, info_ptr=0x%p", 3U, msg_ptr, AMSG_RX_OBJECT_SZ, info_ptr));
+
+    if (msg_ptr != NULL)
+    {
+        Amsg_RxCtor(msg_ptr, info_ptr);
+        Amsg_RxHandleSetup(msg_ptr);
+
+        if (payload_sz != 0U)
+        {
+            if (!Amsp_AllocRxPayload(self, payload_sz, msg_ptr))
+            {
+                Amsp_FreeRxObj(self, msg_ptr);  /* payload allocation has failed - release message object */
+                msg_ptr = NULL;
+            }
+        }
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Allocates a reserved Rx message object with payload up to 45 bytes payload
+ *  \param  self        The instance
+ *  \return Reference to the Rx message object if the allocation succeeds. Otherwise \c NULL.
+ */
+Mns_AmsRx_Msg_t* Amsp_AllocRxRsvd(CAmsMsgPool *self)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+
+    if (self->rx_rsvd_msg_ptr != NULL)
+    {
+        msg_ptr = self->rx_rsvd_msg_ptr;
+        self->rx_rsvd_msg_ptr = NULL;
+        Amsg_RxHandleSetup(msg_ptr);
+        TR_INFO((self->mns_inst_id, "[AMSP]", "Retrieving reserved RxObject: msg_ptr=0x%p", 1U, msg_ptr));
+    }
+    else
+    {
+        self->rx_notify_freed = true;
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Allocates payload for an internal Rx message object 
+ *  \param  self        The instance
+ *  \param  payload_sz  Payload size in bytes
+ *  \param  msg_ptr     Reference to the internal Rx message object
+ *  \return Returns \c true if the allocation succeeds. Otherwise \c NULL.
+ */
+bool Amsp_AllocRxPayload(CAmsMsgPool *self, uint16_t payload_sz, Mns_AmsRx_Msg_t* msg_ptr)
+{
+    bool success = false;
+    void *info_ptr = NULL;
+    void *mem_ptr = self->allocator_ptr->alloc_fptr(self->allocator_ptr->inst_ptr, payload_sz, MNS_AMS_RX_PAYLOAD, &info_ptr);
+
+    TR_INFO((self->mns_inst_id, "[AMSP]", "Allocating RxPayload: msg_ptr=0x%p, mem_ptr=0x%p, size=%d, info_ptr=0x%p", 4U, msg_ptr, mem_ptr, payload_sz, info_ptr));
+    TR_ASSERT(self->mns_inst_id, "[AMSP]", (msg_ptr != NULL));                  /* message reference is required */
+    TR_ASSERT(self->mns_inst_id, "[AMSP]", (msg_ptr != self->rx_rsvd_msg_ref)); /* forbidden overwrite of pre-allocated message payload */
+
+    if (mem_ptr != NULL)
+    {
+        Amsg_RxHandleSetMemory(msg_ptr, (uint8_t*)mem_ptr, payload_sz, info_ptr);
+        success = true;
+    }
+
+    return success;
+}
+
+/*! \brief      Frees an internal Rx message object 
+ *  \param      self        The instance
+ *  \param      msg_ptr     Reference to the internal Rx message object
+ *  \details    Payload that is assigned to the message object has to be freed 
+ *              separately by using Amsp_FreeRxPayload().
+ */
+void Amsp_FreeRxObj(CAmsMsgPool *self, Mns_AmsRx_Msg_t* msg_ptr)
+{
+    if (msg_ptr == self->rx_rsvd_msg_ref)
+    {
+        TR_ASSERT(self->mns_inst_id, "[AMSP]", (self->rx_rsvd_msg_ptr == NULL));    /* before freeing, message shall be reserved */
+        TR_INFO((self->mns_inst_id, "[AMSP]", "Restoring reserved RxObject: msg_ptr=0x%p", 1U, msg_ptr));
+        self->rx_rsvd_msg_ptr = self->rx_rsvd_msg_ref;                              /* restore reserved message */
+
+        if (self->terminated != false)
+        {                                                                           /* also free reserved message if it is freed */
+            Amsp_Cleanup(self);                                                     /* from any queue after Amsp_Cleanup() */
+        }
+    }
+    else 
+    { 
+        Amsg_IntMsgRx_t *obj_ptr = INT_RX(msg_ptr);
+        TR_INFO((self->mns_inst_id, "[AMSP]", "Freeing RxObject: msg_ptr=0x%p, info_ptr=0x%p", 2U, msg_ptr, obj_ptr->info_ptr));
+        self->allocator_ptr->free_fptr(self->allocator_ptr->inst_ptr, msg_ptr, MNS_AMS_RX_OBJECT, obj_ptr->info_ptr);
+    }
+
+    if (self->rx_notify_freed)
+    {
+        Sub_Notify(&self->rx_freed_subject, NULL);
+        self->rx_notify_freed = false;
+    }
+}
+
+/*! \brief  Frees payload that is associated with an internal Rx message object 
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the internal Rx message object
+ */
+void Amsp_FreeRxPayload(CAmsMsgPool *self, Mns_AmsRx_Msg_t* msg_ptr)
+{
+    Amsg_IntMsgRx_t *obj_ptr = INT_RX(msg_ptr);
+
+    if (msg_ptr == self->rx_rsvd_msg_ref)
+    {
+        TR_ASSERT(self->mns_inst_id, "[AMSP]", (self->rx_rsvd_msg_ptr == NULL));    /* release payload before object */
+        TR_INFO((self->mns_inst_id, "[AMSP]", "Restoring reserved RxPayload: msg_ptr=0x%p", 1U, msg_ptr));
+    }
+    else if (obj_ptr->memory_ptr != NULL)
+    {
+        TR_INFO((self->mns_inst_id, "[AMSP]", "Freeing RxPayload: msg_ptr=0x%p, mem_ptr=0x%p, info_ptr=0x%p", 3U, msg_ptr, obj_ptr->memory_ptr, obj_ptr->memory_info_ptr));
+        self->allocator_ptr->free_fptr(self->allocator_ptr->inst_ptr, obj_ptr->memory_ptr, MNS_AMS_RX_PAYLOAD, obj_ptr->memory_info_ptr);
+        Amsg_RxHandleSetMemory(msg_ptr, NULL, 0U, NULL);
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_amspool.h b/mnsl/mns_amspool.h
new file mode 100644
index 0000000..387dc9b
--- /dev/null
+++ b/mnsl/mns_amspool.h
@@ -0,0 +1,100 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Application Message Pools
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_AMSPOOL
+ * @{
+ */
+
+#ifndef MNS_AMSPOOL_H
+#define MNS_AMSPOOL_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_ams_pb.h"
+#include "mns_amsmessage.h"
+#include "mns_obs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Classes                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Class members of AMS Pool */
+typedef struct CAmsMsgPool_
+{
+    Ams_MemAllocator_t *allocator_ptr;              /*!< \brief  Interface to memory allocator */
+    Mns_AmsRx_Msg_t    *rx_rsvd_msg_ptr;            /*!< \brief  Pre-allocated Rx message or NULL if no 
+                                                     *           reserved message is available */
+    Mns_AmsRx_Msg_t    *rx_rsvd_msg_ref;            /*!< \brief  Stores the reference of the reserved message
+                                                     *           to identify it and restore the 
+                                                     *           \c rx_rsvd_msg_ptr. */
+    CSubject            tx_freed_subject;           /*!< \brief  Allows to observe freed Tx message event */
+    CSubject            rx_freed_subject;           /*!< \brief  Allows to observe freed Rx message event */
+    bool                tx_notify_freed;            /*!< \brief  Is \c true when to notify the next Tx freed object */
+    bool                rx_notify_freed;            /*!< \brief  Is \c true when to notify the next Rx freed object */
+    bool                terminated;                 /*!< \brief  Is \c true if a cleanup was done. Helps to release the 
+                                                     *           pre-allocated message after the first cleanup attempt. */
+    uint8_t             mns_inst_id;                /*!< \brief  MOST NetServices instance ID */
+
+} CAmsMsgPool;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class methods                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+extern void Amsp_Ctor(CAmsMsgPool *self, Ams_MemAllocator_t *mem_allocator_ptr, uint8_t mns_inst_id);
+extern void Amsp_Cleanup(CAmsMsgPool *self);
+/* Tx */
+extern void Amsp_AssignTxFreedObs(CAmsMsgPool *self, CObserver *observer_ptr);
+extern Mns_AmsTx_Msg_t* Amsp_AllocTxObj(CAmsMsgPool *self, uint16_t payload_sz);
+/* Rx */
+extern void Amsp_AssignRxFreedObs(CAmsMsgPool *self, CObserver *observer_ptr);
+extern Mns_AmsRx_Msg_t* Amsp_AllocRxObj(CAmsMsgPool *self, uint16_t payload_sz);
+extern Mns_AmsRx_Msg_t* Amsp_AllocRxRsvd(CAmsMsgPool *self);
+extern bool Amsp_AllocRxPayload(CAmsMsgPool *self, uint16_t payload_sz, Mns_AmsRx_Msg_t* msg_ptr);
+extern void Amsp_FreeRxObj(CAmsMsgPool *self, Mns_AmsRx_Msg_t* msg_ptr);
+extern void Amsp_FreeRxPayload(CAmsMsgPool *self, Mns_AmsRx_Msg_t* msg_ptr);
+
+#ifdef __cplusplus
+}               /* extern "C" */
+#endif
+
+#endif          /* MNS_AMSPOOL_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_base.c b/mnsl/mns_base.c
new file mode 100644
index 0000000..542e485
--- /dev/null
+++ b/mnsl/mns_base.c
@@ -0,0 +1,70 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the Base class.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_BASE
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_base.h"
+#include "mns_misc.h"
+#include "mns_message.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CBase                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of the Base class.
+ *  \param  self        Instance pointer
+ *  \param  init_ptr    Reference to the initialization data
+ */
+void Base_Ctor(CBase *self, Base_InitData_t *init_ptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    /* Save MOST NetServices instance ID */
+    self->mns_inst_id = init_ptr->mns_inst_id;
+    /* Create the scheduler instance */
+    Scd_Ctor(&self->scd, &init_ptr->scd);
+    /* Create the timer management instance */
+    Tm_Ctor(&self->tm, &self->scd, &init_ptr->tm);
+    /* Create the event handler instance */
+    Eh_Ctor(&self->eh, self->mns_inst_id);
+    /* Create the API locking manager instance */
+    Alm_Ctor(&self->alm, &self->tm, &self->eh, self->mns_inst_id);
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_base.h b/mnsl/mns_base.h
new file mode 100644
index 0000000..132243d
--- /dev/null
+++ b/mnsl/mns_base.h
@@ -0,0 +1,93 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the Base class.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_BASE
+ * @{
+ */
+
+#ifndef MNS_BASE_H
+#define MNS_BASE_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_timer.h"
+#include "mns_scheduler.h"
+#include "mns_trace.h"
+#include "mns_eh.h"
+#include "mns_alm.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Initialization structure of the Base class. */
+typedef struct Base_InitData_
+{
+    Scd_InitData_t scd;             /*!< \brief Initialization data of the scheduler */
+    Tm_InitData_t tm;               /*!< \brief Initialization data of the timer management */
+    uint8_t mns_inst_id;            /*!< \brief MOST NetServices instance ID */
+
+} Base_InitData_t;
+
+/*! \brief   Class structure of the Base class. */
+typedef struct CBase_
+{
+    CScheduler scd;                 /*!< \brief Scheduler instance */
+    CTimerManagement tm;            /*!< \brief Timer management instance */
+    CEventHandler eh;               /*!< \brief Event handler instance */
+    CApiLockingManager alm;         /*!< \brief API locking manager instance */
+    uint8_t mns_inst_id;            /*!< \brief MOST NetServices instance ID */
+
+} CBase;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+void Base_Ctor(CBase *self, Base_InitData_t *init_ptr);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_BASE_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_cfg.h b/mnsl/mns_cfg.h
new file mode 100644
index 0000000..dcf6e2b
--- /dev/null
+++ b/mnsl/mns_cfg.h
@@ -0,0 +1,67 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Configuration header file of MOST NetServices Light
+ */
+
+#ifndef MNSL_CFG_H
+#define MNSL_CFG_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* File only needed for other includes. */
+#include "mns_types_cfg.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Message Pool                                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+/* Sets the number of pre-allocated Rx messages which are shared by all FIFOs. Default value: 35*/
+/* #define MNSL_CHANNEL_POOL_SIZE_RX 35 */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tracing & Debugging                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+/* Define the following macros to map info and error trace output to user defined functions. 
+ * The purpose of these functions is debugging. It is not recommended to define these functions 
+ * in a production system.
+ */
+#define MNS_TR_ERROR     My_TraceError
+// #define MNS_TR_INFO      My_TraceInfo
+
+extern void My_TraceError(uint8_t mns_inst_id, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...);
+extern void My_TraceInfo(uint8_t mns_inst_id, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNSL_CFG_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
diff --git a/mnsl/mns_dl.c b/mnsl/mns_dl.c
new file mode 100644
index 0000000..7a7a322
--- /dev/null
+++ b/mnsl/mns_dl.c
@@ -0,0 +1,392 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the doubly linked list.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_DL
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_dl.h"
+#include "mns_trace.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CDlList                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the doubly linked list class.
+ *  \param self        Instance pointer
+ *  \param mns_inst_id MOST NetServices instance ID
+ */
+void Dl_Ctor(CDlList *self, uint8_t mns_inst_id)
+{
+    self->head = NULL;
+    self->tail = NULL;
+    self->size = 0U;
+    self->mns_inst_id = mns_inst_id;
+}
+
+/*! \brief Inserts a new node after an arbitrary node.
+ *  \param self       Instance pointer
+ *  \param node       Reference of the initial node
+ *  \param new_node   Reference of the new node are to be inserted
+ */
+void Dl_InsertAfter(CDlList *self, CDlNode *node, CDlNode *new_node)
+{
+    TR_ASSERT(self->mns_inst_id, "[DL]", (self->size <= 0xFFFFU));
+    new_node->prev = node;
+    new_node->next = node->next;
+    if(node->next == NULL)                      /* Is initial node last node in list? */
+    {
+        self->tail = new_node;                  /* Set new node as tail of list */
+    }
+    else
+    {
+        node->next->prev = new_node;            /* Adjust follower node */
+    }
+    node->next = new_node;                      /* Adjust parent node */
+    new_node->in_use = true;                    /* Signals that node is part of a list */
+    self->size++;                               /* Increment number of nodes */
+}
+
+/*! \brief Inserts a new node before an arbitrary node.
+ *  \param self       Instance pointer
+ *  \param node       Reference of the initial node
+ *  \param new_node   Reference of the new node are to be inserted
+ */
+void Dl_InsertBefore(CDlList *self, CDlNode *node, CDlNode *new_node)
+{
+    TR_ASSERT(self->mns_inst_id, "[DL]", (self->size <= 0xFFFFU));
+    new_node->prev = node->prev;
+    new_node->next = node;
+    if(node->prev == NULL)                      /* Is initial node first node in list? */
+    {
+        self->head = new_node;                  /* Set new node as head of list */
+    }
+    else
+    {
+        node->prev->next = new_node;            /* Adjust parent node */
+    }
+    node->prev = new_node;                      /* Adjust follower node */
+    new_node->in_use = true;                    /* Signals that node is part of a list */
+    self->size++;                               /* Increment number of nodes */
+}
+
+/*! \brief Sets the new node as head of a doubly linked list.
+ *  \param self       Instance pointer
+ *  \param new_node   Reference of the new node are to be placed as head of the list
+ */
+void Dl_InsertHead(CDlList *self, CDlNode *new_node)
+{
+    if(self->head == NULL)                      /* Is list empty? */
+    {
+        TR_ASSERT(self->mns_inst_id, "[DL]", (self->size <= 0xFFFFU));
+        self->head = new_node;
+        self->tail = new_node;
+        new_node->prev = NULL;
+        new_node->next = NULL;
+        new_node->in_use = true;                /* Signals that node is part of a list */
+        self->size++;                           /* Increment number of nodes */
+    }
+    else
+    {
+        Dl_InsertBefore(self, self->head, new_node);
+    }
+}
+
+/*! \brief Inserts the new node at the end of a doubly linked list.
+ *  \param self       Instance pointer
+ *  \param new_node   Reference of the new node are to be placed at the end of the list
+ */
+void Dl_InsertTail(CDlList *self, CDlNode *new_node)
+{
+    if(self->tail == NULL)                      /* Is list empty? */
+    {
+        Dl_InsertHead(self, new_node);
+    }
+    else
+    {
+        Dl_InsertAfter(self, self->tail, new_node);
+    }
+}
+
+/*! \brief  Removes an arbitrary node from a doubly linked list.
+ *  \param  self   Instance pointer
+ *  \param  node   Reference of the node are to be removed from the list
+ *  \return \c DL_OK: No error
+ *  \return \c DL_UNKNOWN_NODE: Given node is not part of this list
+ */
+Dl_Ret_t Dl_Remove(CDlList *self, CDlNode *node)
+{
+    Dl_Ret_t ret_val = DL_UNKNOWN_NODE;
+
+    if(Dl_IsNodeInList(self, node) != false)    /* Is node part of list? */
+    {
+        TR_ASSERT(self->mns_inst_id, "[DL]", (self->size > 0U));
+        if(node->prev == NULL)                  /* First node in list? */
+        {
+            self->head = node->next;            /* Replace head node with next node in list */
+        }
+        else                                    /* -> Not first node in list  */
+        {
+            node->prev->next = node->next;      /* Set next pointer of previous node to next node */
+        }
+        if(node->next == NULL)                  /* Last node in list? */
+        {
+            self->tail = node->prev;            /* Replace tail node with previous node in list */
+        }
+        else                                    /* -> Not last node in list */
+        {
+            node->next->prev = node->prev;      /* Set previous ptr of next node to previous node */
+        }
+        node->prev = NULL;
+        node->next = NULL;
+        node->in_use = false;                   /* Signals that node is not part of a list */
+        ret_val = DL_OK;
+        self->size--;                           /* Decrement number of nodes */
+    }
+
+    return ret_val;
+}
+
+/*! \brief  Removes the first node in a doubly linked list.
+ *  \param  self   Instance pointer
+ *  \return The reference of the removed head node or \c NULL if the list is empty.
+ */
+CDlNode * Dl_PopHead(CDlList *self)
+{
+    CDlNode *node = self->head; 
+
+    if(NULL != node)                            /* Is list not empty? */
+    {
+        TR_ASSERT(self->mns_inst_id, "[DL]", (self->size > 0U));
+        self->head = node->next;                /* Replace head node with next node in list */
+        if(node->next == NULL)                  /* Last node in list? */
+        {
+            self->tail = NULL;                  /* Replace tail node and set list's tail pointer 
+                                                 *  to NULL
+                                                 */
+        }
+        else                                    /* -> Not last node in list */
+        {
+            node->next->prev = NULL;            /* Set previous pointer of next node to NULL */
+        }
+        node->prev = NULL;
+        node->next = NULL;
+        node->in_use = false;                   /* Signals that node is not part of a list */
+        self->size--;                           /* Decrement number of nodes */
+    }
+
+    return node;
+}
+
+/*! \brief  Removes the last node in a doubly linked list.
+ *  \param  self   Instance pointer
+ *  \return The reference of the removed tail node or \c NULL if the list is empty.
+ */
+CDlNode * Dl_PopTail(CDlList *self)
+{
+    CDlNode *node = self->tail;
+
+    if(NULL != node)                            /* Is list not empty? */
+    {
+        TR_ASSERT(self->mns_inst_id, "[DL]", (self->size > 0U));
+        if(node->prev == NULL)                  /* First node in list? */
+        {
+            self->head = NULL;                  /* Replace head node and set list's head pointer 
+                                                 * to NULL
+                                                 */
+        }
+        else                                    /* -> Not first node in list  */
+        {
+            node->prev->next = NULL;            /* Set next pointer of previous node to NULL */
+        }
+        self->tail = node->prev;                /* Replace tail node with previous node in list */
+        node->prev = NULL;
+        node->next = NULL;
+        node->in_use = false;                   /* Signals that node is not part of a list */
+        self->size--;                           /* Decrement number of nodes */
+    }
+
+    return node;
+}
+
+/*! \brief  Returns the reference of the first node in a doubly linked list.
+ *  \param  self   Instance pointer
+ *  \return The reference of the head node or \c NULL if the list is empty.
+ */
+CDlNode * Dl_PeekHead(CDlList *self)
+{
+    return self->head;
+}
+
+/*! \brief  Returns the reference of the last node in a doubly linked list.
+ *  \param  self   Instance pointer
+ *  \return The reference of the tail node or NULL if the list is empty.
+ */
+CDlNode * Dl_PeekTail(CDlList *self)
+{
+    return self->tail;
+}
+
+/*! \brief  Calls the given function for each node in the doubly linked list. If the func_ptr 
+ *          returns true the loop is stopped and the current node will be returned.
+ *  \param  self           Instance pointer
+ *  \param  func_ptr       Reference of the callback function which is called for each node
+ *  \param  user_data_ptr  Reference of optional user data given to func_ptr
+ *  \return Returns the current node or \c NULL if the whole list is processed.
+ */
+CDlNode * Dl_Foreach(CDlList *self, Dl_ForeachFunc_t func_ptr, void *user_data_ptr)
+{
+    CDlNode *ret_val = NULL;
+    CDlNode *node = self->head;
+
+    while(NULL != node)                                         /* End of list reached? */
+    {
+        if(func_ptr(node->data_ptr, user_data_ptr) != false)    /* Data found? */
+        {
+            ret_val = node;
+            break;
+        }
+        node = node->next;
+    }
+    return ret_val;
+}
+
+/*! \brief  Checks if a node is part of the given doubly linked list.
+ *  \param  self   Instance pointer
+ *  \param  node   Reference of the searched node
+ *  \return \c true: Node is part of the given list
+ *  \return \c false: Node is not part of the given list
+ */
+bool Dl_IsNodeInList(CDlList *self, const CDlNode *node)
+{
+    bool ret_val = false;
+    CDlNode *current_node = self->head;
+
+    while(NULL != current_node)                 /* End of list reached? */
+    {
+        if(current_node == node)                /* Is current node the searched one */
+        {
+            ret_val = true;
+            break;
+        }
+        current_node = current_node->next;
+    }
+    return ret_val;
+}
+
+/*! \brief Appends one doubly linked list to another doubly linked list.
+ *  \param self       Instance pointer
+ *  \param list_ptr   Reference to the doubly linked list
+ */
+void Dl_AppendList(CDlList *self, CDlList *list_ptr)
+{
+    TR_ASSERT(self->mns_inst_id, "[DL]", (list_ptr != NULL));
+    if(list_ptr->head != NULL)
+    {
+        if(self->tail == NULL)             /* Is list empty? */
+        {
+            self->head = list_ptr->head;
+            self->tail = list_ptr->tail;
+            self->size = list_ptr->size;
+        }
+        else
+        {
+            list_ptr->head->prev = self->tail;
+            self->tail->next = list_ptr->head;
+            self->tail = list_ptr->tail;
+            self->size += list_ptr->size;
+        }
+        list_ptr->head = NULL;
+        list_ptr->tail = NULL;
+        list_ptr->size = 0U;
+    }
+}
+
+/*! \brief  Interface function to retrieve the list size.
+ *  \param  self   Instance pointer
+ *  \return Size of the list
+ */
+uint16_t Dl_GetSize(CDlList *self)
+{
+    return self->size;
+}
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CDlNode                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of doubly linked list nodes.
+ *  \param self        Instance pointer
+ *  \param data_ptr    Optional reference to data
+ */
+void Dln_Ctor(CDlNode *self, void *data_ptr)
+{
+    self->next = NULL;
+    self->prev = NULL;
+    self->in_use = false;
+    self->data_ptr = data_ptr;
+}
+
+/*! \brief Interface function to set the data pointer of the given node.
+ *  \param self        Instance pointer
+ *  \param data_ptr    Reference of the new data
+ */
+void Dln_SetData(CDlNode *self, void *data_ptr)
+{
+    self->data_ptr = data_ptr;
+}
+
+/*! \brief Interface function to request the data pointer of the given node.
+ *  \param self       Instance pointer
+ */
+void * Dln_GetData(CDlNode *self)
+{
+    return self->data_ptr;
+}
+
+/*! \brief  Checks if a node is part of a doubly linked list.
+ *  \param  self   Instance pointer of the searched node
+ *  \return \c true:  Node is part of a list
+ *  \return \c false: Node is not part of a list
+ */
+bool Dln_IsNodePartOfAList(CDlNode *self)
+{
+    return self->in_use;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_dl.h b/mnsl/mns_dl.h
new file mode 100644
index 0000000..96e89e3
--- /dev/null
+++ b/mnsl/mns_dl.h
@@ -0,0 +1,132 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the doubly linked list.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_DL
+ * @{
+ */
+
+#ifndef MNS_DL_H
+#define MNS_DL_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Type definitions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Callback signature used by foreach-function
+ *  \param d_ptr    Reference to the data of the current node
+ *  \param up_ptr   Reference to the user data
+ *  \return true: Stop the for-each-loop
+ *  \return false: Continue the for-each-loop
+ */
+typedef bool(*Dl_ForeachFunc_t)(void *d_ptr, void *ud_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Enumerators                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Standard return values of the list module. */
+typedef enum Dl_Ret_
+{
+    DL_OK,                      /*!< \brief No error */
+    DL_UNKNOWN_NODE,            /*!< \brief Unknown node */
+    DL_STOPPED                  /*!< \brief Search process stopped */
+
+} Dl_Ret_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Class structure of doubly linked list node. */
+typedef struct DlNode_
+{
+    struct DlNode_ *prev;       /*!< \brief Reference to previous node in list */
+    struct DlNode_ *next;       /*!< \brief Reference to next node in list */
+    void *data_ptr;             /*!< \brief Reference to optional data */
+    bool in_use;                /*!< \brief Flag which signals that the node is in use */
+
+} CDlNode;
+
+/*! \brief Class structure of the doubly linked list. */
+typedef struct CDlList_
+{
+    struct DlNode_ *head;       /*!< \brief Reference to head of the list */
+    struct DlNode_ *tail;       /*!< \brief Reference to tail of the list */
+    uint16_t size;              /*!< \brief Number of nodes in the list */
+    uint8_t mns_inst_id;        /*!< \brief MOST NetServices instance ID */
+
+} CDlList;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CDlList                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+extern void Dl_Ctor(CDlList *self, uint8_t mns_inst_id);
+extern void Dl_InsertAfter(CDlList *self, CDlNode *node, CDlNode *new_node);
+extern void Dl_InsertBefore(CDlList *self, CDlNode *node, CDlNode *new_node);
+extern void Dl_InsertHead(CDlList *self, CDlNode *new_node);
+extern void Dl_InsertTail(CDlList *self, CDlNode *new_node);
+extern Dl_Ret_t Dl_Remove(CDlList *self, CDlNode *node);
+extern CDlNode * Dl_PopHead(CDlList *self);
+extern CDlNode * Dl_PopTail(CDlList *self);
+extern CDlNode * Dl_PeekHead(CDlList *self);
+extern CDlNode * Dl_PeekTail(CDlList *self);
+extern CDlNode * Dl_Foreach(CDlList *self, Dl_ForeachFunc_t func_ptr, void *user_data_ptr);
+extern bool Dl_IsNodeInList(CDlList *self, const CDlNode *node);
+extern void Dl_AppendList(CDlList *self, CDlList *list_ptr);
+extern uint16_t Dl_GetSize(CDlList *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CDlNode                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+extern void Dln_Ctor(CDlNode *self, void *data_ptr);
+extern void Dln_SetData(CDlNode *self, void *data_ptr);
+extern void * Dln_GetData(CDlNode *self);
+extern bool Dln_IsNodePartOfAList(CDlNode *self);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_DL_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_eh.c b/mnsl/mns_eh.c
new file mode 100644
index 0000000..36e0168
--- /dev/null
+++ b/mnsl/mns_eh.c
@@ -0,0 +1,155 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the event handler.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_EH
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_eh.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static bool Eh_EncodeEvent(uint32_t event_code, Mns_Error_t *public_error_code_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CEventHandler                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the event handler class.
+ *  \param self            Instance pointer
+ *  \param mns_inst_id     MOST NetServices instance ID
+ */
+void Eh_Ctor(CEventHandler *self, uint8_t mns_inst_id)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    /* Save MOST NetServices instance ID */
+    self->mns_inst_id = mns_inst_id;
+    /* Initialize subject for internal events */
+    Sub_Ctor(&self->internal_event_subject, self->mns_inst_id);
+    /* Initialize subject for public error reporting */
+    Ssub_Ctor(&self->public_error_subject, self->mns_inst_id);
+}
+
+/*! \brief Adds an observer which reports public errors
+ *  \param self        Instance pointer
+ *  \param obs_ptr     Reference to an observer
+ */
+void Eh_AddObsrvPublicError(CEventHandler *self, CSingleObserver *obs_ptr)
+{
+    (void)Ssub_AddObserver(&self->public_error_subject, obs_ptr);
+}
+
+/*! \brief Removes an observer registered by Eh_AddObsrvPublicError().
+ *  \param self        Instance pointer
+ */
+void Eh_DelObsrvPublicError(CEventHandler *self)
+{
+    Ssub_RemoveObserver(&self->public_error_subject);
+}
+
+/*! \brief Reports an event to the event handler.
+ *  \param self        Instance pointer
+ *  \param event_code  Event code to report
+ */
+void Eh_ReportEvent(CEventHandler *self, uint32_t event_code)
+{
+    Mns_Error_t public_error_code;
+    /* Check if event code exists */
+    if((event_code & EH_M_ALL_EVENTS) != 0U)
+    {
+        /* Encode internal event code */
+        bool result = Eh_EncodeEvent(event_code, &public_error_code);
+        /* Notify all registered observers */
+        Msub_Notify(&self->internal_event_subject, &event_code, event_code);
+        /* Report error to application? */
+        if(result != false)
+        {
+            Ssub_Notify(&self->public_error_subject, &public_error_code, false);
+        }
+    }
+}
+
+/*! \brief  Encodes an internal event code. Some internal event codes are mapped to public
+ *          error codes.
+ *  \param  event_code              Internal event code to report
+ *  \param  public_error_code_ptr   Returned public error code
+ *  \return true if error must be reported to the application, otherwise false
+ */
+static bool Eh_EncodeEvent(uint32_t event_code, Mns_Error_t *public_error_code_ptr)
+{
+    bool ret_val = true;
+
+    /* Translate internal event code into public error code */
+    switch(event_code)
+    {
+        case EH_E_BIST_FAILED:
+            *public_error_code_ptr = MNS_GEN_ERR_INIC;
+            break;
+        case EH_E_UNSYNC_COMPLETE:
+        case EH_E_UNSYNC_FAILED:
+            *public_error_code_ptr = MNS_GEN_ERR_COMMUNICATION;
+            break;
+        default:
+            ret_val = false;    /* Do not report this event to application. */
+            break;
+    }
+
+    return ret_val;
+}
+
+/*! \brief Registers an observer on the given event code.
+ *  \param self        Instance pointer
+ *  \param obs_ptr     Reference to the masked-observer object
+ */
+void Eh_AddObsrvInternalEvent(CEventHandler *self, CMaskedObserver *obs_ptr)
+{
+    (void)Sub_AddObserver(&self->internal_event_subject, &obs_ptr->parent);
+}
+
+/*! \brief Unregisters the given observer from the given event code.
+ *  \param self        Instance pointer
+ *  \param obs_ptr     Reference to the masked-observer object
+ */
+void Eh_DelObsrvInternalEvent(CEventHandler *self, CMaskedObserver *obs_ptr)
+{
+    (void)Sub_RemoveObserver(&self->internal_event_subject, &obs_ptr->parent);
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_eh.h b/mnsl/mns_eh.h
new file mode 100644
index 0000000..2186a2f
--- /dev/null
+++ b/mnsl/mns_eh.h
@@ -0,0 +1,130 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the event handler.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_EH
+ * @{
+ */
+
+#ifndef MNS_EH_H
+#define MNS_EH_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_eh_pb.h"
+#include "mns_obs.h"
+#include "mns_trace.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Definitions                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief A control FIFO synchronization is lost. When this event occurs the PMS still waits 
+ *         until all FIFOs are unsynchronized. So this event is no termination event.
+ */
+#define EH_E_SYNC_LOST              0x0001U
+/*! \brief INIC Build-In-Self-Test failed
+ */
+#define EH_E_BIST_FAILED            0x0002U
+/*! \brief Notifies completed un-synchronization of Port Message FIFOs
+ */
+#define EH_E_UNSYNC_COMPLETE        0x0004U
+/*! \brief Notifies that the Port Message Channel was not able to un-synchronize its FIFOs 
+ *         within a definite time
+ */
+#define EH_E_UNSYNC_FAILED          0x0008U
+/*! \brief MOST NetServices initialization succeeded
+ */
+#define EH_E_INIT_SUCCEEDED         0x0010U
+/*! \brief MOST NetServices initialization failed
+ */
+#define EH_E_INIT_FAILED            0x0020U
+
+/*! \brief Mask including all events that lead to the termination of the MNS
+ */
+#define EH_M_TERMINATION_EVENTS     (EH_E_UNSYNC_COMPLETE | EH_E_UNSYNC_FAILED | \
+                                     EH_E_BIST_FAILED | EH_E_INIT_FAILED)
+
+/*! \brief Bitmask to identify all internal event codes
+ */
+#define EH_M_ALL_EVENTS             (EH_M_TERMINATION_EVENTS | EH_E_INIT_SUCCEEDED | EH_E_SYNC_LOST)
+
+/*------------------------------------------------------------------------------------------------*/
+/* Type definitions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Function signature used for callback functions which notifies the event handler 
+ *         observers.
+ *  \param self             Instance pointer
+ *  \param event_code       Reported event code
+ */
+typedef void (*Ehobs_UpdateCb_t)(void *self, uint32_t event_code);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Class structure of the event handler. */
+typedef struct CEventHandler_
+{
+    /*! \brief Subject used for internal events */
+    CSubject internal_event_subject;
+    /*! \brief Single subject to report error to application */
+    CSingleSubject public_error_subject;
+    /*! \brief MOST NetServices instance ID */
+    uint8_t mns_inst_id;
+
+} CEventHandler;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CEventHandler                                                              */
+/*------------------------------------------------------------------------------------------------*/
+extern void Eh_Ctor(CEventHandler *self, uint8_t mns_inst_id);
+extern void Eh_AddObsrvPublicError(CEventHandler *self, CSingleObserver *obs_ptr);
+extern void Eh_DelObsrvPublicError(CEventHandler *self);
+extern void Eh_ReportEvent(CEventHandler *self, uint32_t event_code);
+extern void Eh_AddObsrvInternalEvent(CEventHandler *self, CMaskedObserver *obs_ptr);
+extern void Eh_DelObsrvInternalEvent(CEventHandler *self, CMaskedObserver *obs_ptr);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_EH_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_eh_pb.h b/mnsl/mns_eh_pb.h
new file mode 100644
index 0000000..422ae15
--- /dev/null
+++ b/mnsl/mns_eh_pb.h
@@ -0,0 +1,68 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Public header file of the event handler.
+ */
+/*!
+ * \addtogroup G_MNS_INIT_AND_SRV_TYPES
+ * @{
+ */
+
+#ifndef MNS_EH_PB_H
+#define MNS_EH_PB_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Enumerations                                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief MOST NetServices general error codes */
+typedef enum Mns_Error_
+{
+    MNS_GEN_ERR_COMMUNICATION = 1,  /*!< \brief Fatal communication error between EHC and INIC  */
+    MNS_GEN_ERR_INIC          = 2   /*!< \brief INIC internal error */
+
+} Mns_Error_t;
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_EH_PB_H */
+
+/*! @} */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_encoder.c b/mnsl/mns_encoder.c
new file mode 100644
index 0000000..5153e64
--- /dev/null
+++ b/mnsl/mns_encoder.c
@@ -0,0 +1,254 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 message encoder
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_ENCODER
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_encoder.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Constants                                                                                      */
+/*------------------------------------------------------------------------------------------------*/
+#define ENC_LLR_TIME_DEFAULT  11U /*! \brief Default LLR time required to transmit valid messages
+                                   *         with ContentType 0x81
+                                   */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void    Enc_Encode_00(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+static void    Enc_Decode_00(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+
+static void    Enc_Encode_80(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+static void    Enc_Decode_80(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+
+static void    Enc_Encode_81(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+static void    Enc_Decode_81(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+ 
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Retrieves the interface of a specific encoder
+ *  \details    Creates all encoder interfaces as singletons
+ *  \param      type    Specifies the type of encoder to retrieve
+ *  \return     The desired interface to the specified encoder 
+ */
+IEncoder *Enc_GetEncoder(Enc_MsgContent_t type)
+{
+    static IEncoder enc_content_00 = {ENC_CONTENT_00, 8U, 12U, &Enc_Encode_00, &Enc_Decode_00};
+    static IEncoder enc_content_80 = {ENC_CONTENT_80, 6U, 11U, &Enc_Encode_80, &Enc_Decode_80};
+    static IEncoder enc_content_81 = {ENC_CONTENT_81, 6U, 13U, &Enc_Encode_81, &Enc_Decode_81};
+    IEncoder *encoder_ptr = NULL;
+
+    switch (type)
+    {
+        case ENC_CONTENT_00:
+            encoder_ptr = &enc_content_00;
+            break;
+        case ENC_CONTENT_80:
+            encoder_ptr = &enc_content_80;
+            break;
+        case ENC_CONTENT_81:
+            encoder_ptr = &enc_content_81;
+            break;
+        default:
+            encoder_ptr = NULL;
+            break;
+    }
+
+    return encoder_ptr;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Content type "00"                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Encodes a message telegram to the "ContentType 0x00" MOST message header 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Encode_00(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{
+    header[0]  = MISC_HB(tel_ptr->source_addr);
+    header[1]  = MISC_LB(tel_ptr->source_addr);
+    header[2]  = MISC_HB(tel_ptr->destination_addr);
+    header[3]  = MISC_LB(tel_ptr->destination_addr);
+
+    header[4]  = tel_ptr->id.fblock_id;
+    header[5]  = tel_ptr->id.instance_id;
+
+    header[6]  = MISC_HB(tel_ptr->id.function_id);
+    header[7]  = MISC_LB(tel_ptr->id.function_id);
+
+    header[8]  = (uint8_t)(tel_ptr->tel.tel_id << 4) | (uint8_t)((uint8_t)tel_ptr->id.op_type & 0xFU);
+    header[9]  = tel_ptr->opts.llrbc;
+
+    header[10] = tel_ptr->tel.tel_cnt;
+    header[11] = tel_ptr->tel.tel_len;
+}
+
+/*! \brief  Decodes a "ContentType 0x00" MOST message header to a message telegram structure 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Decode_00(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{
+    tel_ptr->source_addr        = (uint16_t)((uint16_t)header[0] << 8) | (uint16_t)header[1];
+    tel_ptr->destination_addr   = (uint16_t)((uint16_t)header[2] << 8) | (uint16_t)header[3];
+
+    tel_ptr->id.fblock_id       = header[4];
+    tel_ptr->id.instance_id     = header[5];
+
+    tel_ptr->id.function_id     = (uint16_t)((uint16_t)header[6] << 8) | (uint16_t)header[7];
+
+    tel_ptr->tel.tel_id         = header[8] >> 4;                       /* high nibble: TelId */
+    tel_ptr->id.op_type         = (Mns_OpType_t)(header[8] & 0x0FU);    /* low nibble: OPType */
+
+    tel_ptr->opts.llrbc         = header[9];
+    tel_ptr->tel.tel_cnt        = header[10];
+    tel_ptr->tel.tel_len        = header[11];
+
+    tel_ptr->tel.tel_data_ptr   = &header[12];
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Content type "0x80"                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Encodes a message telegram to the "ContentType 0x80" MOST message header 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Encode_80(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{             /* high nibble: TelId                    low nibble: OPType */
+    header[0]  = (uint8_t)(tel_ptr->tel.tel_id << 4) | (uint8_t)((uint8_t)tel_ptr->id.op_type & 0xFU);
+    header[1]  = tel_ptr->tel.tel_cnt;
+    header[2]  = tel_ptr->tel.tel_len;
+
+    header[3]  = MISC_HB(tel_ptr->id.function_id);
+    header[4]  = MISC_LB(tel_ptr->id.function_id);
+
+    header[5]  = MISC_HB(tel_ptr->source_addr);
+    header[6]  = MISC_LB(tel_ptr->source_addr);
+
+    header[7]  = MISC_HB(tel_ptr->destination_addr);
+    header[8]  = MISC_LB(tel_ptr->destination_addr);
+
+    header[9]  = tel_ptr->id.fblock_id;
+    header[10] = tel_ptr->id.instance_id;
+}
+
+/*! \brief  Decodes a "ContentType 0x80" MOST message header to a message telegram structure 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Decode_80(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{
+    tel_ptr->tel.tel_id         = header[0] >> 4;                       /* high nibble: TelId */
+    tel_ptr->id.op_type         = (Mns_OpType_t)(header[0] & 0x0FU);    /* low nibble: OPType */
+
+    tel_ptr->tel.tel_cnt        = header[1];
+    tel_ptr->tel.tel_len        = header[2];
+
+    tel_ptr->id.function_id     = (uint16_t)((uint16_t)header[3] << 8) | (uint16_t)header[4];
+
+    tel_ptr->source_addr        = (uint16_t)((uint16_t)header[5] << 8) | (uint16_t)header[6];
+    tel_ptr->destination_addr   = (uint16_t)((uint16_t)header[7] << 8) | (uint16_t)header[8];
+
+    tel_ptr->id.fblock_id       = header[9];
+    tel_ptr->id.instance_id     = header[10];
+ 
+    tel_ptr->tel.tel_data_ptr   = &header[11];
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Content type "0x81"                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Encodes a message telegram to the "ContentType 0x81" MOST message header 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Encode_81(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{
+    header[0]  = tel_ptr->opts.llrbc;
+    header[1]  = ENC_LLR_TIME_DEFAULT; 
+    /*           high nibble: TelId                    low nibble: OPType */
+    header[2]  = (uint8_t)(tel_ptr->tel.tel_id << 4) | (uint8_t)((uint8_t)tel_ptr->id.op_type & 0xFU);
+    header[3]  = tel_ptr->tel.tel_cnt;
+    header[4]  = tel_ptr->tel.tel_len;
+
+    header[5]  = MISC_HB(tel_ptr->id.function_id);
+    header[6]  = MISC_LB(tel_ptr->id.function_id);
+
+    header[7]  = MISC_HB(tel_ptr->source_addr);
+    header[8]  = MISC_LB(tel_ptr->source_addr);
+
+    header[9]  = MISC_HB(tel_ptr->destination_addr);
+    header[10] = MISC_LB(tel_ptr->destination_addr);
+
+    header[11] = tel_ptr->id.fblock_id;
+    header[12] = tel_ptr->id.instance_id;
+}
+
+/*! \brief  Decodes a "ContentType 0x81" MOST message header to a message telegram structure 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+static void Enc_Decode_81(Msg_MostTel_t *tel_ptr, uint8_t header[])
+{
+    tel_ptr->opts.llrbc         = header[0];
+
+    tel_ptr->tel.tel_id         = header[2] >> 4;                       /* high nibble: TelId */
+    tel_ptr->id.op_type         = (Mns_OpType_t)(header[2] & 0x0FU);    /* low nibble: OPType */
+
+    tel_ptr->tel.tel_cnt        = header[3];
+    tel_ptr->tel.tel_len        = header[4];
+
+    tel_ptr->id.function_id     = (uint16_t)((uint16_t)header[5] << 8) | (uint16_t)header[6];
+
+    tel_ptr->source_addr        = (uint16_t)((uint16_t)header[7] << 8) | (uint16_t)header[8];
+    tel_ptr->destination_addr   = (uint16_t)((uint16_t)header[9] << 8) | (uint16_t)header[10];
+
+    tel_ptr->id.fblock_id       = header[11];
+    tel_ptr->id.instance_id     = header[12];
+ 
+    tel_ptr->tel.tel_data_ptr   = &header[13];
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_encoder.h b/mnsl/mns_encoder.h
new file mode 100644
index 0000000..439a622
--- /dev/null
+++ b/mnsl/mns_encoder.h
@@ -0,0 +1,118 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of message encoder
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_ENCODER
+ * @{
+ */
+
+#ifndef MNS_ENCODER_H
+#define MNS_ENCODER_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Defines                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+#define ENC_MAX_SIZE_CONTENT    16U     /*!< \brief Maximum content size in bytes, quadlet aligned */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Retrieves the size of a MOST message header
+ *  \return The size of the MOST message header in bytes.
+ */
+typedef uint8_t (*Enc_GetSize_t)(void);
+
+/*! \brief  Retrieves the content type of a MOST message header
+ *  \return The content type of the MOST message header in bytes.
+ */
+typedef uint8_t (*Enc_GetContType_t)(void);
+
+/*! \brief  Encodes a message telegram to the MOST message header 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+typedef void    (*Enc_Encode_t)(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+
+/*! \brief  Decodes a MOST message header to a message telegram structure 
+ *  \param  tel_ptr     Reference to the Msg_MostTel_t structure 
+ *  \param  header      The header buffer 
+ */
+typedef void    (*Enc_Decode_t)(Msg_MostTel_t *tel_ptr, uint8_t header[]);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Identifier for a MOST Message Content */
+typedef enum Enc_MsgContent_
+{
+    ENC_CONTENT_00 = 0x00,  /*!< \brief Content Type "0x00": Uncompressed, excluding retry values */
+    ENC_CONTENT_80 = 0x80,  /*!< \brief Content Type "0x80": Compressed, excluding retry values */
+    ENC_CONTENT_81 = 0x81   /*!< \brief Content Type "0x81": Compressed, including retry values */
+
+} Enc_MsgContent_t;
+
+/*! \brief      Interface for message encoder */
+typedef struct IEncoder_
+{
+    Enc_MsgContent_t    content_type;   /*!< \brief Retrieves the content type of the MOST message header */
+    uint8_t             pm_hdr_sz;      /*!< \brief Retrieves the size of the Port Message header */
+    uint8_t             msg_hdr_sz;     /*!< \brief Retrieves the size of the MOST message header */
+    Enc_Encode_t        encode_fptr;    /*!< \brief Function required to encode a MOST message header */
+    Enc_Decode_t        decode_fptr;    /*!< \brief Function required to decode a MOST message header */
+
+} IEncoder;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Function prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern IEncoder *Enc_GetEncoder(Enc_MsgContent_t type);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_ENCODER_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_lld_pb.h b/mnsl/mns_lld_pb.h
new file mode 100644
index 0000000..d1a087b
--- /dev/null
+++ b/mnsl/mns_lld_pb.h
@@ -0,0 +1,221 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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       Declaration of the low-level driver interface
+ * \defgroup    G_LLD Low-Level Driver
+ * \brief       API functions to be used by the low-level driver.
+ * \details     The MOST NetServices provides a certain set of functions which are only dedicated to the low-level driver.
+ *              The low-level driver \em API is a set of functions which shall be used by the low-level driver.
+ *              The low-level driver \em callbacks is a set of function that shall be implemented by the low-level driver.
+ *              The low-level driver \em callbacks shall be assigned to the MOST NetServices initialization structure.
+ *              During initialization MOST NetServices invokes the callback \ref Mns_Lld_Callbacks_t "start_fptr" and
+ *              passes the low-level driver \em API as pointer to \ref Mns_Lld_Api_t.
+ *              \mns_ic_started{ See also Getting Started with \ref P_UM_STARTED_LLD. }
+ *              \mns_ic_examples{ See also <i>Examples</i>, section \ref P_UM_EXAMPLE_LLD_01, \ref P_UM_EXAMPLE_LLD_02 and \ref P_UM_EXAMPLE_LLD_03. }
+ * \ingroup     G_MNS_API
+ * \defgroup    G_LLD_TYPES Referred Types 
+ * \brief       Referred types used by the low-level driver interface
+ * \ingroup     G_LLD
+ * \defgroup    G_LLD_API Low-Level Driver API
+ * \brief       Function pointers to be used by the low-level driver
+ * \ingroup     G_LLD
+ */
+
+#ifndef MNS_LLD_PB_H
+#define MNS_LLD_PB_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+#include "mns_memory_pb.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*!
+ * \addtogroup  G_LLD_TYPES
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Tx message object providing the raw port message byte stream */
+typedef struct Mns_Lld_TxMsg_
+{
+    struct Mns_Lld_TxMsg_ *custom_next_msg_ptr;/*!< \brief     Shall be used by the LLD implementation to queue messages for
+                                                *              asynchronous transmission
+                                                *   \details   MOST NetServices will set this value to \c NULL since only 
+                                                *              single messages are forwarded to the LLD. Within the transmit function 
+                                                *              it is recommended that the LLD queues the message for asynchronous 
+                                                *              transmission. Despite a driver's transmit function might signal busy for 
+                                                *              a short term MOST NetServices might forward multiple messages for 
+                                                *              transmission. If a driver works asynchronously (interrupt driven) it
+                                                *              can easily use this pointer build a queue of waiting messages. 
+                                                *              Nonetheless, it is important that \ref Mns_Lld_Api_t::tx_release_fptr
+                                                *              "tx_release_fptr" is invoked for every message separately. The Interface 
+                                                *              between MOST NetServices and the LLD does only support single messages.
+                                                */
+    Mns_Mem_Buffer_t *memory_ptr;              /*!< \brief     Points to the data buffer */
+
+} Mns_Lld_TxMsg_t;
+
+/*! \brief  Rx message object pointing to the raw port message byte stream. */
+typedef struct Mns_Lld_RxMsg_
+{
+    uint8_t*        data_ptr;       /*!< \brief Points to a MOST NetServices allocated memory chunk. */
+    uint16_t        data_size;      /*!< \brief Size of the memory chunk in bytes. Valid values: 6..72. */
+
+} Mns_Lld_RxMsg_t;
+
+/*!
+ * @} 
+ * \addtogroup  G_LLD_API
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Low-level driver API                                                                           */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Allocates an Rx message object 
+ *  \param  inst_ptr    Reference to internal MOST NetServices handler
+ *  \param  buffer_size The size in bytes of the received Rx message. 
+ *                      Valid values: 6..72.
+ *  \return The Rx message object or \c NULL if no message object is available. In the latter
+ *          case the low-level driver can wait until Mns_Lld_RxMsgAvailableCb_t() is invoked.
+ *          The low-level driver is allowed to pre-allocate Rx messages with the maximum size
+ *          of 72 bytes. After writing received data into Mns_Lld_RxMsg_t::data_ptr the
+ *          low-level driver must set Mns_Lld_RxMsg_t::data_size to the actual message size.
+ *          \warning
+ *          The function will also return \c NULL if the requested \c buffer_size exceeds the valid range.
+ *          In such a case the MOST NetServices cannot guarantee that Mns_Lld_RxMsgAvailableCb_t() is 
+ *          called as expected. Received messages exceeding the valid range must be discarded by the LLD.
+ */
+typedef Mns_Lld_RxMsg_t* (*Mns_Lld_RxAllocateCb_t)(void *inst_ptr, uint16_t buffer_size);
+
+/*! \brief  Frees an unused Rx message object
+ *  \param  inst_ptr    Reference to internal MOST NetServices handler
+ *  \param  msg_ptr     Reference to the unused Rx message object
+ */
+typedef void (*Mns_Lld_RxFreeUnusedCb_t)(void *inst_ptr, Mns_Lld_RxMsg_t *msg_ptr);
+
+/*! \brief  Pass an Rx message to MOST NetServices 
+ *  \param  inst_ptr    Reference to internal MOST NetServices handler
+ *  \param  msg_ptr     Reference to the Rx message object containing the received
+ *                      message.
+ */
+typedef void (*Mns_Lld_RxReceiveCb_t)(void *inst_ptr, Mns_Lld_RxMsg_t *msg_ptr);
+
+/*! \brief  Notifies that the LLD no longer needs to access the Tx message object
+ *  \param  inst_ptr    Reference to internal MOST NetServices handler
+ *  \param  msg_ptr     Reference to the Tx message object which is no longer accessed
+ *                      by the low-level driver
+ */
+typedef void (*Mns_Lld_TxReleaseCb_t)(void *inst_ptr, Mns_Lld_TxMsg_t *msg_ptr);
+
+/*! \brief   Initialization required for one communication channel (control or packet)
+ */
+typedef struct Mns_Lld_Api_
+{
+    Mns_Lld_RxAllocateCb_t   rx_allocate_fptr;     /*!< \brief  Allocates an Rx message object */
+    Mns_Lld_RxFreeUnusedCb_t rx_free_unused_fptr;  /*!< \brief  Frees an unused Rx message object */
+    Mns_Lld_RxReceiveCb_t    rx_receive_fptr;      /*!< \brief  Pass an Rx message to MOST NetServices */
+    Mns_Lld_TxReleaseCb_t    tx_release_fptr;      /*!< \brief  Notifies that the LLD no longer needs to access the Tx message object */
+
+} Mns_Lld_Api_t;
+
+/*!
+ * @} 
+ * \addtogroup  G_LLD
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* LLD interface functions                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief      Notifies the LLD to start transmitting and receiving messages
+ *  \param      api_ptr         Reference to MOST NetServices LLD interface
+ *  \param      ns_ptr          Reference to internal MOST NetServices handler
+ */
+typedef void (*Mns_Lld_StartCb_t)(Mns_Lld_Api_t* api_ptr, void *ns_ptr, void *inst_ptr);
+
+/*! \brief      Notifies the LLD to stop/abort transmitting and receiving messages
+ *  \details    As soon as this function is called the low-level driver is not allowed 
+ *              to call any MOST NetServices function.
+ */
+typedef void (*Mns_Lld_StopCb_t)(void *inst_ptr);
+
+/*! \brief      Notifies the LLD to reset the INIC
+ *  \details    If this function is called the low-level driver is responsible to 
+ *              perform an INIC hardware reset.
+ */
+typedef void (*Mns_Lld_ResetInicCb_t)(void *inst_ptr);
+
+/*! \brief      Callback function which is invoked as soon as port message objects are available again.
+ *  \details    By implementing this callback function the low-level driver can avoid polling for 
+ *              Rx message objects. The low-level driver should wait for the function call as soon 
+ *              as Mns_Lld_RxAllocateCb_t() returns NULL. Only then it shall call those functions again.
+ */
+typedef void (*Mns_Lld_RxMsgAvailableCb_t)(void *inst_ptr);
+
+/*! \brief      Callback function which is invoked to transmit a single message to the INIC
+  * \param      msg_ptr     Reference to a single Tx message.
+  */
+typedef void (*Mns_Lld_TxTransmitCb_t)(Mns_Lld_TxMsg_t *msg_ptr, void *inst_ptr);
+
+/*!
+ * @} 
+ * \addtogroup  G_LLD_TYPES
+ * @{
+ */
+
+/*! \brief  Set of functions implemented by the low-level driver
+ */
+typedef struct Mns_Lld_Callbacks_
+{
+    Mns_Lld_StartCb_t          start_fptr;         /*!< \brief    Callback function to initialize the low-level driver and 
+                                                    *             start the transmission and reception of messages */
+    Mns_Lld_StopCb_t           stop_fptr;          /*!< \brief    Callback function to stop/abort the transmission and reception of messages */
+    Mns_Lld_RxMsgAvailableCb_t rx_available_fptr;  /*!< \brief    Callback function which is invoked as soon as Rx message objects are available again */
+    Mns_Lld_TxTransmitCb_t     tx_transmit_fptr;   /*!< \brief    Callback function to transmit one or multiple messages to the INIC */
+
+} Mns_Lld_Callbacks_t;
+
+/*! @} */
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_LLD_PB_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_lldpool.c b/mnsl/mns_lldpool.c
new file mode 100644
index 0000000..ae9f33d
--- /dev/null
+++ b/mnsl/mns_lldpool.c
@@ -0,0 +1,101 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 LLD Message Pool
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMF
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_lldpool.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Returns an unused LLD Tx message object back to the pool
+ *  \param  self        The instance
+ *  \param  owner_ptr   Assigns messages to the respective FIFO
+ *  \param  mns_inst_id MOST NetServices instance ID
+ */
+void Lldp_Ctor(CLldPool *self, void *owner_ptr, uint8_t mns_inst_id)
+{
+    uint8_t cnt;
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    Dl_Ctor(&self->list, mns_inst_id);
+
+    for (cnt = 0U; cnt < LLDP_NUM_HANDLES; cnt++)         /* setup LLD Tx handles */
+    {
+        TR_ASSERT(mns_inst_id, "[FIFO]", (NULL == self->messages[cnt].msg_ptr));
+        Dln_Ctor(&self->messages[cnt].node, &self->messages[cnt]);
+        self->messages[cnt].owner_ptr = owner_ptr;
+        Dl_InsertTail(&self->list, &self->messages[cnt].node);
+    }
+}
+
+/*! \brief  Returns an unused LLD Tx message object back to the pool
+ *  \param  self    The instance
+ *  \param  msg_ptr The unused LLD Tx message object 
+ */
+void Lldp_ReturnTxToPool(CLldPool *self, Lld_IntTxMsg_t *msg_ptr)
+{
+    Dl_InsertTail(&self->list, &msg_ptr->node);
+}
+
+/*! \brief  Allocates an unused LLD Tx message object from the pool
+ *  \param  self    The instance
+ *  \return An internal LLD Tx message object or \c NULL if no message object is 
+ *          available.
+ */
+Lld_IntTxMsg_t* Lldp_GetTxFromPool(CLldPool *self)
+{
+    CDlNode *node_ptr = NULL;
+    Lld_IntTxMsg_t *handle_ptr = NULL;
+
+    node_ptr = Dl_PopHead(&self->list);
+
+    if (node_ptr != NULL)
+    {
+        handle_ptr = (Lld_IntTxMsg_t*)Dln_GetData(node_ptr);
+    }
+
+    return handle_ptr;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_lldpool.h b/mnsl/mns_lldpool.h
new file mode 100644
index 0000000..fdf4419
--- /dev/null
+++ b/mnsl/mns_lldpool.h
@@ -0,0 +1,112 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of LLD Message Pool
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_PMF
+ * @{
+ */
+
+#ifndef MNS_LLDPOOL_H
+#define MNS_LLDPOOL_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_base.h"
+#include "mns_lld_pb.h"
+#include "mns_message.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Number of LLD Tx handles dedicated to each FIFO */
+#define LLDP_NUM_HANDLES              5U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal types                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Internal LLD Tx message */
+typedef struct Lld_IntTxMsg_
+{
+    Mns_Lld_TxMsg_t lld_msg;    /*!< \brief     Contains the public LLD Tx message
+                                 *   \details   This attribute needs to be the first one in this structure
+                                 */
+    CDlNode     node;           /*!< \brief     Node required for queuing */
+    CMessage   *msg_ptr;        /*!< \brief     Reference to the associated common message object, or
+                                 *              \c NULL if the object is a command */
+    void       *owner_ptr;      /*!< \brief     Points to the FIFO which owns the message object 
+                                 *              or NULL if the object is a command */
+
+} Lld_IntTxMsg_t;
+
+/*! \brief  Internal LLD Rx message */
+typedef struct Lld_IntRxMsg_
+{
+    Mns_Lld_RxMsg_t  lld_msg;   /*!< \brief     Contains the public LLD Rx message 
+                                 *   \details   This attribute needs to be the first one in this structure
+                                 */
+    CMessage        *msg_ptr;   /*!< \brief     Reference to the associated common message object*/
+ 
+} Lld_IntRxMsg_t;
+
+/*! \brief The class CLldPool*/
+typedef struct CLldPool_
+{ 
+    CDlList list;                             /*!< \brief Points to the first available message in Tx pool */
+    Lld_IntTxMsg_t messages[LLDP_NUM_HANDLES];/*!< \brief Available messages in Tx pool */
+
+} CLldPool;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Function prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Lldp_Ctor(CLldPool *self, void *owner_ptr, uint8_t mns_inst_id);
+extern void Lldp_ReturnTxToPool(CLldPool *self, Lld_IntTxMsg_t *msg_ptr);
+extern Lld_IntTxMsg_t* Lldp_GetTxFromPool(CLldPool *self);
+
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif                                              /* MNS_LLDPOOL_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_memory.h b/mnsl/mns_memory.h
new file mode 100644
index 0000000..5b80bf1
--- /dev/null
+++ b/mnsl/mns_memory.h
@@ -0,0 +1,112 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of internal memory buffer
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_MEMORY
+ * @{
+ */
+
+#ifndef MNS_MEMORY_H
+#define MNS_MEMORY_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_memory_pb.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* IAllocator Types                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Callback function which frees memory 
+ *  \param      allocator       Reference to the Mem_Allocator_t object
+ *  \param      mem_ptr         Reference to memory chunk 
+ *  \param      mem_info_ptr    Customer specific information needed to free 
+ *                              the related memory chunk
+ */
+typedef void  (*Mem_Free_t)(void *allocator, void* mem_ptr, void* mem_info_ptr);
+
+/*! \brief      Callback function which allocated memory 
+ *  \param      allocator       Reference to the Mem_Allocator_t object
+ *  \param      size            Size of the demanded memory chunk 
+ *  \param      mem_info_ptr    Customer specific information needed to free 
+ *                              the related memory chunk
+ *  \return     Reference to a memory chunk with a minimum size of \c size. 
+ *              Otherwise NULL.
+ */
+typedef void* (*Mem_Allocate_t)(void *allocator, uint16_t size, void** mem_info_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Interface IAllocator                                                                           */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Interface which is needed to be implemented by a memory allocator */
+typedef struct IAllocator_
+{
+    void*              base;            /*!< Reference to the base class */
+    Mem_Allocate_t     allocate_fptr;   /*!< Callback function required to allocate memory */
+    Mem_Free_t         free_fptr;       /*!< Callback function required to free memory */
+
+} IAllocator;
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Memory buffer                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Memory chunk comprising non public fields */
+typedef struct Mem_IntBuffer_
+{
+    Mns_Mem_Buffer_t   public_buffer;  /*!< \brief      Public attributes of memory buffer
+                                        *   \details    This has to be the first member in this 
+                                        *               struct
+                                        */
+    IAllocator        *allocator_ptr;  /*!< \brief      Reference to the allocator which is 
+                                        *               required to free the memory chunk 
+                                        */
+    void              *mem_info_ptr;   /*!< \brief      Customer specific information needed to 
+                                        *               free the related memory chunk
+                                        */
+} Mem_IntBuffer_t;
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_MEMORY_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_memory_pb.h b/mnsl/mns_memory_pb.h
new file mode 100644
index 0000000..2165e73
--- /dev/null
+++ b/mnsl/mns_memory_pb.h
@@ -0,0 +1,72 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of memory buffer and memory allocator
+ */
+/*!
+ * \addtogroup G_LLD_TYPES
+ * @{
+ */
+
+#ifndef MNS_MEMORY_PB_H
+#define MNS_MEMORY_PB_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Memory buffer                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Memory chunk representing a message or part of a message. */
+typedef struct Mns_Mem_Buffer_
+{
+    struct Mns_Mem_Buffer_  *next_buffer_ptr;   /*!< \brief Points to an additional memory buffer
+                                                 *          that belongs to the same message. 
+                                                 */
+    uint8_t                 *data_ptr;          /*!< \brief Points to the data buffer */
+    uint16_t                 data_size;         /*!< \brief Size of the data buffer */
+    uint16_t                 total_size;        /*!< \brief Reserved for future use. Size of this and all concatenated data buffers */
+
+} Mns_Mem_Buffer_t;
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_MEMORY_PB_H */
+
+/*! @} */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_message.c b/mnsl/mns_message.c
new file mode 100644
index 0000000..33a0673
--- /dev/null
+++ b/mnsl/mns_message.c
@@ -0,0 +1,331 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 class message
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_MESSAGE
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+#include "mns_misc.h"
+ 
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of common MOST message class
+ *  \param      self    The instance
+ */
+void Msg_Ctor(CMessage *self)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    Dln_Ctor(&self->node, self);
+
+    self->rsvd_memory.allocator_ptr = NULL;
+    self->rsvd_memory.mem_info_ptr  = NULL;
+    self->rsvd_memory.public_buffer.next_buffer_ptr = NULL;
+    self->rsvd_memory.public_buffer.data_ptr = &self->rsvd_buffer[0];
+    self->rsvd_memory.public_buffer.data_size  = MSG_SIZE_RSVD_BUFFER;
+    self->rsvd_memory.public_buffer.total_size = MSG_SIZE_RSVD_BUFFER;
+
+    self->start_ptr                = &self->rsvd_buffer[0];
+    self->pb_msg.tel.tel_data_ptr  = &self->rsvd_buffer[0];
+/*  self->pb_msg.tel.tel_id        = 0U;
+    self->pb_msg.tel.tel_cnt       = 0U;
+    self->pb_msg.tel.tel_len       = 0U; */
+
+    self->pb_msg.opts.llrbc     = MSG_LLRBC_DEFAULT;
+
+/*  self->header_rsvd_sz           = 0U;
+    self->header_curr_idx          = 0U;
+    self->header_curr_sz           = 0U;
+    self->ref_ptr                  = NULL; */
+}
+
+/*! \brief      Prepares the message for re-usage 
+ *  \details    In future this function has to take care that external memory
+ *              has to be reinitialize properly.
+ *  \param      self    The instance
+ */
+void Msg_Cleanup(CMessage *self)
+{
+    void *handle = self->lld_handle_ptr;       /* restore associated LLD message object */
+    void *pool_ptr = self->pool_ptr;           /* restore associated pool reference */
+
+    Msg_Ctor(self);                            /* simply call constructor now */
+
+    self->lld_handle_ptr = handle;
+    self->pool_ptr = pool_ptr;
+}
+
+/*! \brief      Adds external message payload to the message
+ *  \details    The internally reserved message payload is no longer in in use.
+ *  \param      self            The instance
+ *  \param      payload_ptr     Pointer to externally allocated payload
+ *  \param      payload_sz      Size of externally allocated payload
+ *  \param      mem_info_ptr    Reference to additional memory information
+ */
+void Msg_SetExtPayload(CMessage *self, uint8_t *payload_ptr, uint8_t payload_sz, void* mem_info_ptr)
+{
+    self->pb_msg.tel.tel_data_ptr = payload_ptr;
+    self->pb_msg.tel.tel_len = payload_sz;
+
+    self->ext_memory.allocator_ptr = NULL;
+    self->ext_memory.mem_info_ptr  = mem_info_ptr;
+    self->ext_memory.public_buffer.data_ptr = payload_ptr;
+    self->ext_memory.public_buffer.data_size  = payload_sz;
+    self->ext_memory.public_buffer.total_size = payload_sz;
+    self->ext_memory.public_buffer.next_buffer_ptr = NULL;
+}
+
+/*! \brief      Initially defines a header space in front of the data body
+ *  \details    Ensure that \c start_ptr is assigned correctly before calling 
+ *              this functions.
+ *  \param      self        The instance
+ *  \param      header_sz   Size of the header
+ */
+void Msg_ReserveHeader(CMessage *self, uint8_t header_sz)
+{
+ /* self->start_ptr stays */
+    self->header_rsvd_sz  = header_sz;
+    self->header_curr_idx = header_sz;
+    self->header_curr_sz  = 0U;
+
+    self->pb_msg.tel.tel_data_ptr = &self->start_ptr[header_sz];
+}
+
+/*! \brief      Adds a defined header space in front of the current header
+ *  \param      self        The instance
+ *  \param      header_sz   Size of the header
+ */
+void Msg_PullHeader(CMessage *self, uint8_t header_sz)
+{
+/*  MNS_ASSERT(header_sz <= self->curr_header_sz); */
+
+/*  self->pb_msg.tel.tel_data_ptr  = &self->rsvd_buffer[MSG_SIZE_RSVD_HEADER];*/
+    self->header_curr_idx -= header_sz;
+    self->header_curr_sz  += header_sz;
+}
+
+/*! \brief      Undoes a message header of a defined size
+ *  \param      self        The instance
+ *  \param      header_sz   Size of the header
+ */
+void Msg_PushHeader(CMessage *self, uint8_t header_sz)
+{
+    self->header_curr_idx += header_sz;
+    self->header_curr_sz  -= header_sz;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class Properties (get/set)                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Retrieves the reference to the containing MOST Telegrams structure 
+ *  \param  self    The instance
+ *  \return Pointer to the internal MOST Telegram structure
+ */
+Msg_MostTel_t* Msg_GetMostTel(CMessage *self)
+{
+    return &self->pb_msg;
+}
+
+/*! \brief  Retrieves the start of the current message header
+ *  \param  self    The instance
+ *  \return Pointer to the current header start 
+ */
+uint8_t* Msg_GetHeader(CMessage *self)
+{
+    return &(self->rsvd_buffer[self->header_curr_idx]);
+}
+
+/*! \brief  Retrieves the size of the current message header
+ *  \param  self    The instance
+ *  \return Size of the current header in bytes 
+ */
+uint8_t Msg_GetHeaderSize(CMessage * self)
+{
+    return (self->header_curr_sz);
+}
+
+/*! \brief  Retrieves the message buffer as memory structure
+ *  \param  self    The instance
+ *  \return Reference to the message memory structure
+ */
+Mns_Mem_Buffer_t* Msg_GetMemTx(CMessage *self)
+{
+    self->rsvd_memory.public_buffer.data_ptr = &(self->rsvd_buffer[self->header_curr_idx]);
+
+    if (self->ext_memory.public_buffer.data_size == 0U)
+    {
+        self->rsvd_memory.public_buffer.next_buffer_ptr = NULL;
+        self->rsvd_memory.public_buffer.data_size = (uint16_t)self->header_curr_sz + (uint16_t)self->pb_msg.tel.tel_len;
+        self->rsvd_memory.public_buffer.total_size = (uint16_t)self->header_curr_sz + (uint16_t)self->pb_msg.tel.tel_len;
+    }
+    else
+    {
+        self->rsvd_memory.public_buffer.next_buffer_ptr = &self->ext_memory.public_buffer;
+        self->rsvd_memory.public_buffer.data_size = (uint16_t)self->header_curr_sz;             /* only header is enclosed */
+        self->rsvd_memory.public_buffer.total_size = self->rsvd_memory.public_buffer.data_size 
+                                                    + self->ext_memory.public_buffer.data_size;
+    }
+
+    return &self->rsvd_memory.public_buffer;
+}
+
+/*! \brief  Assigns a message status handler which is called as soon as the message is processed
+ *  \param  self            The instance
+ *  \param  callback_fptr   Reference to the status callback function
+ *  \param  inst_ptr        The instance which implements the status callback
+ */
+void Msg_SetTxStatusHandler(CMessage *self, Msg_TxStatusCb_t callback_fptr, void *inst_ptr)
+{
+    self->tx_status_inst = inst_ptr;
+    self->tx_status_fptr = callback_fptr;
+}
+
+/*! \brief  Marks the message as occupied by the LLD
+ *  \param  self       The instance
+ *  \param  active     Set to \c true if the message is occupied by the LLD, otherwise \c false.
+ */
+void Msg_SetTxActive(CMessage *self, bool active)
+{
+    self->tx_active = active;
+}
+
+/*! \brief  Checks if the message as occupied by the LLD
+ *  \param  self       The instance
+ *  \return Returns \c true if the message is occupied by the LLD, otherwise \c false.
+ */
+bool Msg_IsTxActive(CMessage *self)
+{
+    return self->tx_active;
+}
+
+/*! \brief  Marks the message as bypass message
+ *  \param  self       The instance
+ *  \param  bypass     Set to \c true if the message is supposed to be a bypass message, otherwise \c false.
+ */
+void Msg_SetTxBypass(CMessage *self, bool bypass)
+{
+    self->tx_bypass = bypass;
+}
+
+/*! \brief  Checks if the message is marked as bypass message
+ *  \param  self       The instance
+ *  \return Returns \c true if the message is marked as bypass message, otherwise \c false.
+ */
+bool Msg_IsTxBypass(CMessage *self)
+{
+    return self->tx_bypass;
+}
+
+/*! \brief  Fires a status notification for the message object
+ *  \param  self    The instance
+ *  \param  status  The transmission status
+ */
+void Msg_NotifyTxStatus(CMessage *self, Mns_MsgTxStatus_t status)
+{
+    if (self->tx_status_fptr != NULL)
+    {
+        self->tx_status_fptr(self->tx_status_inst, &self->pb_msg, status); 
+    }
+}
+
+/*! \brief  Assigns a low-level driver message
+ *  \param  self    The instance
+ *  \param  handle  The reference to a low-level driver message object (Tx or Rx)
+ */
+void Msg_SetLldHandle(CMessage *self, void *handle)
+{
+    self->lld_handle_ptr = handle;
+}
+
+/*! \brief  Retrieves the reference to a low-level driver message
+ *  \param  self    The instance
+ *  \return The reference to a low-level driver message object or \c NULL
+ *          if no message is assigned.
+ */
+void *Msg_GetLldHandle(CMessage *self)
+{
+    return self->lld_handle_ptr;
+}
+
+/*! \brief  Assigns a reference for the owning pool
+ *  \param  self      The instance
+ *  \param  pool_ptr  The reference to the owning pool
+ */
+void Msg_SetPoolReference(CMessage *self, void *pool_ptr)
+{
+    self->pool_ptr = pool_ptr;
+}
+
+/*! \brief  Retrieves a reference for the owning pool
+ *  \param  self      The instance
+ *  \return The reference to the owning pool or \c NULL
+ *          if no pool is assigned.
+ */
+void *Msg_GetPoolReference(CMessage *self)
+{
+    return self->pool_ptr;
+}
+
+/*! \brief  Retrieves the reference to the internal node member
+ *  \param  self    The instance
+ *  \return The reference the internal list node 
+ */
+CDlNode *Msg_GetNode(CMessage *self)
+{
+    return &self->node;
+}
+
+/*! \brief  Performs checks on length payload length 
+ *  \param  self    The instance
+ *  \return Returns \c true if the verification succeeded. Otherwise \c false.
+ */
+bool Msg_VerifyContent(CMessage *self)
+{
+    bool success = (self->pb_msg.tel.tel_len <= MSG_MAX_SIZE_PAYLOAD) ? true : false;
+
+    return success;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_message.h b/mnsl/mns_message.h
new file mode 100644
index 0000000..69d82ea
--- /dev/null
+++ b/mnsl/mns_message.h
@@ -0,0 +1,238 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of class message
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_MESSAGE
+ * @{
+ */
+
+#ifndef MNS_MESSAGE_H
+#define MNS_MESSAGE_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_memory.h"
+#include "mns_dl.h"
+#include "mns_message_pb.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Common macros                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+#define MSG_ADDR_INVALID    0U  /*!< \brief   The (source) address the INIC uses to declare an invalid source address.
+                                 *   \details Invalid source addresses can be:
+                                 *            - invalid messages from MOST: source_address = [0x0000..0x000F] 
+                                 *            - invalid messages from EHC: source_address != [0x0002, 0x0003]
+                                 *            .
+                                 */
+#define MSG_ADDR_INIC       1U  /*!< \brief The address of the local INIC */
+#define MSG_ADDR_EHC_CFG    2U  /*!< \brief The address of the EHC configuration interface (ICM and RCM FIFO) */
+#define MSG_ADDR_EHC_APP    3U  /*!< \brief The address of the EHC application interface (MCM FIFO) */
+
+#define MSG_LLRBC_DEFAULT   10U /*!< \brief The default LowLevelRetry BlockCount */
+#define MSG_LLRBC_MAX       100U/*!< \brief The maximum LowLevelRetry BlockCount */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  MOST message id "FBlockID.InstID.FktID.OPType" */
+typedef struct Msg_MsgId_
+{
+    uint8_t         fblock_id;      /*!< \brief FBlockID */
+    uint8_t         instance_id;    /*!< \brief InstID */
+    uint16_t        function_id;    /*!< \brief FktID */
+    Mns_OpType_t    op_type;        /*!< \brief Operation type */
+
+} Msg_MsgId_t;
+
+/*! \brief  Retry options */
+typedef struct Msg_TxOptions_
+{
+    uint8_t     llrbc;          /*!< \brief   Low-level retry block count performed by the INIC. 
+                                 *   \details The LLRBC are applicable for MCMs. ICMs don't care.
+                                 *            Values exceeding the maximum value are be corrected 
+                                 *            by the INIC silently to the maximum value.
+                                 *            Valid range: 0..100
+                                 */
+    uint8_t     cancel_id;      /*!< \brief   Either "0" or label for a group of dependent telegrams. 
+                                 *   \details The value determines the required action if the transmission
+                                 *            has failed.
+                                 *            Valid range:
+                                 *            - 0: Only the failed telegram will is removed from the FIFO.
+                                 *            - 1..255: All telegrams with the same cancel_id as a failed telegram 
+                                 *              will be removed from the FIFO queue.
+                                 */
+
+} Msg_TxOptions_t;
+
+/*! \brief  Most telegram data */
+typedef struct Msg_TelData_
+{
+    uint8_t     tel_id;         /*!< \brief Telegram id which indicates the telegram as part of
+                                 *          segmented message or as single transfer. */
+    uint8_t     tel_len;        /*!< \brief The telegram length. 
+                                 *          I.e. the number of telegram bytes starting at address
+                                 *          which is referred in \c tel_data_ptr. The INIC will add
+                                 *          \em one in case of \"tel_id = 1..3\". 
+                                 */
+    uint8_t     tel_cnt;        /*!< \brief The message count indexing the telegram within a segmented
+                                 *          message.
+                                 *          The respective tel_cnt is moved by the INIC to \"DATA[0]\"
+                                 *          in case of \"tel_id = 1..3\". Otherwise it is ignored.
+                                 */
+    uint8_t    *tel_data_ptr;   /*!< \brief Points to telegram data. */
+
+} Msg_TelData_t;
+
+/*! \brief  Common MOST message */
+typedef struct Msg_MostTel_
+{
+    uint16_t destination_addr;      /*!< \brief MOST destination address */
+    uint16_t source_addr;           /*!< \brief MOST source address */
+
+    Msg_MsgId_t         id;         /*!< \brief MOST message id "FBlockID.InstID.FktID.OPType" */
+    Msg_TxOptions_t     opts;       /*!< \brief Message transmission options */
+    Msg_TelData_t       tel;        /*!< \brief MOST telegram data */
+    void               *info_ptr;   /*!< \brief Possible reference to additional data */
+
+} Msg_MostTel_t;
+
+/* necessary forward declaration */
+struct CMessage_;
+/*! \brief Common message class which provides MOST style message addressing */
+typedef struct CMessage_ CMessage;
+
+/*! \brief  Assignable function which is invoked as soon as transmission
+ *          of the message object is finished. 
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the message object
+ *  \param  status  Transmission status
+ */
+typedef void (*Msg_TxStatusCb_t)(void *self, Msg_MostTel_t *tel_ptr, Mns_MsgTxStatus_t status);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      Size in bytes of reserved message header */
+#define MSG_SIZE_RSVD_HEADER  24U
+/*! \brief      Size in bytes of message payload */
+#define MSG_MAX_SIZE_PAYLOAD  45U
+/*! \brief      Size in bytes of pre-allocated message buffer
+ *  \details    Size = 24(header) + 45(payload) + 3(stuffing) = 72 */
+#define MSG_SIZE_RSVD_BUFFER  72U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class CMessage                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Class CMessage 
+ *  \details Common internal message class which embeds the public message attributes
+ */
+struct CMessage_
+{
+    Msg_MostTel_t       pb_msg;                 /*!< \brief  Public part which defines the MOST telegram 
+                                                 *           structure. This attribute must be the first 
+                                                 *           element inside the message structure.
+                                                 */
+    uint8_t rsvd_buffer[MSG_SIZE_RSVD_BUFFER];  /*!< \brief  Reserved memory space */
+    Mem_IntBuffer_t     rsvd_memory;            /*!< \brief  Reserved memory which is needed at least for the
+                                                 *           Port message header (24 bytes) */
+    Mem_IntBuffer_t     ext_memory;             /*!< \brief  Possible user memory */
+
+    uint8_t            *start_ptr;              /*!< \brief  Points to the start of the message buffer */
+    uint8_t             header_curr_idx;        /*!< \brief  Index of the end of the current header */
+    uint8_t             header_curr_sz;         /*!< \brief  Current size of header in bytes */
+    uint8_t             header_rsvd_sz;         /*!< \brief  Reserved size of header in bytes */
+
+    void               *pool_ptr;               /*!< \brief  Point to the pool the message is allocated from and released to */
+    void               *lld_handle_ptr;         /*!< \brief  Possible reference to another message object */
+    CDlNode             node;                   /*!< \brief  Node for usage in a doubly linked list */
+
+    Msg_TxStatusCb_t    tx_status_fptr;         /*!< \brief  Pointer to Tx status callback */
+    void               *tx_status_inst;         /*!< \brief  Reference to instance which needs Tx status notification */
+
+    bool                tx_active;              /*!< \brief  Is \c true if the object is occupied by the LLD, otherwise \c false */
+    bool                tx_bypass;              /*!< \brief  Is \c true if a message was queued as bypass message */
+};
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Methods                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+extern void             Msg_Ctor(CMessage *self);
+extern void             Msg_Cleanup(CMessage *self);
+
+extern void             Msg_ReserveHeader(CMessage *self, uint8_t header_sz);
+extern void             Msg_PullHeader(CMessage *self, uint8_t header_sz);
+extern void             Msg_PushHeader(CMessage *self, uint8_t header_sz);
+
+extern void             Msg_NotifyTxStatus(CMessage *self, Mns_MsgTxStatus_t status);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Properties                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+extern Msg_MostTel_t*   Msg_GetMostTel(CMessage *self);
+
+extern uint8_t*         Msg_GetHeader(CMessage *self);
+extern uint8_t          Msg_GetHeaderSize(CMessage *self);
+extern Mns_Mem_Buffer_t* Msg_GetMemTx(CMessage *self);
+
+extern void             Msg_SetLldHandle(CMessage *self, void *handle);
+extern void            *Msg_GetLldHandle(CMessage *self);
+extern void             Msg_SetPoolReference(CMessage *self, void *pool_ptr);
+extern void            *Msg_GetPoolReference(CMessage *self);
+
+extern CDlNode         *Msg_GetNode(CMessage *self);
+
+extern void             Msg_SetTxStatusHandler(CMessage *self, Msg_TxStatusCb_t callback_fptr, void *inst_ptr);
+extern void             Msg_SetExtPayload(CMessage *self, uint8_t *payload_ptr, uint8_t payload_sz, void* mem_info_ptr);
+extern void             Msg_SetTxActive(CMessage *self, bool active);
+extern bool             Msg_IsTxActive(CMessage *self);
+extern void             Msg_SetTxBypass(CMessage *self, bool bypass);
+extern bool             Msg_IsTxBypass(CMessage *self);
+
+extern bool             Msg_VerifyContent(CMessage *self);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_MESSAGE_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_message_pb.h b/mnsl/mns_message_pb.h
new file mode 100644
index 0000000..8656519
--- /dev/null
+++ b/mnsl/mns_message_pb.h
@@ -0,0 +1,121 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of public message types
+ */
+
+#ifndef MNS_MESSAGE_PB_H
+#define MNS_MESSAGE_PB_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*!
+ * \addtogroup G_MNS_AMS
+ * @{
+ */
+/*------------------------------------------------------------------------------------------------*/
+/* Defines                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+#define MNS_ADDR_INTERNAL                0x0000U  /*!< \brief   Internal transmission destination address
+                                                   *   \details Can be used for internal message transmission
+                                                   *            to avoid possible race conditions during 
+                                                   *            recalculation of the own node address.
+                                                   */
+#define MNS_ADDR_BROADCAST_BLOCKING     0x03C8U  /*!< \brief Blocking broadcast destination address */
+#define MNS_ADDR_BROADCAST_UNBLOCKING   0x03FFU  /*!< \brief Unblocking broadcast destination address */
+#define MNS_ADDR_DEBUG                   0x0FF0U  /*!< \brief Optional debug destination address */
+/*! @} */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Message transmission status for internal/debug use
+ *  \ingroup G_MNS_MISC_RET_RES
+ */
+typedef enum Mns_MsgTxStatus_
+{
+    MNS_MSG_STAT_OK                     = 0x00U, /*!< \brief Transmission succeeded */
+    MNS_MSG_STAT_ERROR_CFG_NO_RCVR      = 0x01U, /*!< \brief No internal receiver exists */
+    MNS_MSG_STAT_ERROR_BF               = 0x08U, /*!< \brief Buffer full */ 
+    MNS_MSG_STAT_ERROR_CRC              = 0x09U, /*!< \brief CRC */ 
+    MNS_MSG_STAT_ERROR_ID               = 0x0AU, /*!< \brief Corrupted identifiers */ 
+    MNS_MSG_STAT_ERROR_ACK              = 0x0BU, /*!< \brief Corrupted PACK or CACK */ 
+    MNS_MSG_STAT_ERROR_TIMEOUT          = 0x0CU, /*!< \brief TX timeout */
+    MNS_MSG_STAT_ERROR_FATAL_WT         = 0x10U, /*!< \brief Wrong target */ 
+    MNS_MSG_STAT_ERROR_FATAL_OA         = 0x11U, /*!< \brief Own node address */
+    MNS_MSG_STAT_ERROR_NA_TRANS         = 0x18U, /*!< \brief Control channel was switched off and 
+                                                  *          a pending transmission was canceled */ 
+    MNS_MSG_STAT_ERROR_NA_OFF           = 0x19U, /*!< \brief Control channel not available */
+    MNS_MSG_STAT_ERROR_UNKNOWN          = 0xFEU, /*!< \brief Unknown error status */
+    MNS_MSG_STAT_ERROR_SYNC             = 0xFFU  /*!< \brief Internal error which is notified if 
+                                                  *          communication link with INIC is lost
+                                                  */
+} Mns_MsgTxStatus_t;
+
+/*! \brief   Operation Types 
+ *  \ingroup G_MNS_AMS_TYPES
+ */
+typedef enum Mns_OpType_
+{
+    MNS_OP_SET              = 0x0,  /*!< \brief Operation Set (Property) */
+    MNS_OP_GET              = 0x1,  /*!< \brief Operation Get (Property) */
+    MNS_OP_SETGET           = 0x2,  /*!< \brief Operation SetGet (Property) */
+    MNS_OP_INC              = 0x3,  /*!< \brief Operation Increment (Property) */
+    MNS_OP_DEC              = 0x4,  /*!< \brief Operation Decrement (Property) */
+    MNS_OP_STATUS           = 0xC,  /*!< \brief Operation Status (Property) */
+
+    MNS_OP_START            = 0x0,  /*!< \brief Operation Start (Method) */
+    MNS_OP_ABORT            = 0x1,  /*!< \brief Operation Abort (Method) */
+    MNS_OP_STARTRESULT      = 0x2,  /*!< \brief Operation StartResult (Method) */
+    MNS_OP_PROCESSING       = 0xB,  /*!< \brief Operation Processing (Method) */
+    MNS_OP_RESULT           = 0xC,  /*!< \brief Operation Result (Method) */
+
+    MNS_OP_STARTACK         = 0x8,  /*!< \brief Operation StartAck (Method) */
+    MNS_OP_ABORTACK         = 0x7,  /*!< \brief Operation AbortAck (Method) */
+    MNS_OP_STARTRESULTACK   = 0x6,  /*!< \brief Operation StartResultAck (Method) */
+    MNS_OP_PROCESSINGACK    = 0xA,  /*!< \brief Operation ProcessingAck (Method) */
+    MNS_OP_RESULTACK        = 0xD,  /*!< \brief Operation ResultAck (Method) */
+
+    MNS_OP_GETINTERFACE     = 0x5,  /*!< \brief Operation GetInterface (Property/Method) */
+    MNS_OP_INTERFACE        = 0xE,  /*!< \brief Operation Interface (Property/Method) */
+    MNS_OP_ERROR            = 0xF,  /*!< \brief Operation Error (Property/Method) */
+    MNS_OP_ERRORACK         = 0x9   /*!< \brief Operation ErrorAck (Property/Method) */
+
+} Mns_OpType_t;
+
+#ifdef __cplusplus
+}                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_MESSAGE_PB_H */
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_misc.c b/mnsl/mns_misc.c
new file mode 100644
index 0000000..c020c11
--- /dev/null
+++ b/mnsl/mns_misc.c
@@ -0,0 +1,82 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the library module which contains miscellaneous helper functions.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_MISC
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief MOST NetServices internal memset-function.
+ *  \param dst_ptr Pointer to the block of memory to fill
+ *  \param value   Value to be set
+ *  \param size    Number of bytes to be set to the value
+ */
+void Misc_MemSet(void *dst_ptr, int32_t value, uint32_t size)
+{
+    uint8_t *dst_ptr_ = (uint8_t *)dst_ptr;
+    uint32_t i;
+
+    for(i=0U; i<size; i++)
+    {
+        dst_ptr_[i] = (uint8_t)value;   /* parasoft-suppress  MISRA2004-17_4 "void pointer required for memset-function signature (stdlib)" */
+    }
+}
+
+/*! \brief MOST NetServices internal memcpy-function.
+ *  \param dst_ptr Pointer to the destination array where the content is to be copied
+ *  \param src_ptr Pointer to the source of data to be copied
+ *  \param size    Number of bytes to copy
+ */
+void Misc_MemCpy(void *dst_ptr, void *src_ptr, uint32_t size)
+{
+    uint8_t *dst_ptr_ = (uint8_t *)dst_ptr;
+    uint8_t *src_ptr_ = (uint8_t *)src_ptr;
+    uint32_t i;
+
+    for(i=0U; i<size; i++)
+    {
+        dst_ptr_[i] = src_ptr_[i];  /* parasoft-suppress  MISRA2004-17_4 "void pointers required for memcpy-function signature (stdlib)" */
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_misc.h b/mnsl/mns_misc.h
new file mode 100644
index 0000000..76d005f
--- /dev/null
+++ b/mnsl/mns_misc.h
@@ -0,0 +1,157 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the library module which contains miscellaneous helper functions.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_MISC
+ * @{
+ */
+
+#ifndef MNS_MISC_H
+#define MNS_MISC_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Standard library functions                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/* parasoft suppress item MISRA2004-19_7 reason "function-like macros allowed for stdlib and helper functions" */
+
+/*! \def     MISC_MEM_SET
+ *  \brief   Macro to encapsulate memset function
+ *  \details By defining the macro MNS_MEM_SET the application is able to specify its own memset
+ *           function. If the macro is not defined MOST NetServices internal memset function
+ *           Misc_MemSet() is used.
+ *  \param   dest   Pointer to the block of memory to fill
+ *  \param   value  Value to be set
+ *  \param   size   Number of bytes to be set to the value.
+ */
+#ifdef MNS_MEM_SET
+#define MISC_MEM_SET(dest, value, size)   (MNS_MEM_SET((dest), (value), (size)))
+#else
+#define MISC_MEM_SET(dest, value, size)   (Misc_MemSet((dest), (value), (size)))
+#endif
+
+/*! \def     MISC_MEM_CPY
+ *  \brief   Macro to encapsulate memcpy function
+ *  \details By defining the macro MNS_MEM_CPY the application is able to specify its own memcpy
+ *           function. If the macro is not defined MOST NetServices internal memcpy function
+ *           Misc_MemCpy() is used.
+ *  \param   dest   Pointer to the destination array where the content is to be copied
+ *  \param   src    Pointer to the source of data to be copied
+ *  \param   size   Number of bytes to copy
+ */
+#ifdef MNS_MEM_CPY
+#define MISC_MEM_CPY(dest, src, size)   (MNS_MEM_CPY((dest), (src), (size)))
+#else
+#define MISC_MEM_CPY(dest, src, size)   (Misc_MemCpy((dest), (src), (size)))
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Helper Macros                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Macro to avoid compiler warning "Unused Parameter" */
+#define MISC_UNUSED(p)      ((p) = (p))
+
+/*! \brief High Byte of 16-bit value */
+#define MISC_HB(value)      ((uint8_t)((uint16_t)(value) >> 8))
+
+/*! \brief Low Byte of 16-bit value */
+#define MISC_LB(value)      ((uint8_t)((uint16_t)(value) & (uint16_t)0xFF))
+
+/*! \brief Big-Endian to target 16 bit */
+#define MISC_DECODE_WORD(w_ptr, msb_ptr) (*(w_ptr) = \
+            (uint16_t)((uint16_t)((uint16_t)(msb_ptr)[0] << 8) | (uint16_t)(msb_ptr)[1]))
+
+/*! \brief Big-Endian to target 32 bit */
+#define MISC_DECODE_DWORD(dw_ptr, msb_ptr) (*(dw_ptr) = \
+            (uint32_t)((uint32_t)((uint32_t)(msb_ptr)[0] << 24) | \
+            (uint32_t)((uint32_t)(msb_ptr)[1] << 16) | \
+            (uint32_t)((uint32_t)(msb_ptr)[2] << 8) | (uint32_t)(msb_ptr)[3]))
+
+/*! \brief Checks if a value is inside a certain range */
+#define MISC_IS_VALUE_IN_RANGE(val, min, max)   ((((val) >= (min)) && ((val) <= (max))) ? true : false)
+
+/*! \brief Checks if the given size is a multiple of 4. If not, the given size is corrected 
+ *         by that macro.
+ */
+#define MISC_QUADLET_ALGINED_SIZE(size)         (((((size)+4U)-1U)/4U)*4U)
+
+/* parasoft unsuppress item MISRA2004-19_7 reason "function-like macros allowed for stdlib and helper functions" */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+extern void Misc_MemSet(void *dst_ptr, int32_t value, uint32_t size);
+extern void Misc_MemCpy(void *dst_ptr, void *src_ptr, uint32_t size);
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*!
+ *  \def     MNS_MEM_SET
+ *  \brief   Customer assignment of memset function
+ *  \details By defining the macro MNS_MEM_SET the application is able to specify its own memset
+ *           function to be used by the MOST NetServices. If the macro is not set the MOST 
+ *           NetServices will use byte wise write operations.
+ *  \ingroup G_MNS_MISC
+ */ 
+#ifndef MNS_MEM_SET
+#define MNS_MEM_SET
+#endif
+
+/*!
+ *  \def     MNS_MEM_CPY
+ *  \brief   Customer assignment of memcpy function
+ *  \details By defining the macro MNS_MEM_CPY the application is able to specify its own memcpy
+ *           function to be used by the MOST NetServices. If the macro is not set the MOST 
+ *           NetServices will use byte wise copy operations.
+ *  \ingroup G_MNS_MISC
+ */ 
+#ifndef MNS_MEM_CPY
+#define MNS_MEM_CPY
+#endif
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_MISC_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_obs.c b/mnsl/mns_obs.c
new file mode 100644
index 0000000..7183fb2
--- /dev/null
+++ b/mnsl/mns_obs.c
@@ -0,0 +1,453 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the observer library module. The module consists of the two classes 
+ *        CSubject and CObserver.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_OBS
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_obs.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+#include <assert.h> //TKU
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal Prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Sub_UpdateList(CSubject *self);
+static bool Sub_CheckObserver(void *current_obs_ptr, void *subject_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CSubject                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the subject class. Initializes a subject which distributes its data to
+ *         a list of observers.
+ *  \param self        Instance pointer
+ *  \param mns_inst_id MOST NetServices instance ID
+ */
+void Sub_Ctor(CSubject *self, uint8_t mns_inst_id)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->mns_inst_id = mns_inst_id;
+    Dl_Ctor(&self->list, self->mns_inst_id);
+    Dl_Ctor(&self->add_list, self->mns_inst_id);
+}
+
+/*! \brief  Adds an observer to a subjects list.
+ *  \param  self       Instance pointer
+ *  \param  obs_ptr    Pointer to observer instance
+ *  \return \c SUB_OK: No error
+ *  \return \c SUB_ALREADY_ADDED: Observer is already added
+ *  \return \c SUB_UNKNOWN_OBSERVER: Given observer is not valid
+ */
+Sub_Ret_t Sub_AddObserver(CSubject *self, CObserver *obs_ptr)
+{
+    Sub_Ret_t ret_val;
+    if(obs_ptr == NULL)
+    {
+        ret_val = SUB_UNKNOWN_OBSERVER;
+    }
+    else if(obs_ptr->valid != false)
+    {
+        ret_val = SUB_ALREADY_ADDED;
+    }
+    else if((self->notify != false) &&
+            (false == Dl_IsNodeInList(&self->list, &obs_ptr->node)) &&
+            (false == Dl_IsNodeInList(&self->add_list, &obs_ptr->node)))
+    {
+        TR_ASSERT(self->mns_inst_id, "[OBS]", (self->num_observers < 0xFFU));
+        Dl_InsertTail(&self->add_list, &obs_ptr->node);
+        obs_ptr->valid = true;
+        self->changed = true;
+        ret_val = SUB_DELAYED;
+    }
+    else if((self->notify == false) && (false == Dl_IsNodeInList(&self->list, &obs_ptr->node)))
+    {
+        TR_ASSERT(self->mns_inst_id, "[OBS]", (self->num_observers < 0xFFU));
+        ret_val = SUB_OK;
+        Dl_InsertTail(&self->list, &obs_ptr->node);
+        obs_ptr->valid = true;
+        self->num_observers++;
+    }
+    else
+    {
+        ret_val = SUB_UNKNOWN_OBSERVER;
+    }
+    return ret_val;
+}
+
+/*! \brief  Removes an observer from a subjects list.
+ *  \param  self       Instance pointer
+ *  \param  obs_ptr    Pointer to observer instance
+ *  \return \c SUB_OK: No error
+ *  \return \c SUB_UNKNOWN_OBSERVER: Unknown observer is given
+ *  \return \c SUB_UNKNOWN_OBSERVER: Given observer is not valid
+ */
+Sub_Ret_t Sub_RemoveObserver(CSubject *self, CObserver *obs_ptr)
+{
+    Sub_Ret_t ret_val;
+    if(obs_ptr == NULL)
+    {
+        ret_val = SUB_UNKNOWN_OBSERVER;
+    }
+    else if(obs_ptr->valid == false)
+    {
+        ret_val = SUB_UNKNOWN_OBSERVER;
+    }
+    else if((self->notify != false) &&
+            (Dl_IsNodeInList(&self->list, &obs_ptr->node) != false))
+    {
+        TR_ASSERT(self->mns_inst_id, "[OBS]", (self->num_observers > 0U));
+        obs_ptr->valid = false;
+        self->changed = true;
+        self->num_observers--;
+        ret_val = SUB_DELAYED;
+    }
+    else if((self->notify == false) &&
+            (DL_OK == Dl_Remove(&self->list, &obs_ptr->node)))
+    {
+        TR_ASSERT(self->mns_inst_id, "[OBS]", (self->num_observers > 0U));
+        self->num_observers--;
+        ret_val = SUB_OK;
+    }
+    else
+    {
+        ret_val = SUB_UNKNOWN_OBSERVER;
+    }
+    return ret_val;
+}
+
+/*! \brief Notifies all registered observers of a subject.
+ *  \param self   Instance pointer
+ *  \param data_ptr  Reference to value to distribute (optional)
+ */
+void Sub_Notify(CSubject *self, void *data_ptr)
+{
+    if(NULL != self)
+    {
+        CDlNode *n_tmp = self->list.head;
+        self->notify = true;
+        self->changed = false;
+        while(NULL != n_tmp)
+        {
+            CObserver *o_tmp = (CObserver *)n_tmp->data_ptr;
+            if((NULL != o_tmp->update_fptr) && (o_tmp->valid != false))
+            {
+                (o_tmp->update_fptr)(o_tmp->inst_ptr, data_ptr);
+            }
+            n_tmp = n_tmp->next;
+        }
+        if(self->changed != false)
+        {
+            Sub_UpdateList(self);
+        }
+        self->notify = false;
+    }
+}
+
+/*! \brief Updates the list of observers. Delayed remove- and add-operations are processed.
+ *  \param self   Instance pointer
+ */
+static void Sub_UpdateList(CSubject *self)
+{
+    (void)Dl_Foreach(&self->list, &Sub_CheckObserver, self);
+    Dl_AppendList(&self->list, &self->add_list);
+}
+
+/*! \brief  Checks if the given observer is still valid. If the observer is invalid it will be
+ *          removed from the list. This function is used by the foreach loop in Sub_UpdateList().
+ *  \param  current_obs_ptr     Reference to the current observer object
+ *  \param  subject_ptr         Reference to the subject object
+ *  \return Returns always \c false. Force to process the whole list.
+ */
+static bool Sub_CheckObserver(void *current_obs_ptr, void *subject_ptr)
+{
+    CObserver *current_obs_ptr_ = (CObserver *)current_obs_ptr;
+    CSubject *subject_ptr_ = (CSubject *)subject_ptr;
+
+    if(false == current_obs_ptr_->valid)
+    {
+        (void)Dl_Remove(&subject_ptr_->list, &current_obs_ptr_->node);
+    }
+    return false;
+}
+
+/*! \brief  Returns the number of registered observers of a subject.
+ *  \param  self   Instance pointer
+ *  \return The number of registered observers
+ */
+uint8_t Sub_GetNumObservers(CSubject *self)
+{
+    return self->num_observers;
+}
+
+/*! \brief  Switches all observers of the source-subject to the target-subject.
+ *  \param  sub_target  Target subject
+ *  \param  sub_source  Source subject
+ *  \return \c SUB_OK: No error
+ *  \return \c SUB_INVALID_OPERATION: Target and source must be different objects
+ */
+Sub_Ret_t Sub_SwitchObservers(CSubject *sub_target, CSubject *sub_source)
+{
+    Sub_Ret_t ret_val;
+
+    if(sub_target == sub_source)
+    {
+        ret_val = SUB_INVALID_OPERATION;
+    }
+    else
+    {
+        Dl_AppendList(&sub_target->list, &sub_source->list);
+        sub_target->num_observers += sub_source->num_observers;
+        sub_source->num_observers = 0U;
+        ret_val = SUB_OK;
+    }
+    return ret_val;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CObserver                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the observer class. Initializes an observer which is notified
+ *         by a corresponding subject.
+ *  \param self        Instance pointer
+ *  \param inst_ptr    Instance pointer used by update_fptr()
+ *  \param update_fptr Callback function to update the observer
+ */
+void Obs_Ctor(CObserver *self, void *inst_ptr, Obs_UpdateCb_t update_fptr)
+{
+    assert(NULL != inst_ptr);
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->inst_ptr = inst_ptr;
+    self->update_fptr = update_fptr;
+    Dln_Ctor(&self->node, self);
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CSingleSubject                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the single-subject class. Initializes a single-subject which distributes 
+ *         its data to the registered single-observer.
+ *  \param self        Instance pointer
+ *  \param mns_inst_id MOST NetServices instance ID
+ */
+void Ssub_Ctor(CSingleSubject *self, uint8_t mns_inst_id)
+{
+    self->observer_ptr = NULL;
+    self->mns_inst_id = mns_inst_id;
+}
+
+/*! \brief  Adds a single-observer to a single-subject.
+ *  \param  self       Instance pointer
+ *  \param  obs_ptr    Pointer to single-observer instance
+ *  \return \c SSUB_OK: No error
+ *  \return \c SSUB_ALREADY_ADDED: Observer is already added
+ *  \return \c SSUB_UNKNOWN_OBSERVER: Given observer is not valid
+ */
+Ssub_Ret_t Ssub_AddObserver(CSingleSubject *self, CSingleObserver *obs_ptr)
+{
+    Ssub_Ret_t ret_val;
+    if(obs_ptr == NULL)
+    {
+        ret_val = SSUB_UNKNOWN_OBSERVER;
+    }
+    else if(self->observer_ptr != obs_ptr)
+    {
+#ifdef MNS_TR_INFO
+        if(self->observer_ptr != NULL)
+        {
+            TR_INFO((self->mns_inst_id, "[SSUB]", "Observer callback has been overwritten", 0U));
+        }
+#endif
+        ret_val = SSUB_OK;
+        self->observer_ptr = obs_ptr;
+    }
+    else
+    {
+        ret_val = SSUB_ALREADY_ADDED;
+    }
+ 
+    return ret_val;
+}
+
+/*! \brief Removes an single-observer from a single-subject.
+ *  \param self       Instance pointer
+ */
+void Ssub_RemoveObserver(CSingleSubject *self)
+{
+    self->observer_ptr = NULL;
+}
+
+/*! \brief Notifies the registered single-observer of the given single-subject.
+ *  \param self   Instance pointer
+ *  \param data_ptr        Reference to value to distribute (optional)
+ *  \param auto_remove     If true the observer will be removed
+ */
+void Ssub_Notify(CSingleSubject *self, void *data_ptr, bool auto_remove)
+{
+    void *inst_ptr = NULL;
+    Obs_UpdateCb_t update_fptr = NULL;
+    if(self->observer_ptr != NULL)
+    {
+        inst_ptr = self->observer_ptr->inst_ptr;
+        update_fptr = self->observer_ptr->update_fptr;
+        if(auto_remove != false)
+        {
+            self->observer_ptr = NULL;
+        }
+    }
+    if(update_fptr != NULL)
+    {
+        update_fptr(inst_ptr, data_ptr);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CSingleObserver                                                        */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the single-observer class. Initializes an single-observer which is
+ *         notified by a corresponding single-subject.
+ *  \param self        Instance pointer
+ *  \param inst_ptr    Instance pointer used by update_fptr()
+ *  \param update_fptr Callback function to update the observer
+ */
+void Sobs_Ctor(CSingleObserver *self, void *inst_ptr, Sobs_UpdateCb_t update_fptr)
+{
+    self->inst_ptr = inst_ptr;
+    self->update_fptr = update_fptr;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CMaskedObserver                                                        */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the masked-observer class. Initializes an observer which is notified
+ *         by a corresponding subject.
+ *  \param self                 Instance pointer
+ *  \param inst_ptr             Instance pointer used by update_fptr()
+ *  \param notification_mask    Notification bitmask
+ *  \param update_fptr Callback function to update the observer
+ */
+void Mobs_Ctor(CMaskedObserver *self,
+               void *inst_ptr,
+               uint32_t notification_mask,
+               Obs_UpdateCb_t update_fptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    Obs_Ctor(&self->parent, inst_ptr, update_fptr);
+    self->notification_mask = notification_mask;
+}
+
+/*! \brief Sets the notification mask of a masked-observer.
+ *  \param self     Instance pointer
+ *  \param mask     Bitmask to set
+ */
+void Mobs_SetNotificationMask(CMaskedObserver *self, uint32_t mask)
+{
+    self->notification_mask = mask;
+}
+
+/*! \brief Retrieves the notification mask of a masked-observer.
+ *  \param  self     Instance pointer
+ *  \return Returns the current notification bitmask of the given observer
+ */
+uint32_t Mobs_GetNotificationMask(CMaskedObserver *self)
+{
+    return self->notification_mask;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Additional methods of class CSubject used in combination with CMaskedObserver                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Adds an masked-observer to a masked-subjects list.
+ *  \param  self       Instance pointer
+ *  \param  obs_ptr    Pointer to observer instance
+ *  \return \c SUB_OK: No error
+ *  \return \c SUB_ALREADY_ADDED: Observer is already added
+ *  \return \c SUB_UNKNOWN_OBSERVER: Given observer is not valid
+ */
+Sub_Ret_t Msub_AddObserver(CSubject *self, CMaskedObserver *obs_ptr)
+{
+    return Sub_AddObserver(self, &obs_ptr->parent);
+}
+
+/*! \brief  Removes an masked-observer from a subjects list.
+ *  \param  self       Instance pointer
+ *  \param  obs_ptr    Pointer to observer instance
+ *  \return \c SUB_OK: No error
+ *  \return \c SUB_UNKNOWN_OBSERVER: Unknown observer is given
+ *  \return \c SUB_UNKNOWN_OBSERVER: Given observer is not valid
+ */
+Sub_Ret_t Msub_RemoveObserver(CSubject *self, CMaskedObserver *obs_ptr)
+{
+    return Sub_RemoveObserver(self, &obs_ptr->parent);
+}
+
+/*! \brief Notifies all registered masked-observers of a masked-subject.
+ *  \param self                 Instance pointer
+ *  \param data_ptr             Reference to value to distribute (optional)
+ *  \param notification_mask    Bitmask indicates notified observers
+ */
+void Msub_Notify(CSubject *self, void *data_ptr, uint32_t notification_mask)
+{
+    if(NULL != self)
+    {
+        CDlNode *n_tmp = self->list.head;
+        self->notify = true;
+        self->changed = false;
+        while(NULL != n_tmp)
+        {
+            CMaskedObserver *o_tmp = (CMaskedObserver *)n_tmp->data_ptr;
+            if( (NULL != o_tmp->parent.update_fptr) &&
+                (o_tmp->parent.valid != false)      &&
+                ((o_tmp->notification_mask & notification_mask) != 0U) )
+            {
+                (o_tmp->parent.update_fptr)(o_tmp->parent.inst_ptr, data_ptr);
+            }
+            n_tmp = n_tmp->next;
+        }
+        if(self->changed != false)
+        {
+            Sub_UpdateList(self);
+        }
+        self->notify = false;
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_obs.h b/mnsl/mns_obs.h
new file mode 100644
index 0000000..088c6c8
--- /dev/null
+++ b/mnsl/mns_obs.h
@@ -0,0 +1,196 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the observer library module. The module consists of the two
+ *        classes CSubject and CObserver.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_OBS
+ * @{
+ */
+
+#ifndef MNS_OBS_H
+#define MNS_OBS_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+#include "mns_dl.h"
+#include "mns_ret.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Type definitions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Function signature used for callback functions which notifies the observers.
+ *  \param self     Instance pointer
+ *  \param data_ptr Reference to optional data
+ */
+typedef void (*Obs_UpdateCb_t)(void *self, void *data_ptr);
+
+/*! \brief Function signature used for callback functions which notifies the single-observers.
+ *  \param self     Instance pointer
+ *  \param data_ptr Reference to optional data
+ */
+typedef void (*Sobs_UpdateCb_t)(void *self, void *data_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Enumerators                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Standard return values of the subject class. */
+typedef enum Sub_Ret_
+{
+    SUB_OK,                 /*!< \brief No error */
+    SUB_DELAYED,            /*!< \brief Operation is queued since notification is still active */
+    SUB_ALREADY_ADDED,      /*!< \brief Observer already added */
+    SUB_UNKNOWN_OBSERVER,   /*!< \brief Unknown observer */
+    SUB_INVALID_OPERATION   /*!< \brief Invalid operation */
+
+} Sub_Ret_t;
+
+/*! \brief Standard return values of the single-subject class. */
+typedef enum Ssub_Ret_
+{
+    SSUB_OK,                /*!< \brief No error */
+    SSUB_ALREADY_ADDED,     /*!< \brief Observer already added */
+    SSUB_UNKNOWN_OBSERVER   /*!< \brief Unknown observer */
+
+} Ssub_Ret_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Class structure of observers which are notified by subjects. */
+typedef struct CObserver_
+{
+    CDlNode node;               /*!< \brief Node element to be able to add observer to list */
+    void *inst_ptr;             /*!< \brief Reference to instance used by update_fptr() */
+    Obs_UpdateCb_t update_fptr; /*!< \brief Callback function to update the observer */
+    bool valid;                 /*!< \brief Used for queued remove operation */
+
+} CObserver;
+
+/*! \brief Class structure of subjects. */
+typedef struct CSubject_
+{
+    CDlList list;               /*!< \brief Doubly linked list to manage observers */
+    CDlList add_list;           /*!< \brief List to manage delayed add operations */
+    uint8_t num_observers;      /*!< \brief Number of added observers */
+    bool notify;                /*!< \brief Signals that the notification is in progress */
+    bool changed;               /*!< \brief Signals that an add- or a remove-operation
+                                            has been queued */
+    uint8_t mns_inst_id;        /*!< \brief MOST NetServices instance ID */
+
+} CSubject;
+
+/*! \brief Class structure of a single-observer which is notified by a single-subject. */
+typedef struct CSingleObserver_
+{
+    void *inst_ptr;             /*!< \brief Reference to instance used by update_fptr() */
+    Obs_UpdateCb_t update_fptr; /*!< \brief Callback function to update the observer */
+
+} CSingleObserver;
+
+/*! \brief Class structure of a single-subject. */
+typedef struct CSingleSubject_
+{
+    CSingleObserver *observer_ptr;  /*!< \brief Reference to the assigned single-observer */
+    uint8_t mns_inst_id;            /*!< \brief MOST NetServices instance ID */
+
+} CSingleSubject;
+
+/*! \brief Class structure of masked observers which are notified by subjects. */
+typedef struct CMaskedObserver_
+{
+    CObserver parent;               /*!< \brief Parent class instance */
+    uint32_t notification_mask;     /*!< \brief Notification bitmask */
+
+} CMaskedObserver;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CSubject                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+extern void Sub_Ctor(CSubject *self, uint8_t mns_inst_id);
+extern Sub_Ret_t Sub_AddObserver(CSubject *self, CObserver *obs_ptr);
+extern Sub_Ret_t Sub_RemoveObserver(CSubject *self, CObserver *obs_ptr);
+extern void Sub_Notify(CSubject *self, void *data_ptr);
+extern uint8_t Sub_GetNumObservers(CSubject *self);
+extern Sub_Ret_t Sub_SwitchObservers(CSubject *sub_target, CSubject *sub_source);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CObserver                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+extern void Obs_Ctor(CObserver *self, void *inst_ptr, Obs_UpdateCb_t update_fptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CSingleSubject                                                             */
+/*------------------------------------------------------------------------------------------------*/
+extern void Ssub_Ctor(CSingleSubject *self, uint8_t mns_inst_id);
+extern Ssub_Ret_t Ssub_AddObserver(CSingleSubject *self, CSingleObserver *obs_ptr);
+extern void Ssub_RemoveObserver(CSingleSubject *self);
+extern void Ssub_Notify(CSingleSubject *self, void *data_ptr, bool auto_remove);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CSingleObserver                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Sobs_Ctor(CSingleObserver *self, void *inst_ptr, Sobs_UpdateCb_t update_fptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CMaskedObserver                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Mobs_Ctor(CMaskedObserver *self,
+                      void *inst_ptr,
+                      uint32_t notification_mask,
+                      Obs_UpdateCb_t update_fptr);
+extern void Mobs_SetNotificationMask(CMaskedObserver *self, uint32_t mask);
+extern uint32_t Mobs_GetNotificationMask(CMaskedObserver *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Additional prototypes of class CSubject used in combination with CMaskedObserver               */
+/*------------------------------------------------------------------------------------------------*/
+extern Sub_Ret_t Msub_AddObserver(CSubject *self, CMaskedObserver *obs_ptr);
+extern Sub_Ret_t Msub_RemoveObserver(CSubject *self, CMaskedObserver *obs_ptr);
+extern void Msub_Notify(CSubject *self, void *data_ptr, uint32_t notification_mask);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_OBS_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmchannel.c b/mnsl/mns_pmchannel.c
new file mode 100644
index 0000000..e98a2b2
--- /dev/null
+++ b/mnsl/mns_pmchannel.c
@@ -0,0 +1,311 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Port Message Channel
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMC
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmchannel.h"
+#include "mns_pmp.h"
+#include "mns_pmcmd.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal Constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal typedefs                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+/* LLD related interface functions */
+static Mns_Lld_RxMsg_t* Pmch_RxAllocate(void *self, uint16_t buffer_size);
+static void Pmch_RxUnused(void *self, Mns_Lld_RxMsg_t *msg_ptr);
+static void Pmch_RxReceive(void *self, Mns_Lld_RxMsg_t *msg_ptr);
+static void Pmch_TxRelease(void *self, Mns_Lld_TxMsg_t *msg_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief  Constructor of class CPmChannel
+ *  \param  self        The instance
+ *  \param  init_ptr    Reference to initialization data structure
+ *  \param  inst_ptr    TKU: MultiInstance param
+ */
+void Pmch_Ctor(CPmChannel *self, const Pmch_InitData_t *init_ptr, void *inst_ptr)
+{
+    uint16_t cnt;
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    self->init_data    = *init_ptr;
+    self->inst_ptr     = inst_ptr;
+    self->lld_active   = false;
+ 
+    self->mns_iface.rx_allocate_fptr       = &Pmch_RxAllocate;
+    self->mns_iface.rx_receive_fptr        = &Pmch_RxReceive;
+    self->mns_iface.rx_free_unused_fptr    = &Pmch_RxUnused;
+    self->mns_iface.tx_release_fptr        = &Pmch_TxRelease;
+
+    Pool_Ctor(&self->rx_msgs_pool, self->rx_msgs,                   /* initialize Rx message pool */
+              PMCH_POOL_SIZE_RX, self->init_data.mns_inst_id);
+    for (cnt = 0U; cnt < PMCH_POOL_SIZE_RX; cnt++)                  /* and assign LLD Rx handles  */
+    {
+        Msg_SetLldHandle(&self->rx_msgs[cnt], &self->lld_rx_msgs[cnt]);
+        self->lld_rx_msgs[cnt].msg_ptr = &self->rx_msgs[cnt];
+    }
+}
+
+/*! \brief      Registers an Rx callback function dedicated to one FIFO
+ *  \param      self      The instance
+ *  \param      fifo_id   The FIFO identifier
+ *  \param      rx_fptr   The Rx callback function
+ *  \param      inst_ptr  Reference to the instance required to invoke the callback
+ */
+void Pmch_RegisterReceiver(CPmChannel *self, Pmp_FifoId_t fifo_id, Pmch_OnRxMsg_t rx_fptr, void *inst_ptr)
+{
+    TR_ASSERT(self->init_data.mns_inst_id, "[PMCH]", (((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_ICM)||((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_MCM)||((uint8_t)fifo_id == (uint8_t)PMP_FIFO_ID_RCM)));
+
+    self->receivers[fifo_id].rx_fptr = rx_fptr;
+    self->receivers[fifo_id].inst_ptr = inst_ptr;
+}
+
+/*! \brief      Un-initializes the LLD interface of the channel
+ *  \param      self    The instance
+ */
+void Pmch_Initialize(CPmChannel *self)
+{
+    if (self->lld_active == false)
+    {
+        self->lld_active   = true;
+        TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Initialize(): LLD_START()", 0U));
+        self->init_data.lld_iface.start_fptr(&self->mns_iface, self, self->inst_ptr);
+    }
+}
+
+/*! \brief      Un-initializes the LLD interface of the channel
+ *  \param      self    The instance
+ */
+extern void Pmch_Uninitialize(CPmChannel *self)
+{
+    TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Uninitialize(): Channel un-synchronization started", 0U));
+
+    if (self->lld_active != false)
+    {
+        self->lld_active = false;
+        TR_INFO((self->init_data.mns_inst_id, "[PMCH]", "Pmch_Uninitialize(): LLD_STOP()", 0U));
+        self->init_data.lld_iface.stop_fptr(self->inst_ptr);
+    }
+}
+
+/*! \brief      Wrapper for LLD transmit
+ *  \details    This function which shall be used by all internal classes. No class shall
+ *              invoke the LLD transmit function directly. Thus, it might be possible 
+ *              in future to handle transmission failures and retries.
+ *  \param      self    The instance
+ *  \param      msg_ptr Reference to the public LLD message structure
+ */
+void Pmch_Transmit(CPmChannel *self, Mns_Lld_TxMsg_t *msg_ptr)
+{
+    if (self->lld_active != false)
+    {
+        self->init_data.lld_iface.tx_transmit_fptr(msg_ptr, self->inst_ptr);
+    }
+    else
+    {
+        Pmch_TxRelease(self, msg_ptr);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* The exposed low-level driver interface                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Allocates an Rx message object 
+ *  \param  self        The instance
+ *  \param  buffer_size Size of the memory chunk in bytes which is needed to
+ *                      copy the Rx message.
+ *  \return Reference to an allocated Rx message object or \c NULL if no message object is available.
+ */
+static Mns_Lld_RxMsg_t* Pmch_RxAllocate(void *self, uint16_t buffer_size)
+{
+    CMessage *msg_ptr = NULL;
+    Mns_Lld_RxMsg_t *handle = NULL;
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    if (buffer_size <= MSG_SIZE_RSVD_BUFFER)
+    {
+        msg_ptr = Pool_GetMsg(&self_->rx_msgs_pool);
+
+        if (msg_ptr != NULL)
+        {
+            Msg_Cleanup(msg_ptr);
+            handle = &((Lld_IntRxMsg_t*)Msg_GetLldHandle(msg_ptr))->lld_msg;
+
+            TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (handle != NULL));
+ 
+            handle->data_size       = buffer_size;
+            handle->data_ptr        = Msg_GetHeader(msg_ptr);
+        }
+        else
+        {
+            self_->rx_trigger_available = true;
+            TR_INFO((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxAllocate(): Allocation failed, size=%u", 1U, buffer_size));
+        }
+    }
+    else
+    {
+        self_->rx_trigger_available = true;         
+        TR_FAILED_ASSERT(self_->init_data.mns_inst_id, "[PMCH]");
+    }
+
+    return handle;
+}
+
+/*! \brief  Frees an unused Rx message object
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the unused Rx message object
+ */
+static void Pmch_RxUnused(void *self, Mns_Lld_RxMsg_t *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+    CMessage *pb_handle = ((Lld_IntRxMsg_t*)(void*)msg_ptr)->msg_ptr;
+
+    TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (pb_handle != NULL));
+    Pmch_ReturnRxToPool(self_, pb_handle);
+}
+
+/*! \brief  Pass an Rx message to MOST NetServices 
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the Rx message object containing the received
+ *                      message.
+ */
+static void Pmch_RxReceive(void *self, Mns_Lld_RxMsg_t *msg_ptr)
+{
+    bool found = false;
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    if (msg_ptr->data_ptr != NULL)
+    {
+        if (msg_ptr->data_size >= PMP_PM_MIN_SIZE_HEADER)                     /* ignore incomplete messages */
+        {
+            uint8_t fifo_no = (uint8_t)Pmp_GetFifoId(msg_ptr->data_ptr);    /* get channel id (FIFO number) */
+
+            if ((fifo_no < PMP_MAX_NUM_FIFOS) && (self_->receivers[fifo_no].inst_ptr != NULL))
+            {
+                CMessage *handle = ((Lld_IntRxMsg_t*)(void*)msg_ptr)->msg_ptr;
+                                                                            /* forward message to the respective FIFO/channel */
+                self_->receivers[fifo_no].rx_fptr(self_->receivers[fifo_no].inst_ptr, handle); 
+                found = true;
+            }
+            else
+            {
+                TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): received message for unregistered FIFO no=%u", 1U, fifo_no));
+            }
+        }
+        else
+        {
+            TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): received incomplete message of size=%u", 1U, msg_ptr->data_size));
+        }
+    }
+    else
+    {
+        TR_ERROR((self_->init_data.mns_inst_id, "[PMCH]", "Pmch_RxReceive(): message data is not valid", 0U));
+    }
+
+    if (false == found)
+    {
+        Pmch_RxUnused(self_, msg_ptr);                                      /* Just return message to pool until PMC is implemented */
+    }
+}
+
+/*! \brief  Notifies that the LLD no longer needs to access the Tx message object
+ *  \param  self        The instance
+ *  \param  msg_ptr     Reference to the Tx message object which is no longer accessed
+ *                      by the low-level driver
+ */
+static void Pmch_TxRelease(void *self, Mns_Lld_TxMsg_t *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+    Lld_IntTxMsg_t *tx_ptr = (Lld_IntTxMsg_t*)(void*)msg_ptr;
+
+    if ((tx_ptr->owner_ptr == NULL) && (tx_ptr->msg_ptr == NULL))           /* tx_ptr is command */
+    {
+        Pmcmd_Release((CPmCommand*)(void*)tx_ptr);
+    }
+    else if (tx_ptr->owner_ptr != NULL)                                     /* release message to FIFO */
+    {
+        self_->init_data.tx_release_fptr(tx_ptr->owner_ptr, msg_ptr);
+    }
+    else
+    {
+        TR_FAILED_ASSERT(self_->init_data.mns_inst_id, "[PMCH]"); /* unknown FIFO - invalid message object */
+    }
+
+    TR_ASSERT(self_->init_data.mns_inst_id, "[PMCH]", (NULL == msg_ptr->custom_next_msg_ptr));  /* concatenation destroyed by the LLD */
+ 
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* FIFO Related Callback Functions                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Returns an unused Rx message object back to the pool
+ *  \param  self    The instance
+ *  \param  msg_ptr The unused Rx message object 
+ */
+void Pmch_ReturnRxToPool(void *self, CMessage *msg_ptr)
+{
+    CPmChannel *self_ = (CPmChannel*)self;
+
+    Pool_ReturnMsg(msg_ptr);
+
+    if (self_->rx_trigger_available == true)
+    {
+        self_->rx_trigger_available = false;
+
+        if (self_->init_data.lld_iface.rx_available_fptr != NULL)
+        {
+            self_->init_data.lld_iface.rx_available_fptr(self_->inst_ptr);
+        }
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmchannel.h b/mnsl/mns_pmchannel.h
new file mode 100644
index 0000000..8b069ad
--- /dev/null
+++ b/mnsl/mns_pmchannel.h
@@ -0,0 +1,179 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Port Message Channel
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_PMC
+ * @{
+ */
+
+#ifndef MNS_PMCHANNEL_H
+#define MNS_PMCHANNEL_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_lld_pb.h"
+#include "mns_lldpool.h"
+#include "mns_pool.h"
+#include "mns_base.h"
+#include "mns_message.h"
+#include "mns_pmp.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+#define PMCH_POOL_SIZE_RX_MIN       10U  /*!< \brief Minimal size of Rx pool which is shared by all FIFOs */
+#define PMCH_POOL_SIZE_RX_OPT       35U  /*!< \brief Optimal size of Rx pool which is shared by all FIFOs */
+
+#define PMCH_MCM_CREDITS_OPT        21U  /*!< \brief Optimal number of credits configured for MCM FIFO */
+#define PMCH_MCM_THRESHOLD_OPT      8U   /*!< \brief Optimal threshold configured for MCM FIFO */
+
+#define PMCH_FIFO_CREDITS_OPT       5U   /*!< \brief Optimal number of credits configured for conventional FIFOs */
+#define PMCH_FIFO_THRESHOLD_OPT     4U   /*!< \brief Optimal threshold configured for conventional FIFO */
+
+#define PMCH_FIFO_CREDITS_MIN       3U   /*!< \brief Minimal number of credits configured for conventional FIFOs */
+#define PMCH_FIFO_THRESHOLD_MIN     2U   /*!< \brief Minimal threshold configured for conventional FIFO */
+
+/* required rules */
+#if defined(MNS_FOOTPRINT_TINY) && defined(MNSL_CHANNEL_POOL_SIZE_RX)
+# error Forbidden combination of macros MNS_FOOTPRINT_TINY and MNSL_CHANNEL_POOL_SIZE_RX
+#endif
+
+#ifdef MNSL_CHANNEL_POOL_SIZE_RX
+# if (MNSL_CHANNEL_POOL_SIZE_RX < PMCH_POOL_SIZE_RX_MIN)
+#   error MNSL_CHANNEL_POOL_SIZE_RX must be at least 10
+# endif
+#endif
+
+/*! \def     MNSL_CHANNEL_POOL_SIZE_RX
+ *  \brief   MNSL configuration that defines the number of pre-allocated Rx messages which are shared by all FIFOs.
+ *           Valid values: 35...65535. Default value: 35.
+ *
+ *  \def     PMCH_POOL_SIZE_RX
+ *  \brief   Defines the number of pre-allocated Rx messages which are shared by all FIFOs.
+ */
+#ifdef MNS_FOOTPRINT_TINY
+# define PMCH_POOL_SIZE_RX          (PMCH_POOL_SIZE_RX_MIN)
+# define PMCH_MCM_CREDITS           (PMCH_FIFO_CREDITS_MIN)
+# define PMCH_FIFO_CREDITS          (PMCH_FIFO_CREDITS_MIN)
+# define PMCH_MCM_THRESHOLD         (PMCH_FIFO_THRESHOLD_MIN)
+# define PMCH_FIFO_THRESHOLD        (PMCH_FIFO_THRESHOLD_MIN)
+# define MNSL_CHANNEL_POOL_SIZE_RX  (PMCH_POOL_SIZE_RX_MIN)
+#elif defined MNSL_CHANNEL_POOL_SIZE_RX
+# define PMCH_POOL_SIZE_RX          ((uint16_t)MNSL_CHANNEL_POOL_SIZE_RX)
+# define PMCH_MCM_CREDITS           (PMCH_FIFO_CREDITS_MIN)
+# define PMCH_FIFO_CREDITS          (PMCH_FIFO_CREDITS_MIN)
+# define PMCH_MCM_THRESHOLD         (PMCH_FIFO_THRESHOLD_MIN)
+# define PMCH_FIFO_THRESHOLD        (PMCH_FIFO_THRESHOLD_MIN)
+#else
+# define PMCH_POOL_SIZE_RX          (PMCH_POOL_SIZE_RX_OPT)
+# define PMCH_MCM_CREDITS           (PMCH_MCM_CREDITS_OPT)
+# define PMCH_FIFO_CREDITS          (PMCH_FIFO_CREDITS_OPT)
+# define PMCH_MCM_THRESHOLD         (PMCH_MCM_THRESHOLD_OPT)
+# define PMCH_FIFO_THRESHOLD        (PMCH_FIFO_THRESHOLD_OPT)
+# define MNSL_CHANNEL_POOL_SIZE_RX  (PMCH_POOL_SIZE_RX_OPT)
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+typedef void (*Pmch_OnRxMsg_t)(void *fifo_ptr, CMessage *msg_ptr);
+typedef void (*Pmch_OnTxRelease_t)(void *fifo_ptr, Mns_Lld_TxMsg_t *handle_ptr);
+
+/*! \brief  Initialization structure of the Base Module. */
+typedef struct Pmch_InitData_
+{
+    uint8_t  mns_inst_id;                       /*!< \brief Initialization data of the Trace Module */
+    Mns_Lld_Callbacks_t lld_iface;              /*!< \brief LLD callback functions */
+    Pmch_OnTxRelease_t tx_release_fptr;         /*!< \brief Callback which releases a FIFO dedicated LLD buffer */
+
+} Pmch_InitData_t;
+
+/*! \brief  Combination of callback and instance for a receiving FIFO */
+typedef struct Pmch_Receiver_
+{
+    Pmch_OnRxMsg_t rx_fptr;                     /*!< \brief Reference to an Rx callback function */
+    void *inst_ptr;                             /*!< \brief Reference to the instance which shall be 
+                                                 *          passed to the callback function */
+} Pmch_Receiver_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class attributes                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Structure of a PMS object */
+typedef struct CPmChannel_
+{ 
+    Pmch_InitData_t init_data;                      /*!< \brief Copy of initialization data */
+ 
+    Lld_IntRxMsg_t  lld_rx_msgs[PMCH_POOL_SIZE_RX]; /*!< \brief Pre-allocated LLD Rx message objects */
+    CMessage        rx_msgs[PMCH_POOL_SIZE_RX];     /*!< \brief Pre-allocated Rx message objects */
+    CPool           rx_msgs_pool;                   /*!< \brief Pre-allocated Rx message pool */
+    bool            rx_trigger_available;           /*!< \brief Triggers LLD callback function if a buffer
+                                                     *          is available again.
+                                                     */
+    bool            lld_active;                     /*!< \brief Determines whether the LLD is running */
+    Mns_Lld_Api_t   mns_iface;                      /*!< \brief PMS function pointers */
+
+    Pmch_Receiver_t receivers[PMP_MAX_NUM_FIFOS];   /*!< \brief Registered FIFOs for Rx */
+    
+    void           *inst_ptr;                       /*< TKU: tag for LLD */
+
+} CPmChannel;
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class methods                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/* component creation */
+extern void Pmch_Ctor(CPmChannel *self, const Pmch_InitData_t *init_ptr, void *inst_ptr);
+extern void Pmch_Initialize(CPmChannel *self);
+extern void Pmch_Uninitialize(CPmChannel *self);
+extern void Pmch_RegisterReceiver(CPmChannel *self, Pmp_FifoId_t fifo_id, Pmch_OnRxMsg_t rx_fptr, void *inst_ptr);
+extern void Pmch_Transmit(CPmChannel *self, Mns_Lld_TxMsg_t *msg_ptr);
+extern void Pmch_ReturnRxToPool(void *self, CMessage *msg_ptr);
+
+#ifdef __cplusplus
+}                                               /* extern "C" */
+#endif
+
+#endif                                          /* MNS_PMCHANNEL_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmcmd.c b/mnsl/mns_pmcmd.c
new file mode 100644
index 0000000..21d8913
--- /dev/null
+++ b/mnsl/mns_pmcmd.c
@@ -0,0 +1,157 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 class CPmCommand
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PM_CMD
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmcmd.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of CPmCommand class 
+ *  \param  self    The instance
+ *  \param  fifo    The dedicated FIFO
+ *  \param  type    The port message type
+ */
+void Pmcmd_Ctor(CPmCommand *self, Pmp_FifoId_t fifo, Pmp_MsgType_t type)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));           /* setup attributes */
+    self->memory.data_ptr = &self->data[0];
+    self->tx_obj.lld_msg.memory_ptr = &self->memory;
+    self->tx_obj.msg_ptr = NULL;                    /* label message as command by setting */
+    self->tx_obj.owner_ptr = NULL;                  /* msg_ptr and owner_ptr to NULL */
+    self->trigger = false;
+
+    Pmp_SetPmhl(self->data, 3U);                    /* PMHL is always "3" for control/status messages */
+    Pmp_SetFph(self->data, fifo, type);
+}
+
+/*! \brief  Retrieves reference to the LLD Tx message object required to call Pmch_Transmit()
+ *  \param  self    The instance
+ *  \return Returns a reference to the LLD Tx message object 
+ */
+Mns_Lld_TxMsg_t* Pmcmd_GetLldTxObject(CPmCommand *self)
+{
+    return (Mns_Lld_TxMsg_t*)(void*)self;
+}
+
+/*! \brief  Sets the content of a command/status message
+ *  \param  self          The instance
+ *  \param  sid           The sequence id
+ *  \param  ext_type      The ExtType type
+ *  \param  ext_code      The ExtType code
+ *  \param  add_data_ptr  Additional payload data
+ *  \param  add_data_sz   The size of additional payload data, valid values: 0..4
+ */
+void Pmcmd_SetContent(CPmCommand *self, uint8_t sid, uint8_t ext_type, uint8_t ext_code, uint8_t add_data_ptr[], uint8_t add_data_sz)
+{
+    if ((add_data_ptr != NULL) && (add_data_sz != 0U))
+    {
+        MISC_MEM_CPY(&self->data[6U], add_data_ptr, (size_t)add_data_sz);
+    }
+
+    self->memory.data_size = 6U + (uint16_t)add_data_sz;
+    self->memory.total_size = 6U + (uint16_t)add_data_sz;
+
+    Pmp_SetPml(self->data, 4U + add_data_sz);
+    Pmp_SetSid(self->data, sid);
+    Pmp_SetExtType(self->data, ext_type, ext_code);
+}
+
+/*! \brief   Updates the content of a command/status message
+ *  \details The length and the content of the payload is not modified.
+ *           It is important to call Pmcmd_SetContent() before.
+ *  \param   self        The instance
+ *  \param   sid         The sequence id
+ *  \param   ext_type    The ExtType type
+ *  \param   ext_code    The ExtType code
+ */
+void Pmcmd_UpdateContent(CPmCommand *self, uint8_t sid, uint8_t ext_type, uint8_t ext_code)
+{
+    Pmp_SetSid(self->data, sid);
+    Pmp_SetExtType(self->data, ext_type, ext_code);
+}
+
+/*! \brief  Reserves the command object if it is available
+ *  \param  self    The instance
+ *  \return \c true if the command object is available, \c false
+ *          if the command object is (still) in usage
+ */
+bool Pmcmd_Reserve(CPmCommand *self)
+{
+    bool succ = false;
+
+    if (self->reserved == false)
+    {
+        self->reserved = true;
+        succ = true;
+    }
+    return succ;
+}
+
+/*! \brief  Releases the command object after usage
+ *  \param  self    The instance
+ */
+void Pmcmd_Release(CPmCommand *self)
+{
+    self->reserved = false;
+}
+
+/*! \brief  Sets or resets the trigger attribute
+ *  \param  self    The instance
+ *  \param  trigger The trigger value
+ */
+void Pmcmd_SetTrigger(CPmCommand *self, bool trigger)
+{
+    self->trigger = trigger;
+}
+
+/*! \brief  Returns the trigger value
+ *  \param  self    The instance
+ *  \return Returns \c true if the trigger attribute is set, otherwise \c false.
+ */
+bool Pmcmd_IsTriggered(CPmCommand *self)
+{
+    return self->trigger;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmcmd.h b/mnsl/mns_pmcmd.h
new file mode 100644
index 0000000..5905beb
--- /dev/null
+++ b/mnsl/mns_pmcmd.h
@@ -0,0 +1,92 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of class CPmCommand
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PM_CMD
+ * @{
+ */
+
+#ifndef MNS_PMCMD_H
+#define MNS_PMCMD_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+#include "mns_memory.h"
+#include "mns_lldpool.h"
+#include "mns_pmp.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class CPmCommand                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Class CPmCommand  */
+typedef struct CPmCommand_
+{
+    Lld_IntTxMsg_t      tx_obj;     /*!< \brief  Required LLD Tx structure, must be first attribute */
+    uint8_t             data[10];   /*!< \brief  Reserved memory space */
+    Mns_Mem_Buffer_t    memory;     /*!< \brief  Public memory structure */
+    bool                reserved;   /*!< \brief  \c true if the command is in use, otherwise \c false. */
+    bool                trigger;    /*!< \brief  \c true if the command is triggered, otherwise \c false. */
+
+} CPmCommand;
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Methods                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+extern void Pmcmd_Ctor(CPmCommand *self, Pmp_FifoId_t fifo, Pmp_MsgType_t type);
+extern Mns_Lld_TxMsg_t* Pmcmd_GetLldTxObject(CPmCommand *self);
+extern bool Pmcmd_Reserve(CPmCommand *self);
+extern void Pmcmd_Release(CPmCommand *self);
+extern void Pmcmd_SetContent(CPmCommand *self, uint8_t sid, uint8_t ext_type, 
+                             uint8_t ext_code, uint8_t add_data_ptr[], uint8_t add_data_sz);
+extern void Pmcmd_UpdateContent(CPmCommand *self, uint8_t sid, uint8_t ext_type, uint8_t ext_code);
+extern void Pmcmd_SetTrigger(CPmCommand *self, bool trigger);
+extern bool Pmcmd_IsTriggered(CPmCommand *self);
+
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_PMCMD_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmfifo.c b/mnsl/mns_pmfifo.c
new file mode 100644
index 0000000..a1cafbf
--- /dev/null
+++ b/mnsl/mns_pmfifo.c
@@ -0,0 +1,1368 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Port Message FIFO
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMF
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmfifo.h"
+#include "mns_pmp.h"
+#include "mns_pmcmd.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal macros                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------------------------------*/
+/* Internal Constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+static const uint8_t     FIFO_SRV_PRIO              = 252U; /* parasoft-suppress  MISRA2004-8_7 "configuration property" */
+static const Srv_Event_t FIFO_SE_RX_SERVICE         = 1U;   /*!< \brief Event which triggers the Rx service */
+static const Srv_Event_t FIFO_SE_TX_SERVICE         = 2U;   /*!< \brief Event which triggers the Rx service */
+static const Srv_Event_t FIFO_SE_TX_APPLY_STATUS    = 4U;   /*!< \brief Event which triggers to apply the current INIC status */
+static const Srv_Event_t FIFO_SE_ALL                = 7U;   /* parasoft-suppress  MISRA2004-8_7 "configuration property" */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Fifo_InitCounters(CPmFifo *self, uint8_t tx_sid_complete, uint8_t tx_credits);
+static void Fifo_Service(void *self);
+
+static void Fifo_RxService(CPmFifo *self);
+static void Fifo_RxCheckStatusTrigger(CPmFifo *self);
+static void Fifo_RxGetCredit(CPmFifo *self);
+static void Fifo_RxReleaseCredit(CPmFifo *self);
+static bool Fifo_RxProcessData(CPmFifo *self, CMessage *msg_ptr);
+static void Fifo_RxProcessStatus(CPmFifo *self, CMessage *msg_ptr);
+static void Fifo_RxProcessCommand(CPmFifo *self, CMessage *msg_ptr);
+static void Fifo_RxProcessSyncStatus(CPmFifo *self, uint8_t sid, uint8_t type, uint8_t code, uint8_t *header_ptr);
+static uint8_t Fifo_RxCheckFailureCode(CPmFifo *self, uint8_t failure_code);
+static void Fifo_OnRx(void *self, CMessage *msg_ptr);
+
+static void Fifo_TxService(CPmFifo *self);
+static void Fifo_TxProcessData(CPmFifo *self);
+static void Fifo_TxProcessStatus(CPmFifo *self);
+static void Fifo_TxProcessCommand(CPmFifo *self);
+
+static void Fifo_TxEnqueueBypassMsg(CPmFifo *self, CDlList *q_ptr, CMessage *msg_ptr);
+static bool Fifo_FindFirstRegularMsg(void *d_ptr, void *ud_ptr);
+
+static void Fifo_TxExecuteCancel(CPmFifo *self, uint8_t failure_sid, uint8_t failure_code);
+static void Fifo_TxExecuteCancelAll(CPmFifo *self, uint8_t failure_sid, uint8_t failure_code);
+static void Fifo_TxFinishedCancelAll(CPmFifo *self);
+static uint8_t Fifo_TxPendingGetFollowerId(CPmFifo *self);
+static void Fifo_TxCancelFollowers(CPmFifo *self, uint8_t follower_id, Mns_MsgTxStatus_t status);
+
+static bool Fifo_TxHasAccessPending(CPmFifo *self);
+static void Fifo_TxRestorePending(CPmFifo *self);
+
+static void Fifo_TxOnWatchdogTimer(void *self);
+static void Fifo_TxStartWatchdog(CPmFifo *self);
+
+static uint8_t Fifo_TxGetValidAcknowledges(CPmFifo *self, uint8_t sid);
+static bool Fifo_TxNotifyStatus(CPmFifo *self, uint8_t sid, Mns_MsgTxStatus_t status);
+static void Fifo_TxApplyCurrentStatus(CPmFifo *self);
+static void Fifo_TxUpdateCurrentStatus(CPmFifo *self, uint8_t sid, uint8_t type, uint8_t code);
+static bool Fifo_TxIsIncomingSidValid(CPmFifo *self, uint8_t sid);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of message FIFO
+ *  \param  self        The instance
+ *  \param  init_ptr    Reference to initialization data
+ *  \param  config_ptr  Reference to configuration
+ */
+void Fifo_Ctor(CPmFifo *self, const Fifo_InitData_t *init_ptr, const Fifo_Config_t *config_ptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    self->init          = *init_ptr;
+    self->config        = *config_ptr;
+
+    self->sync_state    = FIFO_S_UNSYNCED_INIT;                         /* initialize members */
+    Sub_Ctor(&self->sync_state_subject, self->init.base_ptr->mns_inst_id);
+
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Ctor(): state: %u", 1U, self->sync_state));
+
+    Srv_Ctor(&self->service, FIFO_SRV_PRIO, self, &Fifo_Service);       /* registration of service */
+    (void)Scd_AddService(&self->init.base_ptr->scd, &self->service);
+
+    T_Ctor(&self->wd.timer);                                            /* setup watchdog */
+    self->wd.timer_value = self->config.tx_wd_timer_value;
+    Pmcmd_Ctor(&self->wd.wd_cmd, self->config.fifo_id, PMP_MSG_TYPE_CMD);
+    Pmcmd_SetContent(&self->wd.wd_cmd, 0U, PMP_CMD_TYPE_REQ_STATUS, PMP_CMD_CODE_REQ_STATUS, NULL, 0U);
+
+    /* init Rx part */
+    Dl_Ctor(&self->rx.queue, self->init.base_ptr->mns_inst_id);
+    self->rx.encoder_ptr = self->init.rx_encoder_ptr;
+    self->rx.on_complete_fptr = self->init.rx_cb_fptr;
+    self->rx.on_complete_inst = self->init.rx_cb_inst;
+
+    self->rx.ack_threshold = self->config.rx_threshold;
+
+    if (self->config.rx_threshold > self->config.rx_credits)/* configuration error - use single acknowledge */
+    {
+        self->rx.ack_threshold = 1U;
+        TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");
+    }
+
+    self->rx.wait_processing = false;
+    Pmcmd_Ctor(&self->rx.status, self->config.fifo_id, PMP_MSG_TYPE_STATUS);
+    Pmcmd_SetContent(&self->rx.status, 0U, PMP_STATUS_TYPE_FLOW, PMP_STATUS_CODE_SUCCESS, NULL, 0U);
+
+    /* init Tx part */
+    Dl_Ctor(&self->tx.waiting_queue, self->init.base_ptr->mns_inst_id);
+    Dl_Ctor(&self->tx.pending_q, self->init.base_ptr->mns_inst_id);
+ 
+    Pmcmd_Ctor(&self->tx.cancel_cmd, self->config.fifo_id, PMP_MSG_TYPE_CMD);
+    Pmcmd_SetContent(&self->tx.cancel_cmd, 0U, PMP_CMD_TYPE_MSG_ACTION, PMP_CMD_CODE_ACTION_CANCEL, NULL, 0U);
+
+    Fifo_InitCounters(self, 0U, 0U);                        /* values are incremented on each sync attempt */
+    self->tx.encoder_ptr = init_ptr->tx_encoder_ptr;
+
+    /* FIFO synchronization command */
+    self->sync_cnt = 0xFFU;
+    self->sync_params[0] = config_ptr->rx_credits;
+    self->sync_params[1] = config_ptr->rx_busy_allowed; 
+    self->sync_params[2] = config_ptr->rx_ack_timeout;
+    self->sync_params[3] = config_ptr->tx_wd_timeout;
+    Pmcmd_Ctor(&self->tx.sync_cmd, self->config.fifo_id, PMP_MSG_TYPE_CMD);
+    Pmcmd_SetContent(&self->tx.sync_cmd, 0U, PMP_CMD_TYPE_SYNCHRONIZATION, PMP_CMD_CODE_SYNC, self->sync_params, 4U);
+
+    /* default PM header for Tx */
+    self->tx.pm_header.pml = 6U;
+    self->tx.pm_header.pmhl  = self->tx.encoder_ptr->pm_hdr_sz - 3U;
+    Pmh_SetFph(&self->tx.pm_header, self->config.fifo_id, PMP_MSG_TYPE_DATA);
+    self->tx.pm_header.sid = 0U;
+    self->tx.pm_header.ext_type = (uint8_t)self->tx.encoder_ptr->content_type;
+
+    Lldp_Ctor(&self->tx.lld_pool, self, self->init.base_ptr->mns_inst_id);
+
+    Pmch_RegisterReceiver(self->init.channel_ptr, self->config.fifo_id, &Fifo_OnRx, self);
+}
+
+/*! \brief Initializes flow control and related counters
+ *  \param  self            The instance
+ *  \param  tx_sid_complete Reference to initialization data
+ *  \param  tx_credits      Number of credits for Tx
+ */
+static void Fifo_InitCounters(CPmFifo *self, uint8_t tx_sid_complete, uint8_t tx_credits)
+{
+    self->rx.busy_num = 0U;
+    self->rx.expected_sid = tx_sid_complete + 1U;
+    self->rx.ack_last_ok_sid = tx_sid_complete;
+
+    self->tx.credits = tx_credits;
+    self->tx.sid_next_to_use = tx_sid_complete +1U;
+    self->tx.sid_last_completed = tx_sid_complete;
+
+    self->tx.failure_status = 0U;
+    self->tx.failure_sid = 0U;
+
+    self->tx.current_sid = tx_sid_complete;
+    self->tx.current_type = PMP_STATUS_TYPE_FLOW;
+    self->tx.current_code = (uint8_t)PMP_STATUS_CODE_SUCCESS;
+}
+
+/*! \brief          Adds an observer of synchronization state changes
+ *  \param self     The instance
+ *  \param obs_ptr  The observer. The notification result type is \ref Pmp_FifoId_t.
+ */
+void Fifo_AddStateObserver(CPmFifo *self, CObserver *obs_ptr)
+{
+    (void)Sub_AddObserver(&self->sync_state_subject, obs_ptr);
+}
+
+/*! \brief          Removes an observer of synchronization state changes
+ *  \param self     The instance
+ *  \param obs_ptr  The observer.
+ */
+void Fifo_RemoveStateObserver(CPmFifo *self, CObserver *obs_ptr)
+{
+    (void)Sub_RemoveObserver(&self->sync_state_subject, obs_ptr);
+}
+
+/*! \brief  Stops execution of a FIFO and notifies sync lost if necessary
+ *  \param  self        The instance
+ *  \param  new_state   The new synchronization state
+ *  \param  allow_notification Set to \c false in order to avoid recursion
+ */
+void Fifo_Stop(CPmFifo *self, Fifo_SyncState_t new_state, bool allow_notification)
+{
+    bool notify = false; 
+
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Stop(): FIFO: %u, state: %u, new_state: %u", 3U, self->config.fifo_id, self->sync_state, new_state));
+
+    if (self->sync_state != new_state)
+    {
+        notify = true;
+    }
+
+    self->sync_state = new_state;
+    self->tx.credits = 0U;
+
+    if (self->wd.timer_value != 0U)
+    {
+        Tm_ClearTimer(&self->init.base_ptr->tm, &self->wd.timer);
+    }
+
+    if ((notify != false) && (allow_notification != false))
+    {
+        Sub_Notify(&self->sync_state_subject, &self->config.fifo_id);
+    }
+}
+
+/*! \brief   Releases all external references
+ *  \details It is important to call Fifo_Stop() prior to this functions. The low-level driver
+ *           must be stopped as well to avoid concurrent access to message objects.
+ *  \param   self   The instance
+ */
+void Fifo_Cleanup(CPmFifo *self)
+{
+    CMessage *msg_ptr = NULL;
+    CDlNode *node_ptr = NULL;
+
+    TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (self->sync_state == FIFO_S_UNSYNCED_INIT));
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Cleanup(): FIFO: %u", 1U, self->config.fifo_id));
+
+    /* cleanup pending queue */
+    for (node_ptr = Dl_PopHead(&self->tx.pending_q); node_ptr != NULL; node_ptr = Dl_PopHead(&self->tx.pending_q))
+    {
+        msg_ptr = (CMessage*)Dln_GetData(node_ptr);
+
+        Msg_NotifyTxStatus(msg_ptr, MNS_MSG_STAT_ERROR_SYNC);
+        Lldp_ReturnTxToPool(&self->tx.lld_pool, (Lld_IntTxMsg_t*)Msg_GetLldHandle(msg_ptr));
+        Msg_SetLldHandle(msg_ptr, NULL);                    /* remove link to LLD message object */
+    }
+
+    /* cleanup waiting queue */
+    for (node_ptr = Dl_PopHead(&self->tx.waiting_queue); node_ptr != NULL; node_ptr = Dl_PopHead(&self->tx.waiting_queue))
+    {
+        msg_ptr = (CMessage*)Dln_GetData(node_ptr);
+
+        Msg_NotifyTxStatus(msg_ptr, MNS_MSG_STAT_ERROR_SYNC);
+    }
+
+    /* cleanup Rx queue */
+    for (node_ptr = Dl_PopHead(&self->rx.queue); node_ptr != NULL; node_ptr = Dl_PopHead(&self->rx.queue))
+    {
+        msg_ptr = (CMessage*)Dln_GetData(node_ptr);
+ 
+        Pmch_ReturnRxToPool(self->init.channel_ptr, msg_ptr);
+    }
+
+    Srv_ClearEvent(&self->service, FIFO_SE_ALL);
+}
+
+
+/*! \brief   Service function of FIFO
+ *  \details The processing order of Rx followed by Tx is important for Fifo_RxProcessCommand()
+ *  \param   self   The instance
+ */
+static void Fifo_Service(void *self)
+{
+    CPmFifo *self_ = (CPmFifo*)self;
+    Srv_Event_t event_mask;
+
+    Srv_GetEvent(&self_->service, &event_mask);
+
+    if(FIFO_SE_RX_SERVICE == (event_mask & FIFO_SE_RX_SERVICE))     /* Is event pending? */
+    {
+        Srv_ClearEvent(&self_->service, FIFO_SE_RX_SERVICE);
+        Fifo_RxService(self_);
+    }
+ 
+    if(FIFO_SE_TX_APPLY_STATUS == (event_mask & FIFO_SE_TX_APPLY_STATUS))
+    {
+        Srv_ClearEvent(&self_->service, FIFO_SE_TX_APPLY_STATUS);
+        Fifo_TxApplyCurrentStatus(self_);
+    }
+
+    if(FIFO_SE_TX_SERVICE == (event_mask & FIFO_SE_TX_SERVICE))     /* Is event pending? */
+    {
+        Srv_ClearEvent(&self_->service, FIFO_SE_TX_SERVICE);
+        Fifo_TxService(self_);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tx Implementation                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Enqueues a message for transmission
+ *  \param   self    The instance
+ *  \param   msg_ptr The Tx message object
+ *  \param   bypass  Use \c true if the message shall bypass all other messages
+ *                   in the FIFO. Otherwise \c false.
+ */
+void Fifo_Tx(CPmFifo *self, CMessage *msg_ptr, bool bypass)
+{
+    uint8_t *msg_hdr_ptr = NULL;
+
+    TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (msg_ptr != NULL));
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Tx(): FIFO: %u, msg_ptr: 0x%p, FuncId: 0x%X, queued Tx message", 3U, self->config.fifo_id, msg_ptr, msg_ptr->pb_msg.id.function_id));
+
+    Msg_PullHeader(msg_ptr, self->tx.encoder_ptr->msg_hdr_sz);
+    msg_hdr_ptr = Msg_GetHeader(msg_ptr);
+    self->tx.encoder_ptr->encode_fptr(Msg_GetMostTel(msg_ptr), msg_hdr_ptr);
+
+    if (bypass == false)
+    {
+        Dl_InsertTail(&self->tx.waiting_queue, Msg_GetNode(msg_ptr)); /* enqueue message for asynchronous transmission */
+    }
+    else
+    {
+        Fifo_TxEnqueueBypassMsg(self, &self->tx.waiting_queue, msg_ptr);    /* queue before first non-bypass message */
+    }
+
+    Srv_SetEvent(&self->service, FIFO_SE_TX_SERVICE);
+}
+
+/*! \brief   Enqueues a bypass message between the last bypass and the first regular message in a queue
+ *  \param   self    The instance
+ *  \param   q_ptr   The message queue
+ *  \param   msg_ptr The Tx message object
+ */
+static void Fifo_TxEnqueueBypassMsg(CPmFifo *self, CDlList *q_ptr, CMessage *msg_ptr)
+{
+    CDlNode *node_ptr = Dl_Foreach(q_ptr, &Fifo_FindFirstRegularMsg, NULL); /* find first "non-bypass" message */
+    Msg_SetTxBypass(msg_ptr, true);                                         /* mark new message as bypass message */
+
+    if (node_ptr == NULL)                                                   /* no message or only bypass messages found */
+    {                               
+        Dl_InsertTail(&self->tx.waiting_queue, Msg_GetNode(msg_ptr));       /* enqueue message to tail */   
+    }
+    else                                                                    /* first "non-bypass" message is found */
+    {                                                                       /* insert the bypass message before the first regular message found */
+        Dl_InsertBefore(&self->tx.waiting_queue, node_ptr, Msg_GetNode(msg_ptr));
+    }
+}
+
+/*! \brief   Required as "for-each" function to find the first "regular message"
+ *  \param   d_ptr   Points to a message object in the queue
+ *  \param   ud_ptr  Unused data reference, always \c NULL
+ *  \return  Returns \c true if a regular (non-bypass) message is found.
+ */
+static bool Fifo_FindFirstRegularMsg(void *d_ptr, void *ud_ptr)
+{
+    bool ret = true;
+    MISC_UNUSED(ud_ptr);
+
+    if (Msg_IsTxBypass((CMessage*)d_ptr))
+    {
+        ret = false;
+    }
+
+    return ret;
+}
+
+/*! \brief   Processing of data, status and command messages
+ *  \param   self    The instance
+ */
+static void Fifo_TxService(CPmFifo *self)
+{
+    Fifo_TxProcessCommand(self);
+    Fifo_TxProcessStatus(self);
+    Fifo_TxProcessData(self);
+}
+
+/*! \brief   Processing of status messages
+ *  \param   self    The instance
+ */
+static void Fifo_TxProcessStatus(CPmFifo *self)
+{
+    if (Pmcmd_IsTriggered(&self->rx.status) != false)
+    {
+        if (Pmcmd_Reserve(&self->rx.status) != false)
+        {
+            Pmcmd_SetTrigger(&self->rx.status, false);
+            self->rx.ack_last_ok_sid = (self->rx.expected_sid - self->rx.busy_num) - 1U;
+            self->rx.wait_processing = false;
+
+            if (self->rx.busy_num == 0U)                /* currently no processing of data messages active */
+            {                                           /* notify the latest with SUCCESS */
+                Pmcmd_UpdateContent(&self->rx.status, self->rx.expected_sid - 1U, PMP_STATUS_TYPE_FLOW, PMP_STATUS_CODE_SUCCESS);
+            }
+            else                                        /* message processing is active */
+            {                                           /* notify code busy according to remaining credits */
+                Pmcmd_UpdateContent(&self->rx.status, self->rx.expected_sid - self->rx.busy_num, PMP_STATUS_TYPE_FLOW, PMP_STATUS_CODE_BUSY);
+            }
+
+            Pmch_Transmit(self->init.channel_ptr, Pmcmd_GetLldTxObject(&self->rx.status));
+        }
+    }
+}
+
+/*! \brief   Processing of queued data messages
+ *  \param   self    The instance
+ */
+static void Fifo_TxProcessData(CPmFifo *self)
+{
+    /* process all queued messages as long as credits are available,
+     * process all queued messages if FIFO is not synced 
+     */
+    while ((self->tx.cancel_all_running == false) && (self->tx.credits > 0U))
+    {
+        CMessage *msg_ptr = NULL;
+        CDlNode *node_ptr = NULL;
+        uint8_t *msg_hdr_ptr = NULL;
+        Lld_IntTxMsg_t *lld_tx_ptr = NULL;
+
+        node_ptr = Dl_PopHead(&self->tx.waiting_queue);             /* get message node */
+        if (NULL == node_ptr)
+        {
+            msg_ptr = NULL;                                         /* stop processing - no further messages in queue */
+            break;
+        }
+
+        msg_ptr = (CMessage*)Dln_GetData(node_ptr);                 /* get message object */
+
+        if (self->sync_state != FIFO_S_SYNCED)
+        {
+            Msg_NotifyTxStatus(msg_ptr, MNS_MSG_STAT_ERROR_SYNC);     /* notify sync error while not synced */
+        }
+        else
+        {
+            lld_tx_ptr = Lldp_GetTxFromPool(&self->tx.lld_pool);
+            TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (msg_ptr != NULL));
+            TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (lld_tx_ptr != NULL));
+            TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxProcessData(): FIFO: %u, msg_ptr: 0x%p, FuncId: 0x%X, SID: 0x%02X, queued Tx message", 4U, self->config.fifo_id, msg_ptr, msg_ptr->pb_msg.id.function_id, self->tx.sid_next_to_use));
+
+            Msg_SetLldHandle(msg_ptr, lld_tx_ptr);                     /* link message objects */
+            lld_tx_ptr->msg_ptr = msg_ptr;
+
+            Msg_PullHeader(msg_ptr, self->tx.encoder_ptr->pm_hdr_sz);  /* get PM header pointer */
+            msg_hdr_ptr = Msg_GetHeader(msg_ptr);
+
+            {
+                uint8_t tel_length = Msg_GetMostTel(msg_ptr)->tel.tel_len;
+                self->tx.pm_header.pml = (Msg_GetHeaderSize(msg_ptr) + tel_length) - 2U;
+            }
+
+            self->tx.pm_header.sid = self->tx.sid_next_to_use;        /* assign SeqID */
+            self->tx.sid_next_to_use++;
+
+            Pmh_BuildHeader(&self->tx.pm_header, msg_hdr_ptr);        /* build PM header */
+            lld_tx_ptr->lld_msg.memory_ptr = Msg_GetMemTx(msg_ptr);
+ 
+            Msg_SetTxActive(msg_ptr, true);
+            Dl_InsertTail(&self->tx.pending_q, Msg_GetNode(msg_ptr));
+
+            Pmch_Transmit(self->init.channel_ptr, (Mns_Lld_TxMsg_t*)(void*)lld_tx_ptr);
+
+            self->tx.credits--;
+        }
+    }
+}
+
+/*! \brief   Processing of status messages
+ *  \param   self    The instance
+ */
+static void Fifo_TxProcessCommand(CPmFifo *self)
+{
+    if (Pmcmd_IsTriggered(&self->tx.sync_cmd) != false)
+    {
+        if (Pmcmd_Reserve(&self->tx.sync_cmd) != false)
+        {
+            Pmcmd_SetTrigger(&self->tx.sync_cmd, false);
+
+            if (self->sync_state == FIFO_S_SYNCING)
+            {
+                self->sync_cnt++;
+                Pmcmd_SetContent(&self->tx.sync_cmd, self->sync_cnt, PMP_CMD_TYPE_SYNCHRONIZATION, PMP_CMD_CODE_SYNC, self->sync_params, 4U);
+                Pmch_Transmit(self->init.channel_ptr, Pmcmd_GetLldTxObject(&self->tx.sync_cmd));
+            }
+            else if (self->sync_state == FIFO_S_UNSYNCING)
+            {
+                Pmcmd_SetContent(&self->tx.sync_cmd, 0U, PMP_CMD_TYPE_SYNCHRONIZATION, PMP_CMD_CODE_UNSYNC, NULL, 0U);
+                Pmch_Transmit(self->init.channel_ptr, Pmcmd_GetLldTxObject(&self->tx.sync_cmd));
+            }
+            else
+            {
+                Pmcmd_Release(&self->tx.sync_cmd);
+                TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");
+            }
+        }
+        else
+        {
+            TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");
+        }
+    }
+}
+
+/*! \brief      Releases a LLD Tx message object
+ *  \param      self        The instance
+ *  \param      handle_ptr  The unused LLD Tx message object 
+ *  \details    If Fifo_TxApplyStatus() is waiting for a message object 
+ *              being released 
+ */
+void Fifo_TxOnRelease(void *self, Mns_Lld_TxMsg_t *handle_ptr)
+{
+    CPmFifo *self_ = (CPmFifo*)self;
+    Lld_IntTxMsg_t *tx_ptr = (Lld_IntTxMsg_t*)(void*)handle_ptr;
+
+    if (tx_ptr->msg_ptr != NULL)
+    {
+        Msg_SetTxActive(tx_ptr->msg_ptr, false);
+    }
+    else
+    {
+        TR_FAILED_ASSERT(self_->init.base_ptr->mns_inst_id, "[FIFO]");
+    }
+
+    if (self_->tx.status_waiting_release != false)
+    {
+        self_->tx.status_waiting_release = false;
+        Srv_SetEvent(&self_->service, (FIFO_SE_TX_APPLY_STATUS | FIFO_SE_TX_SERVICE));
+    }
+}
+
+/*! \brief   Triggers a command CANCEL_ALL and stops further Tx processing
+ *  \details CANCEL_ALL shall be called only, if the front-most pending message 
+ *           has followers (is segmented, i.e. \c cancel_id > 0). Use command CANCEL
+ *           if the front-most message has no followers (\c cancel_id == NULL).
+ *  \param   self           The instance
+ *  \param   failure_sid    The failure sid
+ *  \param   failure_code   The failure code reported by the INIC
+ */
+static void Fifo_TxExecuteCancelAll(CPmFifo *self, uint8_t failure_sid, uint8_t failure_code)
+{
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxExecuteCancelAll(): FIFO: %u, SID: %u, Code: %u", 3U, self->config.fifo_id, failure_sid, failure_code));
+ 
+    if (Pmcmd_Reserve(&self->tx.cancel_cmd) != false)                   /* prepare cancel command */
+    {
+        Pmcmd_UpdateContent(&self->tx.cancel_cmd, self->tx.current_sid, 
+                            PMP_CMD_TYPE_MSG_ACTION, PMP_CMD_CODE_ACTION_CANCEL_ALL);
+        Pmch_Transmit(self->init.channel_ptr, Pmcmd_GetLldTxObject(&self->tx.cancel_cmd));
+    }
+    else
+    {
+        TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");   /* Unable to reserve cancel command */
+    }
+
+    self->tx.cancel_all_running = true;
+    self->tx.failure_sid = failure_sid;
+    self->tx.failure_status = failure_code;
+}
+
+/*! \brief   Shall be called if the command CANCEL_ALL was processed completely
+ *  \param   self           The instance
+ *  \details Since the CANCEL_ALL is used to cancel the front-most message and
+ *           all of its followers (same cancel_id)
+ 
+ for mid-level retries, the canceled messages
+ *           are moved from the processing_q to the waiting_q again. The MLR timer is
+ *           started. As soon as the timer elapses, Tx processing is continued again.
+ *           If the front-most message has a follower id, all pending messages are 
+ *           moved to the waiting queue and all messages with the same follower id 
+ *           are notified as failed.
+ */
+static void Fifo_TxFinishedCancelAll(CPmFifo *self)
+{
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxFinishedCancelAll(): FIFO: %u, FailureStatus: %u,", 2U, self->config.fifo_id, self->tx.failure_status));
+
+    if (self->tx.failure_status != 0U)                          /* avoid multiple execution of the same CANCELED status */
+    {                                                           /* and all of its followers */
+        uint8_t follower_id = Fifo_TxPendingGetFollowerId(self);
+        Fifo_TxRestorePending(self);                            /* move remaining messages to waiting_q */
+        Fifo_TxCancelFollowers(self, follower_id, (Mns_MsgTxStatus_t)self->tx.failure_status);
+                                                                /* notify front-most and message and all of its followers */
+        self->tx.cancel_all_running = false;                    /* continue with Tx processing */
+        self->tx.failure_sid = 0U;
+        self->tx.failure_status = 0U;
+        Srv_SetEvent(&self->service, FIFO_SE_TX_SERVICE);
+    }
+}
+
+/*! \brief   Triggers a command CANCEL while Tx processing continues
+ *  \param   self           The instance
+ *  \param   failure_sid    The failure sid
+ *  \param   failure_code   The failure code reported by the INIC
+ */
+static void Fifo_TxExecuteCancel(CPmFifo *self, uint8_t failure_sid, uint8_t failure_code)
+{
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxExecuteCancel(): FIFO: %u, SID: %u, Code: %u", 3U, self->config.fifo_id, failure_sid, failure_code));
+
+    if (Pmcmd_Reserve(&self->tx.cancel_cmd) != false)
+    {
+        Pmcmd_UpdateContent(&self->tx.cancel_cmd, self->tx.current_sid, 
+                            PMP_CMD_TYPE_MSG_ACTION, PMP_CMD_CODE_ACTION_CANCEL);
+        Pmch_Transmit(self->init.channel_ptr, Pmcmd_GetLldTxObject(&self->tx.cancel_cmd));
+    }
+    else
+    {
+        TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");   /* Unable to reserve cancel command */
+    }
+
+    self->tx.cancel_all_running = false;
+    self->tx.failure_sid = failure_sid;
+    self->tx.failure_status = failure_code;
+}
+
+/*! \brief   Checks if the LLD has released all messages in the pending_q
+ *  \param   self           The instance
+ *  \return  Returns \c true if all messages are released by the LLD, otherwise \c false.
+ */
+static bool Fifo_TxHasAccessPending(CPmFifo *self)
+{
+    bool ret = true;
+    CDlNode *node_ptr = Dl_PeekTail(&self->tx.pending_q);           /* if the tail is not active, then all */
+                                                                    /* pending message are not active */
+    if (node_ptr != NULL)
+    {
+        CMessage *msg_ptr = (CMessage*)Dln_GetData(node_ptr);
+
+        if (Msg_IsTxActive(msg_ptr) != false)
+        {
+            TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxHasAccessPending(): FIFO: %u, msg_ptr: 0x%p, still in use", 2U, self->config.fifo_id, msg_ptr));
+            self->tx.status_waiting_release = true;
+            ret = false;
+        }
+    }
+
+    return ret;
+}
+
+/*! \brief   Moves all pending messages to the waiting_q
+ *  \details All messages from pending_q will be moved to the waiting_g and 
+ *           all consumed credits are restored. The message objects are restored
+ *           to the queue in the same order as they have been forwarded to the LLD.
+ *           This method is typically called to restore the waiting_q in the correct
+ *           order before notifying a 
+ *  \param   self           The instance
+ */
+static void Fifo_TxRestorePending(CPmFifo *self)
+{
+    /* take tail from pending_q to the head of waiting_q */
+    CMessage *msg_ptr = NULL;
+    CDlNode *node_ptr = NULL;
+
+    /* cleanup pending queue */
+    for (node_ptr = Dl_PopTail(&self->tx.pending_q); node_ptr != NULL; node_ptr = Dl_PopTail(&self->tx.pending_q))
+    {
+        msg_ptr = (CMessage*)Dln_GetData(node_ptr);
+
+        TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxRestorePending(): FIFO: %u, msg_ptr: 0x%p", 2U, self->config.fifo_id, msg_ptr));
+        TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (Msg_IsTxActive(msg_ptr) == false));
+
+        self->tx.sid_last_completed++;
+        self->tx.credits++;
+        Lldp_ReturnTxToPool(&self->tx.lld_pool, (Lld_IntTxMsg_t*)Msg_GetLldHandle(msg_ptr));
+        Msg_SetLldHandle(msg_ptr, NULL);                            /* remove link to LLD message object */
+        Msg_PushHeader(msg_ptr, self->tx.encoder_ptr->pm_hdr_sz);   /* set index to position of message header */
+        Dl_InsertHead(&self->tx.waiting_queue, node_ptr);           /* enqueue message to waiting_q */
+    }
+}
+
+/*! \brief   Retrieves the follower id of the front-most pending message
+ *  \param   self           The instance
+ *  \return  Returns the follower id of the front-most pending message.
+ */
+static uint8_t Fifo_TxPendingGetFollowerId(CPmFifo *self)
+{
+    CDlNode *node_ptr;
+    CMessage *tx_ptr;
+    uint8_t ret = 0U;
+
+    node_ptr = Dl_PeekHead(&self->tx.pending_q);
+    TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (node_ptr != NULL));
+
+    if (node_ptr != NULL)
+    {
+        tx_ptr = (CMessage*)Dln_GetData(node_ptr);
+        ret = tx_ptr->pb_msg.opts.cancel_id;
+    }
+
+    return ret;
+}
+
+/*! \brief  Aborts the transmission of all messages in the waiting_q with a given follower id
+ *  \param  self          The instance
+ *  \param  follower_id   The follower id a message needs to have to be canceled
+ *  \param  status        The transmission status that shall be notified 
+ */
+static void Fifo_TxCancelFollowers(CPmFifo *self, uint8_t follower_id, Mns_MsgTxStatus_t status)
+{
+    CDlNode *node_ptr;
+    CDlList temp_queue;
+
+    Dl_Ctor(&temp_queue, self->init.base_ptr->mns_inst_id);
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxCancelFollowers(): FIFO: %u: FollowerId: %u", 2U, self->config.fifo_id, follower_id));
+
+    for (node_ptr = Dl_PopHead(&self->tx.waiting_queue); node_ptr != NULL; node_ptr = Dl_PopHead(&self->tx.waiting_queue))
+    {
+        CMessage *tx_ptr = (CMessage*)Dln_GetData(node_ptr);
+
+        TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (Msg_GetLldHandle(tx_ptr) == NULL));
+
+        if (tx_ptr->pb_msg.opts.cancel_id == follower_id)
+        {
+            Msg_NotifyTxStatus(tx_ptr, status);             /* notify failed transmission of message and all followers */
+        }
+        else
+        {
+            Dl_InsertTail(&temp_queue, node_ptr);           /* add to temporary queue and keep order of messages */
+        }
+    }
+
+    if (Dl_GetSize(&temp_queue) > 0U)                       /* restore temp_queue to waiting_q */
+    {
+        Dl_AppendList(&self->tx.waiting_queue, &temp_queue);/* temp_queue will be empty now */
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tx Message Processing                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Retrieves the number of (implicit) acknowledges that are related to one SID
+ *  \param  self    The instance
+ *  \param  sid     The sequence ID
+ *  \return The number of implicit acknowledges that are related to the SID
+ */
+static uint8_t Fifo_TxGetValidAcknowledges(CPmFifo *self, uint8_t sid)
+{
+    uint8_t diff_s = (uint8_t)(sid - self->tx.sid_last_completed);                          /* number of implicit acknowledged data */
+    uint8_t diff_b = (uint8_t)(self->tx.sid_next_to_use - self->tx.sid_last_completed);     /* number of "sent but un-acknowledged data" + 1 */
+
+    if (diff_b <= diff_s)                                                                   /* check valid acknowledges */
+    {
+        diff_s = 0U;
+    }
+
+    return diff_s;
+}
+
+
+/*! \brief  Checks id an incoming SID of a status message is valid.
+ *  \param  self The instance
+ *  \param  sid  The sequence ID
+ *  \return Returns \c true if the SID is valid, otherwise \c false.
+ */
+static bool Fifo_TxIsIncomingSidValid(CPmFifo *self, uint8_t sid)
+{
+    bool ret = false;
+    uint8_t diff_s = (uint8_t)(sid - self->tx.sid_last_completed);                          /* number of implicit acknowledged data */
+    uint8_t diff_b = (uint8_t)(self->tx.sid_next_to_use - self->tx.sid_last_completed);     /* number of "sent but un-acknowledged data" + 1 */
+    uint8_t diff_p = (uint8_t)(self->tx.current_sid - self->tx.sid_last_completed);         /* pending/known acknowledges */
+
+    if (diff_b > diff_s)                                                                    /* check if SID fits in valid range */
+    {
+        if (diff_s >= diff_p)                                                               /* avoid overwriting with smaller values */
+        {
+            ret = true;
+        }
+    }
+
+    return ret;
+}
+
+/*! \brief  Implicitly notifies transmission status to calling classes
+ *  \param  self    The instance
+ *  \param  sid     The sequence ID until the status shall be notified
+ *  \param  status  The status which is notified
+ *  \return Returns \c true if all desired messages had been notified, 
+ *          otherwise \c false.
+ */
+static bool Fifo_TxNotifyStatus(CPmFifo *self, uint8_t sid, Mns_MsgTxStatus_t status)
+{
+    bool ret = true;
+    uint8_t acks = Fifo_TxGetValidAcknowledges(self, sid);
+
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxNotifyStatus(): FIFO: %u, calculated_acks: %u", 2U, self->config.fifo_id, acks));
+
+    while (acks > 0U)
+    {
+        CDlNode *node_ptr = Dl_PopHead(&self->tx.pending_q);
+
+        if (node_ptr != NULL)
+        {
+            CMessage *tx_ptr = (CMessage*)node_ptr->data_ptr;
+
+            if (!Msg_IsTxActive(tx_ptr))
+            {
+                TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (tx_ptr != NULL));
+                TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxNotifyStatus(): FIFO: %u, FuncId: 0x%X, notified status: %u", 3U, self->config.fifo_id, tx_ptr->pb_msg.id.function_id, status));
+                Msg_NotifyTxStatus(tx_ptr, status);
+                Lldp_ReturnTxToPool(&self->tx.lld_pool, (Lld_IntTxMsg_t*)Msg_GetLldHandle(tx_ptr));
+                Msg_SetLldHandle(tx_ptr, NULL);                             /* remove link to LLD message object */
+
+                self->tx.credits++;                                         /* increment credits */
+                self->tx.sid_last_completed++;                              /* update last acknowledge SID */
+            }
+            else
+            {
+                TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxNotifyStatus(): FIFO: %u, LLD objects still occupied", 1U, self->config.fifo_id));
+                Dl_InsertHead(&self->tx.pending_q, node_ptr);
+                self->tx.status_waiting_release = true;
+                ret = false;
+                break;
+            }
+        }
+        else
+        {
+            TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");   /* not yet handled */
+                                                                            /* trigger sync again */
+        }
+
+        acks--;
+    }
+
+    return ret;
+}
+
+/*! \brief  Updates the current Tx status with the content of a received FIFO status
+ *  \param  self    The instance
+ *  \param  sid     The sequence id of the FIFO status
+ *  \param  type    The type of the FIFO status. Valid types are only:
+ *                  - PMP_STATUS_TYPE_FLOW
+ *                  - PMP_STATUS_TYPE_FAILURE
+ *  \param  code    The code of the FIFO status
+ */
+static void Fifo_TxUpdateCurrentStatus(CPmFifo *self, uint8_t sid, uint8_t type, uint8_t code)
+{
+    TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (type == (uint8_t)PMP_STATUS_TYPE_FAILURE) || (type == (uint8_t)PMP_STATUS_TYPE_FLOW));
+    if (Fifo_TxIsIncomingSidValid(self, sid))               /* is new or updating status */
+    {
+        self->tx.current_sid = sid;                         /* update current status */
+        self->tx.current_type = (Pmp_StatusType_t)type;
+        self->tx.current_code = code;
+    }
+    else
+    {
+        TR_ERROR((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxUpdateCurrentStatus(): FIFO: %u, sid: %u, type: %u, code: %u, INVALID SID", 4U, self->config.fifo_id, sid, type, code));
+    }
+}
+
+/*! \brief  Analyses the current Tx status, tries to notify statuses to the transmitter and triggers
+ *          retry/cancel actions.
+ *  \param  self    The instance
+ */
+static void Fifo_TxApplyCurrentStatus(CPmFifo *self)
+{
+    if ((self->tx.cancel_all_running == false) && (self->tx.failure_status != 0U))      /* Command(CANCEL) is pending */
+    {
+        if (Fifo_TxGetValidAcknowledges(self, self->tx.current_sid) > 1U)               /* ?>=1? "single cancel" is valid and implicit */
+        {
+            if (Fifo_TxNotifyStatus(self, self->tx.failure_sid, (Mns_MsgTxStatus_t)self->tx.failure_status))
+            {
+                self->tx.failure_status = 0U;                                           /* implicit canceled stops retries */
+                self->tx.failure_sid = 0U;
+            }
+        }
+    }
+
+    if ((self->tx.current_type == PMP_STATUS_TYPE_FAILURE) && (self->tx.status_waiting_release == false))
+    {
+        if (self->tx.cancel_all_running == false)
+        {
+            if (Fifo_TxNotifyStatus(self, self->tx.current_sid - 1U, MNS_MSG_STAT_OK) != false)
+            {
+                /* important: failed message now is front-most message in the tx.pending_q, */
+                /*            any implicit acknowledge was done before */
+                if (self->tx.failure_status == 0U)                  /* failure not yet handled - avoid multiple calls */
+                {
+                    if (Fifo_TxPendingGetFollowerId(self) == 0U)
+                    {
+                        Fifo_TxExecuteCancel(self, self->tx.current_sid, self->tx.current_code);    /* execute simple cancel */
+                    }
+                    else
+                    {
+                        Fifo_TxExecuteCancelAll(self, self->tx.current_sid, self->tx.current_code); /* execute cancel all */
+                        /* self->tx.cancel_all_running now is 'true' and Tx is stopped */
+                    }
+                }
+            }
+        }
+    }
+
+    if ((self->tx.current_type == PMP_STATUS_TYPE_FLOW) && (self->tx.status_waiting_release == false))
+    {
+        if ((uint8_t)PMP_STATUS_CODE_SUCCESS == self->tx.current_code)                           /* acknowledge pending messages */
+        {
+                                                                   /* no further retries possible */
+            (void)Fifo_TxNotifyStatus(self, self->tx.current_sid, MNS_MSG_STAT_OK);
+        }
+        else if ((uint8_t)PMP_STATUS_CODE_CANCELED == self->tx.current_code)
+        {
+            if (self->tx.cancel_all_running != false)
+            {
+                /* wait until the last SID is notified */
+                if (self->tx.current_sid == (uint8_t)(self->tx.sid_next_to_use - (uint8_t)1U))
+                {
+                    /* cancel done if none of pending messages is active */
+                    if (Fifo_TxHasAccessPending(self) != false)
+                    {
+                        Fifo_TxFinishedCancelAll(self);
+                    }
+                }
+            }
+            else if (Fifo_TxNotifyStatus(self, self->tx.current_sid, (Mns_MsgTxStatus_t)self->tx.failure_status))
+            {
+                self->tx.failure_status = 0U;
+                self->tx.failure_sid = 0U;
+            }
+        }
+        else 
+        {
+            if (Fifo_TxNotifyStatus(self, self->tx.current_sid - 1U, MNS_MSG_STAT_OK)) /* just implicitly acknowledge preceding message */
+            {
+                if ((uint8_t)PMP_STATUS_CODE_NACK == self->tx.current_code)
+                {
+                    Fifo_Stop(self, FIFO_S_UNSYNCED_INIT, true);
+                    TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");
+                }
+            }
+        }
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Rx Implementation                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Receives a message on the respective FIFO 
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the Rx message
+ */
+static void Fifo_OnRx(void *self, CMessage *msg_ptr)
+{
+    CPmFifo *self_ = (CPmFifo*)self;
+    Dl_InsertTail(&self_->rx.queue, Msg_GetNode(msg_ptr));      /* enqueue in rx_queue */
+    Srv_SetEvent(&self_->service, (FIFO_SE_RX_SERVICE | FIFO_SE_TX_APPLY_STATUS | FIFO_SE_TX_SERVICE));
+}
+
+/*! \brief  Processes the Rx queue completely and triggers possible Tx events
+ *  \param  self    The instance
+ */
+static void Fifo_RxService(CPmFifo *self)
+{
+    while (false == self->rx.wait_processing)                   /* process all Rx messages if possible */
+    {
+        CMessage *msg_ptr;
+        uint8_t *header_ptr;
+        Pmp_MsgType_t type;
+        bool ok;
+
+        bool free_msg = true;                                   /* default: free every status or command message */
+        CDlNode *node_ptr = Dl_PopHead(&self->rx.queue);
+
+        if (NULL == node_ptr)
+        {
+            msg_ptr = NULL;                                     /* stop processing - no further messages in queue */
+            break;
+        }
+ 
+        msg_ptr = (CMessage*)node_ptr->data_ptr;
+        header_ptr = Msg_GetHeader(msg_ptr);
+        type = Pmp_GetMsgType(header_ptr);
+        ok = Pmp_VerifyHeader(header_ptr, MSG_SIZE_RSVD_BUFFER);
+
+        if (ok != false)
+        {
+            switch (type)
+            {
+                case PMP_MSG_TYPE_CMD:
+                    Fifo_RxProcessCommand(self, msg_ptr);
+                    break;
+                case PMP_MSG_TYPE_STATUS:
+                    Fifo_RxProcessStatus(self, msg_ptr);
+                    break;
+                case PMP_MSG_TYPE_DATA:
+                    free_msg = Fifo_RxProcessData(self, msg_ptr);                   /* important: message can be freed */
+                    break;                                                          /*            synchronously */
+                default:
+                    TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");   /* unknown FIFO message type */
+                    break;
+            }
+        }
+        else
+        {
+            TR_FAILED_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]");           /* invalid message header */
+        }
+
+        if (free_msg != false)
+        {
+            Pmch_ReturnRxToPool(self->init.channel_ptr, msg_ptr);
+        }
+    }
+}
+
+/*! \brief   Evaluates the trigger condition to transmit a Rx status
+ *  \details Needs to be called before and after processing Rx data messages
+ *  \param   self    The instance
+ */
+static void Fifo_RxCheckStatusTrigger(CPmFifo *self)
+{
+    /* calculate the number of credits the INIC has consumed */
+    /* if less messages are processing, the freed can be acknowledged */
+    uint8_t consumed_inic_credits = (self->rx.expected_sid - self->rx.ack_last_ok_sid) - 1U;
+    uint8_t possible_acks = consumed_inic_credits - self->rx.busy_num;
+
+    if ((consumed_inic_credits >= self->rx.ack_threshold) && (possible_acks > 0U))
+    {
+        if (Pmcmd_IsTriggered(&self->rx.status) == false)
+        {
+            Pmcmd_SetTrigger(&self->rx.status, true);       /* INIC might run out of credits */ 
+            Srv_SetEvent(&self->service, FIFO_SE_TX_SERVICE);
+        }
+    }
+}
+
+/*! \brief  This function shall be called before processing a valid FIFO data message
+ *  \param  self    The instance
+ */
+static void Fifo_RxGetCredit(CPmFifo *self)
+{
+    self->rx.busy_num++;
+    Fifo_RxCheckStatusTrigger(self);
+}
+
+/*! \brief   This function shall be called after processing a valid FIFO data message
+ *  \details It is important to call this function after the message object is freed,
+ *           so that the flow control can be updated.
+ *  \param   self    The instance
+ */
+static void Fifo_RxReleaseCredit(CPmFifo *self)
+{
+    self->rx.busy_num--;
+    Fifo_RxCheckStatusTrigger(self);
+}
+
+/*! \brief   Releases a FIFO data message which was received and forwarded by the FIFO
+ *  \details The function returns the message to the channel's Rx message pool and
+ *           has to update the number of credits (processing handles). 
+ *           A FIFO data message is initially allocated from the channel's Rx message pool.
+ *           When processing the handle the determined FIFO need to calculate the amount of 
+ *           credits. When freeing the message the handle needs to be returned to the channel's
+ *           Rx pool again and the FIFO needs to refresh the status and credits calculation.
+ *           Therefore the message has to be freed to the respective FIFO again.
+ *  \param   self    The instance
+  * \param  msg_ptr The Rx data message
+ */
+void Fifo_RxReleaseMsg(CPmFifo *self, CMessage *msg_ptr)
+{
+    Pmch_ReturnRxToPool(self->init.channel_ptr, msg_ptr);
+    Fifo_RxReleaseCredit(self);
+}
+
+/*! \brief  Processes an Rx data message
+ *  \param  self    The instance
+ *  \param  msg_ptr The Rx data message
+ *  \return \c true if the message object is no longer needed.
+ *          Otherwise \c false.
+ */
+static bool Fifo_RxProcessData(CPmFifo *self, CMessage *msg_ptr)
+{
+    bool free_msg = true;
+    uint8_t content_header_sz = 0U;
+    uint8_t sid = 0U;
+    uint8_t *header_ptr = Msg_GetHeader(msg_ptr);
+    sid = Pmp_GetSid(header_ptr);
+
+    if (self->sync_state != FIFO_S_SYNCED)
+    {                                                       /* discard Rx messages while FIFO is not synced */
+        TR_ERROR((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_RxProcessData(): FIFO: %u, state: %u, discards Rx message with SID=0x%02X while not synced (warning)", 3U, self->config.fifo_id, self->sync_state, sid));
+    }
+    else if (sid == self->rx.expected_sid)                       /* check if SID is ok */
+    {
+        uint8_t pm_header_sz = Pmp_GetPmhl(header_ptr) + 3U;
+        TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (pm_header_sz == self->rx.encoder_ptr->pm_hdr_sz));
+
+        self->rx.expected_sid++;                            /* update SID */
+        content_header_sz = self->rx.encoder_ptr->msg_hdr_sz;
+ 
+        /* parasoft suppress item MISRA2004-17_4 reason "necessary offset usage" */
+        self->rx.encoder_ptr->decode_fptr(Msg_GetMostTel(msg_ptr), &(header_ptr[pm_header_sz]));
+        /* parasoft unsuppress item MISRA2004-17_4 reason "necessary offset usage" */
+
+        Msg_ReserveHeader(msg_ptr, content_header_sz + pm_header_sz);
+        Msg_PullHeader(msg_ptr, content_header_sz + pm_header_sz);
+
+        if (Msg_VerifyContent(msg_ptr))
+        {
+            if (self->rx.on_complete_fptr != NULL)
+            {
+                (void)Fifo_RxGetCredit(self);
+                free_msg =  false;                              /* callback is responsible to free the message  */
+                self->rx.on_complete_fptr(self->rx.on_complete_inst, msg_ptr);
+                                                                /* Fifo_RxReleaseCredit() is called when message is freed */
+            }
+        }
+    }
+    else
+    {
+        TR_ERROR((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_RxProcessData(): FIFO: %u, state: %u, discards Rx message with unexpected SID=0x%02X (warning)", 3U, self->config.fifo_id, self->sync_state, sid));
+    }
+
+    return free_msg;
+}
+
+/*! \brief  Processes an Rx status message
+ *  \param  self    The instance
+ *  \param  msg_ptr The Rx status message
+ */
+static void Fifo_RxProcessStatus(CPmFifo *self, CMessage *msg_ptr)
+{
+    CPmh pm_header;
+    uint8_t current_sid;
+    uint8_t current_type;
+    uint8_t current_code;
+    uint8_t *header_ptr = Msg_GetHeader(msg_ptr);
+
+    Pmh_DecodeHeader(&pm_header, header_ptr);
+    current_sid = pm_header.sid;
+    current_type = (uint8_t)Pmh_GetExtStatusType(&pm_header);
+    current_code = (uint8_t)Pmh_GetExtStatusCode(&pm_header);
+
+    self->wd.request_started = false;                                                   /* status finishes a wd request */
+
+    switch ((Pmp_StatusType_t)current_type)
+    {
+        case PMP_STATUS_TYPE_FAILURE:
+            Fifo_TxUpdateCurrentStatus(self, current_sid, current_type, Fifo_RxCheckFailureCode(self, current_code));  /* just update status type FAILURE */
+            break;
+        case PMP_STATUS_TYPE_FLOW:
+            Fifo_TxUpdateCurrentStatus(self, current_sid, current_type, current_code);  /* just update status type FLOW (codes: BUSY, NACK, SUCCESS, CANCELED) */
+            break;
+        case PMP_STATUS_TYPE_SYNCED:
+            Fifo_RxProcessSyncStatus(self, current_sid, current_type, current_code, header_ptr);
+            break;
+        case PMP_STATUS_TYPE_UNSYNCED_BSY:
+            TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_RxProcessStatus(): FIFO: %u, state: %u, received UNSYNCED_BSY", 2U, self->config.fifo_id, self->sync_state));
+            if (self->sync_state != FIFO_S_SYNCING)
+            {
+                Fifo_Stop(self, FIFO_S_UNSYNCED_BUSY, true);
+            }
+            break;
+        case PMP_STATUS_TYPE_UNSYNCED_RDY:
+            TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_RxProcessStatus(): FIFO: %u, state: %u, received UNSYNCED_RDY", 2U, self->config.fifo_id, self->sync_state));
+            if (self->sync_state == FIFO_S_SYNCING)
+            {
+                if (current_code == (uint8_t)PMP_UNSYNC_R_COMMAND)
+                {
+                    Fifo_Synchronize(self);                 /* retry synchronization */
+                }
+            }
+            else
+            {
+                Fifo_Stop(self, FIFO_S_UNSYNCED_READY, true);
+            }
+            break;
+        default:
+            /* ignore status */
+            TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_RxProcessStatus(): FIFO: %u, state: %u, received UNKNOWN TYPE: %u", 3U, self->config.fifo_id, self->sync_state, current_type));
+            break;
+    }
+}
+
+/*! \brief  Checks failure_code and sets invalid code to MNS_MSG_STAT_ERROR_UNKNOWN
+ *  \param  self         The instance
+ *  \param  failure_code The INIC failure code
+ *  \return Returns the checked failure code
+ */
+static uint8_t Fifo_RxCheckFailureCode(CPmFifo *self, uint8_t failure_code)
+{
+    uint8_t ret;
+    MISC_UNUSED(self);
+
+    switch (failure_code)
+    {
+        case (uint8_t)MNS_MSG_STAT_ERROR_CFG_NO_RCVR:
+        case (uint8_t)MNS_MSG_STAT_ERROR_BF:
+        case (uint8_t)MNS_MSG_STAT_ERROR_CRC:
+        case (uint8_t)MNS_MSG_STAT_ERROR_ID:
+        case (uint8_t)MNS_MSG_STAT_ERROR_ACK:
+        case (uint8_t)MNS_MSG_STAT_ERROR_TIMEOUT:
+        case (uint8_t)MNS_MSG_STAT_ERROR_FATAL_WT:
+        case (uint8_t)MNS_MSG_STAT_ERROR_FATAL_OA:
+        case (uint8_t)MNS_MSG_STAT_ERROR_NA_TRANS:
+        case (uint8_t)MNS_MSG_STAT_ERROR_NA_OFF:
+            ret = failure_code;
+            break;
+        default:
+            ret = (uint8_t)MNS_MSG_STAT_ERROR_UNKNOWN;
+            break;
+    }
+
+    return ret;
+}
+
+/*! \brief  Processes an Rx command message
+ *  \param  self    The instance
+ *  \param  msg_ptr The Rx command message
+ */
+static void Fifo_RxProcessCommand(CPmFifo *self, CMessage *msg_ptr)
+{
+    MISC_UNUSED(msg_ptr);
+                                                             /* be aware that PMHL might vary */
+    Pmcmd_SetTrigger(&self->rx.status, true);                /* just trigger latest Rx status now */
+}
+
+/*! \brief  Processes a status SYNCED from the INIC
+ *  \param  self        The instance
+ *  \param  sid         The sid of the sync status
+ *  \param  type        The type of the sync status
+ *  \param  code        The code of the sync status
+ *  \param  header_ptr  Pointer to the raw port message
+ *  \return The current synchronization state
+ */
+static void Fifo_RxProcessSyncStatus(CPmFifo *self, uint8_t sid, uint8_t type, uint8_t code, uint8_t *header_ptr)
+{
+    bool check = false;
+    uint8_t tx_credits = 0U;
+    
+    TR_ASSERT(self->init.base_ptr->mns_inst_id, "[FIFO]", (type==(uint8_t)PMP_STATUS_TYPE_SYNCED));
+    MISC_UNUSED(type);
+    MISC_UNUSED(code);
+
+    if (Pmp_GetDataSize(header_ptr) == 4U)
+    {
+        tx_credits = Pmp_GetData(header_ptr, 0U) & (uint8_t)PMP_CREDITS_MASK;
+
+        if ((tx_credits >= PMP_CREDITS_MIN) && 
+            (Pmp_GetData(header_ptr, 1U) == self->sync_params[1]) &&
+            (Pmp_GetData(header_ptr, 2U) == self->sync_params[2]) &&
+            (Pmp_GetData(header_ptr, 3U) == self->sync_params[3]) &&
+            (sid == (self->sync_cnt)))
+        {
+            check = true;                                               /* the sync status parameters are correct */
+        }
+    }
+
+    if ((check != false) && (self->sync_state == FIFO_S_SYNCING))
+    {
+        Fifo_InitCounters(self, sid, tx_credits);                       /* values are incremented on each sync attempt */
+        self->sync_state = FIFO_S_SYNCED;                               /* sync status shall have 4 bytes message body */
+        self->rx.wait_processing = false;
+        Fifo_TxStartWatchdog(self);
+        Sub_Notify(&self->sync_state_subject, &self->config.fifo_id);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Synchronization                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief  Synchronizes the FIFO
+ *  \param  self    The instance
+ */
+void Fifo_Synchronize(CPmFifo *self)
+{
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Synchronize(): FIFO: %u, state: %u", 2U, self->config.fifo_id, self->sync_state));
+    self->sync_state           = FIFO_S_SYNCING;
+    Pmcmd_SetTrigger(&self->tx.sync_cmd, true);
+    Srv_SetEvent(&self->service, FIFO_SE_TX_SERVICE);
+}
+
+/*! \brief  Un-synchronizes the FIFO
+ *  \param  self    The instance
+ */
+void Fifo_Unsynchronize(CPmFifo *self)
+{
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_Unsynchronize(): FIFO: %u, state: %u", 2U, self->config.fifo_id, self->sync_state));
+    if ( (self->sync_state == FIFO_S_SYNCING) || (self->sync_state == FIFO_S_SYNCED) )
+    {
+        self->sync_state           = FIFO_S_UNSYNCING;
+        Pmcmd_SetTrigger(&self->tx.sync_cmd, true);
+        Srv_SetEvent(&self->service, FIFO_SE_TX_SERVICE);
+    }
+}
+
+/*! \brief  Retrieves the current synchronization state
+ *  \param  self    The instance
+ *  \return The current synchronization state
+ */
+Fifo_SyncState_t Fifo_GetState(CPmFifo *self)
+{
+    return self->sync_state;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Watchdog                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief  Starts the watchdog handling 
+ *  \param  self    The instance
+ */
+static void Fifo_TxStartWatchdog(CPmFifo *self)
+{
+    self->wd.request_started = false;
+
+    TR_INFO((self->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxStartWatchdog(): fifo_id: %u, timeout: %u", 2U, self->config.fifo_id, self->wd.timer_value));
+
+    if (self->wd.timer_value != 0U)
+    {
+        Tm_SetTimer(&self->init.base_ptr->tm, &self->wd.timer, &Fifo_TxOnWatchdogTimer, 
+                    self, 
+                    self->wd.timer_value, 
+                    self->wd.timer_value
+                    );
+    }
+}
+
+/*! \brief   Callback function which is invoked if the watchdog timer expires 
+ *  \param   self    The instance
+ */
+static void Fifo_TxOnWatchdogTimer(void *self)
+{
+    CPmFifo *self_ = (CPmFifo*)self;
+
+    TR_INFO((self_->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxOnWatchdogTimer(): FIFO: %u, state: %u", 2U, self_->config.fifo_id, self_->sync_state));
+
+    if (self_->wd.request_started == false)
+    {
+        if (Pmcmd_Reserve(&self_->wd.wd_cmd) != false)
+        {
+            self_->wd.request_started = true;       /* indicate that a status is expected */
+            Pmcmd_UpdateContent(&self_->wd.wd_cmd, self_->tx.sid_next_to_use - 1U, PMP_CMD_TYPE_REQ_STATUS, PMP_CMD_CODE_REQ_STATUS);
+            Pmch_Transmit(self_->init.channel_ptr, Pmcmd_GetLldTxObject(&self_->wd.wd_cmd));
+        }
+        else
+        {
+            TR_ERROR((self_->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxOnWatchdogTimer(): Unable to reserve watchdog command ", 0U));
+            Fifo_Stop(self_, FIFO_S_UNSYNCED_INIT, true);
+        }
+    }
+    else                                            /* status not received in time - notify communication error */
+    {
+        TR_ERROR((self_->init.base_ptr->mns_inst_id, "[FIFO]", "Fifo_TxOnWatchdogTimer(): Missing response on status request", 0U));
+        Fifo_Stop(self_, FIFO_S_UNSYNCED_INIT, true);
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmfifo.h b/mnsl/mns_pmfifo.h
new file mode 100644
index 0000000..3c9962f
--- /dev/null
+++ b/mnsl/mns_pmfifo.h
@@ -0,0 +1,232 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Port Message FIFO
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_PMF
+ * @{
+ */
+
+#ifndef MNS_PMFIFO_H
+#define MNS_PMFIFO_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_base.h"
+#include "mns_lld_pb.h"
+#include "mns_message.h"
+#include "mns_encoder.h"
+#include "mns_pmp.h"
+#include "mns_lldpool.h"
+#include "mns_pmchannel.h"
+#include "mns_pmcmd.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Number of LLD Tx handles dedicated to each FIFO */
+#define FIFO_TX_HANDLES     5U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Callback function which is invoked when receiving an Rx message 
+ *  \param  self    The Instance (of the host)
+ *  \param  msg_ptr The Rx message
+ */
+typedef void (*Fifo_OnRxMsg_t)(void *self, CMessage *msg_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Initialization structure of class Port Message FIFO */
+typedef struct Fifo_InitData_
+{
+    CBase              *base_ptr;       /*!< \brief Reference to base module */
+    CPmChannel         *channel_ptr;    /*!< \brief Points to channel object which is needed to communicate with
+                                         *          the driver */
+    IEncoder           *tx_encoder_ptr; /*!< \brief Encoder for Tx messages */
+    IEncoder           *rx_encoder_ptr; /*!< \brief Encoder for Rx messages */
+    Fifo_OnRxMsg_t      rx_cb_fptr;     /*!< \brief Callback function invoked for Rx */
+    void               *rx_cb_inst;     /*!< \brief Instance which is referred when invoking rx_cb_fptr */
+
+} Fifo_InitData_t;
+
+/*! \brief  Initialization structure of class Port Message FIFO */
+typedef struct Fifo_Config_
+{
+    Pmp_FifoId_t    fifo_id;            /*!< \brief Identifier of message FIFO.
+                                         *   \details It is required that the fifo_id has the same value as
+                                         *            specified in PMP.
+                                         */
+    uint8_t         rx_credits;         /*!< \brief Number of Rx credits, i.e. reserved Rx messages */
+    uint8_t         rx_threshold;       /*!< \brief Number of Rx credits which are acknowledged in a single status.
+                                         *   \details The value needs to be smaller or equal than \c rx_credits.
+                                         *          Valid values are:
+                                         *          - 0,1:              Single message acknowledge
+                                         *          - 2..rx_credits:    Implicit acknowledge is triggered after 
+                                         *                              the specified number of messages.
+                                         */
+    uint8_t         tx_wd_timeout;      /*!< \brief Idle timeout in x100ms. Formerly known as watchdog timeout */
+    uint16_t        tx_wd_timer_value;  /*!< \brief Timer value used to trigger the watchdog in ms */
+    uint8_t         rx_ack_timeout;     /*!< \brief Rx status timeout in x100ms. */
+    uint8_t         rx_busy_allowed;    /*!< \brief Number of allowed RxStatus busy responds. 0..14, or 0xF (infinite) */
+
+} Fifo_Config_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal types                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief The synchronization status  */
+typedef enum Fifo_SyncState_
+{ 
+    FIFO_S_UNSYNCED_INIT,
+    FIFO_S_SYNCING,
+    FIFO_S_UNSYNCED_BUSY,
+    FIFO_S_UNSYNCED_READY,
+    FIFO_S_SYNCED,
+    FIFO_S_UNSYNCING
+
+} Fifo_SyncState_t;
+
+/*! \brief The class CPmFifo*/
+typedef struct CPmFifo_
+{
+    Fifo_InitData_t         init;               /*!< \brief Initialization data */
+    Fifo_Config_t           config;             /*!< \brief Configuration data */
+
+    CService                service;            /*!< \brief Service object */
+    Fifo_SyncState_t        sync_state;         /*!< \brief Synchronization state of the FIFO */
+    CSubject                sync_state_subject; /*!< \brief Notification of changed synchronization state */
+    uint8_t                 sync_params[4];     /*!< \brief Synchronization parameters */
+    uint8_t                 sync_cnt;           /*!< \brief Counts the number of synchronization attempts */
+
+    struct CPmFifo_wd_
+    {
+        CTimer              timer;              /*!< \brief The timer object */
+        CPmCommand          wd_cmd;             /*!< \brief The watchdog command message */
+        uint16_t            timer_value;        /*!< \brief The internal timer value used by PMC to trigger the watchdog */
+        bool                request_started;    /*!< \brief Is used to check if the INIC responds with a status before the 
+                                                 *          next Cmd.REQUEST_STATUS is triggered.
+                                                 */
+    } wd; 
+
+    struct CPmFifo_rx_
+    {
+        CDlList queue;                          /*!< \brief Message queue containing all incoming messages */
+
+        IEncoder *encoder_ptr;                  /*!< \brief Encoder for Rx messages */
+        Fifo_OnRxMsg_t on_complete_fptr;        /*!< \brief Callback function invoked for Rx */
+        void *on_complete_inst;                 /*!< \brief Instance which is referred when invoking rx_cb_fptr */
+
+        uint8_t ack_threshold;                  /*!< \brief Number of unacknowledged Rx credits */
+        uint8_t ack_last_ok_sid;                /*!< \brief Latest SID which was acknowledged with "success" */ 
+        uint8_t expected_sid;                   /*!< \brief The next expected Rx message SeqId */
+        uint8_t busy_num;                       /*!< \brief The number of currently processing data messages */
+
+        bool wait_processing;                   /*!< \brief If set: Wait until transmission of e.g. NACK has finished 
+                                                 *          before continuing with further Rx message processing.
+                                                 *          The flag is used if a status must be sent explicitly.
+                                                 */
+        CPmCommand status;                      /*!< \brief Rx status channel control  */
+
+    } rx;
+
+    struct CPmFifo_tx_
+    {
+        CDlList waiting_queue;                  /*!< \brief Queue containing all outgoing messages */
+        CDlList pending_q;                      /*!< \brief Queue containing all messages waiting for Tx status */
+        IEncoder *encoder_ptr;                  /*!< \brief Encoder for Tx messages */
+        uint8_t credits;                        /*!< \brief Remaining Tx credits */
+ 
+        CLldPool lld_pool;                      /*!< \brief Pool of LLD Tx messages, used for data messages */
+
+        CPmh pm_header;                         /*!< \brief Temporary header which is used to build the FIFO data messages*/
+        CPmCommand cancel_cmd;                  /*!< \brief Tx cancel command message */
+        CPmCommand sync_cmd;                    /*!< \brief Sync command message */
+
+        uint8_t sid_next_to_use;                /*!< \brief SID that shall be used for the next transmission */
+        uint8_t sid_last_completed;             /*!< \brief Latest SID that was acknowledged by the INIC */
+        uint8_t current_sid;                    /*!< \brief Tracks the latest valid FIFO status SID received from the INIC */
+        Pmp_StatusType_t current_type;          /*!< \brief Tracks the latest valid FIFO status type received from the INIC */
+        uint8_t current_code;                   /*!< \brief Tracks the latest valid FIFO status code received from the INIC */
+
+        bool status_waiting_release;            /*!< \brief Is \c true if status notification wasn't completed due to messages
+                                                 *          which are not yet released by the LLD. 
+                                                 */
+        bool cancel_all_running;                /*!< \brief Is \c true during pending command CANCEL_ALL. This command is required
+                                                 *          if the front-most message is segmented which requires to discard all
+                                                 *          belonging segments (same \c cancel_id) after the CANCEL_ALL was completed.
+                                                 */
+        uint8_t failure_status;                 /*!< \brief Stores the Tx status until the message is canceled */
+        uint8_t failure_sid;                    /*!< \brief Stores the SID of the last cancelled data message */
+    } tx;
+
+} CPmFifo;
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Function Prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Fifo_Ctor(CPmFifo *self, const Fifo_InitData_t *init_ptr, const Fifo_Config_t *config_ptr);
+extern void Fifo_Stop(CPmFifo *self, Fifo_SyncState_t new_state, bool allow_notification);
+extern void Fifo_Cleanup(CPmFifo *self);
+
+extern void Fifo_Synchronize(CPmFifo *self);
+extern void Fifo_Unsynchronize(CPmFifo *self);
+extern Fifo_SyncState_t Fifo_GetState(CPmFifo *self);
+extern void Fifo_AddStateObserver(CPmFifo *self, CObserver *obs_ptr);
+extern void Fifo_RemoveStateObserver(CPmFifo *self, CObserver *obs_ptr);
+
+/* Rx interface */
+extern void Fifo_RxReleaseMsg(CPmFifo *self, CMessage *msg_ptr);
+
+/* Tx interface */
+extern void Fifo_Tx(CPmFifo *self, CMessage *msg_ptr, bool bypass);
+extern void Fifo_TxOnRelease(void *self, Mns_Lld_TxMsg_t *handle_ptr);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif                                              /* MNS_PMFIFO_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmfifos.c b/mnsl/mns_pmfifos.c
new file mode 100644
index 0000000..e82b837
--- /dev/null
+++ b/mnsl/mns_pmfifos.c
@@ -0,0 +1,447 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 class CPmFifos
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMFIFOS
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmfifos.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal Constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief The initialization value of sync_count. It is incremented for each sync or un-sync attempt. */
+static const uint8_t     FIFOS_SYNC_CNT_INITIAL = 0xFFU;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal typedefs                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Fifos_Cleanup(CPmFifos *self);
+static void Fifos_OnSyncTimeout(void *self);
+static void Fifos_OnUnsyncTimeout(void *self);
+static void Fifos_OnFifoEvent(void *self, void *fifo_id_ptr);
+
+static void Fifos_HandleFifoStateChange(CPmFifos *self, Pmp_FifoId_t fifo_id);
+static bool Fifos_AreAllFifosInState(CPmFifos *self, Fifo_SyncState_t target_state);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of class CPmFifos
+ *  \param  self         The instance
+ *  \param  base_ptr     Reference to basic services
+ *  \param  channel_ptr  Reference to the port message channel
+ *  \param  icm_fifo_ptr Reference to ICM FIFO, or NULL. 
+ *  \param  mcm_fifo_ptr Reference to MCM FIFO, or NULL.
+ *  \param  rcm_fifo_ptr Reference to RCM FIFO, or NULL.
+ *  \details At least one FIFO (MCM or ICM) must be provided.
+ */
+void Fifos_Ctor(CPmFifos *self, CBase *base_ptr, CPmChannel *channel_ptr, CPmFifo *icm_fifo_ptr, CPmFifo *mcm_fifo_ptr, CPmFifo *rcm_fifo_ptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+
+    self->base_ptr      = base_ptr;
+    self->channel_ptr   = channel_ptr;
+    self->state         = FIFOS_S_UNSYNCED;
+
+    self->unsync_initial = false;
+    Fifos_ConfigureSyncParams(self, FIFOS_SYNC_RETRIES, FIFOS_SYNC_TIMEOUT);
+
+    self->fifos[PMP_FIFO_ID_ICM] = icm_fifo_ptr;
+    self->fifos[PMP_FIFO_ID_RCM] = rcm_fifo_ptr;
+    self->fifos[PMP_FIFO_ID_MCM] = mcm_fifo_ptr;
+
+    T_Ctor(&self->init_timer); 
+    Sub_Ctor(&self->event_subject, self->base_ptr->mns_inst_id);
+    Obs_Ctor(&self->obs_icm, self, &Fifos_OnFifoEvent);
+    Obs_Ctor(&self->obs_rcm, self, &Fifos_OnFifoEvent);
+    Obs_Ctor(&self->obs_mcm, self, &Fifos_OnFifoEvent);
+    
+    Pmcmd_Ctor(&self->cmd, PMP_FIFO_ID_ALL, PMP_MSG_TYPE_CMD);
+
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[FIFOS]", (!((icm_fifo_ptr == NULL) && (mcm_fifo_ptr == NULL))));
+
+    if (icm_fifo_ptr != NULL)
+    {
+        Fifo_AddStateObserver(icm_fifo_ptr, &self->obs_icm);
+    }
+
+    if (rcm_fifo_ptr != NULL)
+    {
+        Fifo_AddStateObserver(rcm_fifo_ptr, &self->obs_rcm);
+    }
+
+    if (mcm_fifo_ptr != NULL)
+    {
+        Fifo_AddStateObserver(mcm_fifo_ptr, &self->obs_mcm);
+    }
+
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_Ctor(): FIFOS created, state %d", 1U, self->state));
+}
+
+/*! \brief          Adds an observer of synchronization events
+ *  \param self     The instance
+ *  \param obs_ptr  The observer. The notification result type is Fifos_Event_t.
+ */
+void Fifos_AddEventObserver(CPmFifos *self, CObserver *obs_ptr)
+{
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[FIFOS]", (obs_ptr != 0));
+    (void)Sub_AddObserver(&self->event_subject, obs_ptr);
+}
+
+/*! \brief          Removes an observer of synchronization events
+ *  \param self     The instance
+ *  \param obs_ptr  The observer.
+ */
+void Fifos_RemoveEventObserver(CPmFifos *self, CObserver *obs_ptr)
+{
+    TR_ASSERT(self->base_ptr->mns_inst_id, "[FIFOS]", (obs_ptr != 0));
+    (void)Sub_RemoveObserver(&self->event_subject, obs_ptr);
+}
+
+/*! \brief          Forces all FIFOs to state UNSYNCED without waiting for INIC responses and
+ *                  without throwing events
+ *  \details        Stops the LLD interface and releases all pending message resources.
+ *                  This function shall be called if the MNS requires a un-normal termination
+ *                  which is not detected by port message protocol.
+ *  \param self     The instance
+ */
+void Fifos_ForceTermination(CPmFifos *self)
+{
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_ForceTermination(): Termination started, state: %d", 1U, self->state));
+    Fifos_Cleanup(self);
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_ForceTermination(): Termination done, state: %d", 1U, self->state));
+}
+
+/*! \brief          Configures retries and timeout for synchronize or un-synchronize
+ *                  operation
+ *  \details        This method shall be called before starting a synchronization or un-synchronization
+ *                  or after it has finished. The current counter of synchronization attempts is reset.
+ *  \param self     The instance
+ *  \param retries  The number of retries until event FIFOS_EV_SYNC_FAILED or 
+ *                  FIFOS_EV_UNSYNC_FAILED will be notified
+ *  \param timeout  The timeout in milliseconds when the retry is performed
+ */
+void Fifos_ConfigureSyncParams(CPmFifos *self, uint8_t retries, uint16_t timeout)
+{
+    self->cmd_retries = retries;
+    self->cmd_timeout = timeout;
+    self->sync_cnt = FIFOS_SYNC_CNT_INITIAL;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Synchronization                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief    Initializes all port message FIFOs
+ *  \details  Possible results of the operation are the following events which are fired
+ *            asynchronously. Refer also Fifos_AddEventObserver() and \ref Fifos_Event_t.
+ *            - \ref FIFOS_EV_SYNC_ESTABLISHED
+ *            - \ref FIFOS_EV_SYNC_FAILED
+ *  \param    self        The instance
+ *  \param    reset_cnt   If \c true resets the synchronization counter. In this case an automatic
+ *                        retries will be done after the first synchronization timeout.
+ *  \param    force_sync  If \c true the method will also trigger the synchronization of already 
+ *                        synced \ref CPmFifo objects.
+ */
+void Fifos_Synchronize(CPmFifos *self, bool reset_cnt, bool force_sync)
+{
+    uint8_t cnt;
+    self->state = FIFOS_S_SYNCING;
+    self->unsync_initial = false;
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_Synchronize(): Synchronization started, state: %d", 1U, self->state));
+
+    if (reset_cnt)
+    {
+        self->sync_cnt = FIFOS_SYNC_CNT_INITIAL;
+    }
+
+    self->sync_cnt++;
+    Pmch_Initialize(self->channel_ptr);                     /* Start LLD if not already done */
+
+    for (cnt = 0U; cnt < PMP_MAX_NUM_FIFOS; cnt++)
+    {
+        if (self->fifos[cnt] != NULL)
+        {
+            if (force_sync || (Fifo_GetState(self->fifos[cnt]) != FIFO_S_SYNCED))
+            {
+                Fifo_Synchronize(self->fifos[cnt]);
+            }
+        }
+    }
+
+    Tm_SetTimer(&self->base_ptr->tm, &self->init_timer, 
+                &Fifos_OnSyncTimeout, self, 
+                self->cmd_timeout, 0U);
+}
+
+/*! \brief      Un-initializes all port message FIFOs
+ *  \details    Possible results of the operation are the following events which are fired
+ *              asynchronously. Refer also Fifos_AddEventObserver() and \ref Fifos_Event_t.
+ *              - \ref FIFOS_EV_UNSYNC_COMPLETE
+ *              - \ref FIFOS_EV_UNSYNC_FAILED
+ *  \param      self    The instance
+ *  \param      reset_cnt  If \c true resets the synchronization counter. In this case an automatic
+ *                         retries will be done after the first synchronization timeout.
+ *  \param      initial    If the un-synchronization shall be executed prior to a initial synchronization
+ *                         it is recommended to set the argument to \c true. After notifying the event 
+ *                         FIFOS_EV_UNSYNC_COMPLETE the LLD interface will not be stopped. The subsequent 
+ *                         call of Fifos_Synchronize() will not start the LLD interface un-necessarily.
+ *                         To trigger a final un-synchronization \c initial shall be set to \c false.
+ *                         I.e., FIFOS_EV_UNSYNC_COMPLETE stops the LLD interface.
+ */
+void Fifos_Unsynchronize(CPmFifos *self, bool reset_cnt, bool initial)
+{
+    self->state = FIFOS_S_UNSYNCING;
+    self->unsync_initial = initial;
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_Unsynchronize(): Un-synchronization started, state: %d", 1U, self->state));
+
+    if (reset_cnt)
+    {
+        self->sync_cnt = FIFOS_SYNC_CNT_INITIAL;
+    }
+
+    self->sync_cnt++;
+    Pmch_Initialize(self->channel_ptr);                     /* Start LLD if not already done */
+
+    if (Pmcmd_Reserve(&self->cmd))
+    {
+        Pmcmd_SetContent(&self->cmd, 0xFFU, PMP_CMD_TYPE_SYNCHRONIZATION, PMP_CMD_CODE_UNSYNC, NULL, 0U);
+
+        Pmch_Transmit(self->channel_ptr, Pmcmd_GetLldTxObject(&self->cmd));
+    }
+
+    Tm_SetTimer(&self->base_ptr->tm, &self->init_timer, 
+                &Fifos_OnUnsyncTimeout, self, 
+                self->cmd_timeout, 0U);
+}
+
+/*! \brief  Handles the synchronization timeout
+ *  \param  self    The instance
+ */
+static void Fifos_OnSyncTimeout(void *self)
+{
+    CPmFifos *self_ = (CPmFifos*)self;
+    Fifos_Event_t the_event = FIFOS_EV_SYNC_FAILED;
+
+    self_->state = FIFOS_S_UNSYNCED;
+
+    TR_INFO((self_->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_OnSyncTimeout(): state: %d", 1U, self_->state));
+
+    if (self_->sync_cnt < self_->cmd_retries)
+    {
+        Fifos_Synchronize(self_, false, false);             /* retry synchronization after first timeout */
+    }
+    else
+    {
+        Fifos_Cleanup(self_);
+        Sub_Notify(&self_->event_subject, &the_event);
+    }
+}
+
+/*! \brief  Handles the un-synchronization timeout
+ *  \param  self    The instance
+ */
+static void Fifos_OnUnsyncTimeout(void *self)
+{
+    CPmFifos *self_ = (CPmFifos*)self;
+    Fifos_Event_t the_event = FIFOS_EV_UNSYNC_FAILED;
+
+    self_->state = FIFOS_S_UNSYNCED;
+    TR_INFO((self_->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_OnUnsyncTimeout(): state: %d", 1U, self_->state));
+
+    if (self_->sync_cnt < self_->cmd_retries)
+    {
+        Fifos_Unsynchronize(self_, false, self_->unsync_initial);   /* retry synchronization after first timeout */
+    }
+    else
+    {
+        self_->unsync_initial = false;                              /* un-sync timeout will lead to termination - stop LLD */
+    Fifos_Cleanup(self_);
+    Sub_Notify(&self_->event_subject, &the_event);
+}
+}
+
+/*! \brief      Performs a cleanup of the Port Message Channel and the dedicated FIFOs
+ *  \details    Releases all message objects which are currently in use.
+ *  \param      self            The instance
+ */
+static void Fifos_Cleanup(CPmFifos *self)
+{
+    uint8_t count;
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_Cleanup(): Channel cleanup started", 0U));
+
+    if (self->unsync_initial == false)
+    {
+    Pmch_Uninitialize(self->channel_ptr);
+    }
+
+    for (count = 0U; count < PMP_MAX_NUM_FIFOS; count++)    /* stop & cleanup all FIFOs */
+    {
+        if (self->fifos[count] != NULL)
+        {                                               /* stop and avoid recursion */
+            Fifo_Stop(self->fifos[count], FIFO_S_UNSYNCED_INIT, false);
+            Fifo_Cleanup(self->fifos[count]);
+        }
+    }
+
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_Cleanup(): Channel cleanup completed", 0U));
+
+    /* notify external event after message objects were released */
+    self->state = FIFOS_S_UNSYNCED;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* FIFO observation                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+
+/*! \brief  Notifies an event to the host class
+ *  \param  self        The instance
+ *  \param  fifo_id_ptr Specific event identifier, pointer to "fifo_id"
+ */
+static void Fifos_OnFifoEvent(void *self, void *fifo_id_ptr)
+{
+    CPmFifos *self_ = (CPmFifos*)self;
+    Fifos_HandleFifoStateChange(self_, *((Pmp_FifoId_t*)fifo_id_ptr));
+}
+
+/*! \brief  Executes transition to new synchronization states
+ *  \param  self        The instance
+ *  \param  fifo_id     The FIFO identifier
+ */
+static void Fifos_HandleFifoStateChange(CPmFifos *self, Pmp_FifoId_t fifo_id)
+{
+    Fifos_Event_t the_event;
+
+    TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): FIFOs state: %d, FIFO: %d, FIFO State: %d", 3U, 
+             self->state, fifo_id, Fifo_GetState(self->fifos[fifo_id])));
+
+    switch (self->state)
+    {
+        case FIFOS_S_SYNCING:
+            if (Fifos_AreAllFifosInState(self, FIFO_S_SYNCED))
+            {
+                self->state = FIFOS_S_SYNCED;                           /* now the complete channel is synced */
+                Tm_ClearTimer(&self->base_ptr->tm, &self->init_timer);
+                Fifos_ConfigureSyncParams(self, FIFOS_UNSYNC_RETRIES, FIFOS_UNSYNC_TIMEOUT);
+                the_event = FIFOS_EV_SYNC_ESTABLISHED;
+                Sub_Notify(&self->event_subject, &the_event);
+                TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Synchronization of Port Message channel completed", 0U));
+            }
+            break;
+
+        case FIFOS_S_UNSYNCING:
+            if (Fifos_AreAllFifosInState(self, FIFO_S_UNSYNCED_READY))
+            {
+                Fifos_Cleanup(self);
+                self->state = FIFOS_S_UNSYNCED;                         /* now the complete channel is un-synced */
+                Tm_ClearTimer(&self->base_ptr->tm, &self->init_timer);
+                the_event = FIFOS_EV_UNSYNC_COMPLETE;
+                Sub_Notify(&self->event_subject, &the_event);
+                TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Un-synchronization of Port Message channel completed", 0U));
+            }
+            break;
+
+        case FIFOS_S_SYNCED:
+            if (!Fifos_AreAllFifosInState(self, FIFO_S_SYNCED))
+            {
+                self->state = FIFOS_S_UNSYNCING;                        /* set state to 'unsyncing' and wait until all FIFOs are unsynced */
+                self->sync_cnt = 0U;                                    /* pretend having triggered an un-sync which starts the timer */
+                Tm_SetTimer(&self->base_ptr->tm, &self->init_timer, 
+                            &Fifos_OnUnsyncTimeout, self, 
+                            FIFOS_UNSYNC_TIMEOUT, 0U); 
+                the_event = FIFOS_EV_SYNC_LOST;
+                Sub_Notify(&self->event_subject, &the_event);
+                TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Lost synchronization of Port Message channel", 0U));
+            }
+            if (Fifos_AreAllFifosInState(self, FIFO_S_UNSYNCED_READY))
+            {
+                Fifos_Cleanup(self);
+                self->state = FIFOS_S_UNSYNCED;                         /* the complete channel suddenly goes unsynced_complete */
+                Tm_ClearTimer(&self->base_ptr->tm, &self->init_timer);
+                the_event = FIFOS_EV_UNSYNC_COMPLETE;
+                Sub_Notify(&self->event_subject, &the_event);
+                TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Sudden un-synchronization of Port Message channel completed", 0U));
+            }
+            break;
+
+        case FIFOS_S_UNSYNCED:
+            TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Unexpected FIFO event in state unsynced", 0U));
+            break;
+
+        default:
+            TR_INFO((self->base_ptr->mns_inst_id, "[FIFOS]", "Fifos_HandleFifoStateChange(): Unexpected FIFOs state", 0U));
+            break;
+    }
+
+    MISC_UNUSED(fifo_id);
+}
+
+/*! \brief  Helper function that evaluates if all configured FIFOs are in a given state 
+ *  \param  self            The instance
+ *  \param  target_state    The required state that is evaluated for all FIFOs
+ *  \return \c true if all FIFOs are in the given \c target_state, otherwise \c false.
+ */
+static bool Fifos_AreAllFifosInState(CPmFifos *self, Fifo_SyncState_t target_state)
+{
+    bool ret = true;
+    uint8_t cnt;
+
+    for (cnt = 0U; cnt < PMP_MAX_NUM_FIFOS; cnt++)
+    {
+        if (self->fifos[cnt] != NULL)
+        {
+            Fifo_SyncState_t state = Fifo_GetState(self->fifos[cnt]);
+
+            if (state != target_state)
+            {
+                ret = false;
+            }
+        }
+    }
+
+    return ret;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmfifos.h b/mnsl/mns_pmfifos.h
new file mode 100644
index 0000000..814b057
--- /dev/null
+++ b/mnsl/mns_pmfifos.h
@@ -0,0 +1,131 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of class CPmFifos
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_PMFIFOS
+ * @{
+ */
+
+#ifndef MNS_PMFIFOS_H
+#define MNS_PMFIFOS_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_base.h"
+#include "mns_pmfifo.h"
+#include "mns_pmchannel.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+#define FIFOS_SYNC_TIMEOUT      50U     /*!< \brief Synchronization timeout in milliseconds */
+#define FIFOS_SYNC_RETRIES      40U     /*!< \brief Maximum number of synchronization retries after timeout */
+#define FIFOS_UNSYNC_TIMEOUT    200U    /*!< \brief Un-synchronization timeout in milliseconds */
+#define FIFOS_UNSYNC_RETRIES    0U      /*!< \brief Un-synchronization retries */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal types                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief The synchronization status of all FIFOs */
+typedef enum Fifos_SyncState_
+{ 
+    FIFOS_S_UNSYNCED,               /*!< \brief Not all FIFOs are synchronized  */
+    FIFOS_S_SYNCING,                /*!< \brief FIFOs synchronization has started */
+    FIFOS_S_SYNCED,                 /*!< \brief All FIFOs are synchronized */
+    FIFOS_S_UNSYNCING               /*!< \brief FIFOs un-synchronization has started */
+
+} Fifos_SyncState_t;
+
+/*! \brief  PMS Events */
+typedef enum Fifos_Event_
+{
+    FIFOS_EV_SYNC_LOST = 0,         /*!< \brief Synchronization of at least one FIFO is lost */
+    FIFOS_EV_SYNC_ESTABLISHED = 1,  /*!< \brief Synchronization of all FIFOs is established */
+    FIFOS_EV_SYNC_FAILED = 2,       /*!< \brief The initial synchronization of FIFOs failed */
+    FIFOS_EV_UNSYNC_COMPLETE = 3,   /*!< \brief Un-synchronization of all FIFOs has succeeded */
+    FIFOS_EV_UNSYNC_FAILED = 4      /*!< \brief Un-synchronization of all FIFOs has failed */
+
+} Fifos_Event_t;
+
+/*! \brief The class CPmFifos*/
+typedef struct CPmFifos_
+{
+    CBase      *base_ptr;               /*!< \brief Reference to base object */
+    uint8_t     mns_inst_id;            /*!< \brief MOST NetServices instance ID */
+    CPmChannel *channel_ptr;            /*!< \brief MOST NetServices instance ID */
+
+    CPmFifo *fifos[PMP_MAX_NUM_FIFOS];  /*!< \brief Reference to assigned FIFOs */
+
+    CObserver           obs_icm;        /*!< \brief Observes ICM synchronization state */
+    CObserver           obs_rcm;        /*!< \brief Observes ICM synchronization state */
+    CObserver           obs_mcm;        /*!< \brief Observes MCM synchronization state */
+    CPmCommand          cmd;            /*!< \brief The UNSYNC command message */
+    Fifos_SyncState_t   state;          /*!< \brief The Overall synchronization state */
+    uint8_t             sync_cnt;       /*!< \brief The current count of synchronization command */
+
+    uint8_t             cmd_retries;    /*!< \brief The number of sync/un-sync retries */
+    uint16_t            cmd_timeout;    /*!< \brief The the timeout to retry sync/un-sync */
+    bool                unsync_initial; /*!< \brief Specifies if un-sync complete shall un-initialize the channel */
+ 
+    CSubject    event_subject;          /*!< \brief Subject to report synchronization result */
+    CTimer      init_timer;             /*!< \brief Timer elapses on synchronization timeout */
+
+} CPmFifos;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Function prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Fifos_Ctor(CPmFifos *self, CBase *base_ptr, CPmChannel *channel_ptr, CPmFifo *icm_fifo_ptr, CPmFifo *mcm_fifo_ptr, CPmFifo *rcm_fifo_ptr);
+extern void Fifos_AddEventObserver(CPmFifos *self, CObserver *obs_ptr);
+extern void Fifos_RemoveEventObserver(CPmFifos *self, CObserver *obs_ptr);
+extern void Fifos_Synchronize(CPmFifos *self, bool reset_cnt, bool force_sync);
+extern void Fifos_Unsynchronize(CPmFifos *self, bool reset_cnt, bool initial);
+extern void Fifos_ForceTermination(CPmFifos *self);
+extern void Fifos_ConfigureSyncParams(CPmFifos *self, uint8_t retries, uint16_t timeout/*, bool uninit_on_fail*/);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif                                              /* MNS_PMFIFOS_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmp.c b/mnsl/mns_pmp.c
new file mode 100644
index 0000000..765982d
--- /dev/null
+++ b/mnsl/mns_pmp.c
@@ -0,0 +1,352 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Port Message Protocol
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_PMH
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pmp.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* PMP Indexes                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+#define PMP_IDX_PML_H           0U
+#define PMP_IDX_PML_L           1U
+#define PMP_IDX_PMHL            2U
+#define PMP_IDX_FPH             3U
+#define PMP_IDX_SID             4U
+#define PMP_IDX_EXT_TYPE        5U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Masks and shifts for bit fields                                                                */
+/*------------------------------------------------------------------------------------------------*/
+#define PMP_PMHL_MASK           0x1FU      /* 0b00011111 */
+#define PMP_VERSION_MASK        0xE0U      /* 0b11100000 */
+#define PMP_VERSION             0x40U      /* Version: "2" */
+#define PMP_FPH_TYPE_POS        1U
+#define PMP_FPH_TYPE_MASK       0x06U      /* 0b00000110 */
+#define PMP_FPH_ID_POS          3U
+#define PMP_FPH_ID_MASK         0x38U      /* 0b00111000 */
+#define PMP_FPH_DIR_RX          0x01U      /* RX: "1" */
+#define PMP_FPH_DIR_MASK        0x01U      /* 0b00000001 */
+#define PMP_EXT_TYPE_POS        5U
+#define PMP_EXT_TYPE_MASK       0xE0U      /* 0b11100000 */
+#define PMP_EXT_CODE_MASK       0x1FU      /* 0b00011111 */
+
+/*------------------------------------------------------------------------------------------------*/
+/* PMP Verification                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+#define PMP_PML_MAX_SIZE_CTRL   69U
+#define PMP_PMHL_MIN_SIZE       3U
+#define PMP_PMHL_MAX_SIZE       5U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macro like functions                                                                           */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Sets the port message length within a given message header
+ *  \param header The message header 
+ *  \param length The port message length
+ */
+void Pmp_SetPml(uint8_t header[], uint8_t length)
+{
+    header[PMP_IDX_PML_H] = 0U;
+    header[PMP_IDX_PML_L] = length;
+}
+
+/*! \brief Sets the port message header length within a given message header
+ *  \param header The message header 
+ *  \param length The port message header length. Valid values: 3..5.
+ *                Invalid values will set the PMHL to \c 0.
+ */
+void Pmp_SetPmhl(uint8_t header[], uint8_t length)
+{
+    if ((length < PMP_PMHL_MIN_SIZE) || (length > PMP_PMHL_MAX_SIZE))
+    {
+        length = 0U;
+    }
+
+    header[PMP_IDX_PMHL] = length | PMP_VERSION;
+}
+
+/*! \brief Sets the FIFO protocol header within a given message header
+ *  \param header The message header 
+ *  \param id   The FIFO id
+ *  \param type The port message type
+ */
+void Pmp_SetFph(uint8_t header[], Pmp_FifoId_t id, Pmp_MsgType_t type)
+{
+    header[PMP_IDX_FPH] = (uint8_t)((uint8_t)type << PMP_FPH_TYPE_POS) | (uint8_t)((uint8_t)id << PMP_FPH_ID_POS) | (uint8_t)PMP_DIR_TX;
+}
+
+/*! \brief Sets the field ExtType within a given message header
+ *  \param header The message header 
+ *  \param type   The command or status type
+ *  \param code   The command or status code
+ */
+void Pmp_SetExtType(uint8_t header[], uint8_t type, uint8_t code)
+{
+    header[PMP_IDX_EXT_TYPE] = (uint8_t)((type << PMP_EXT_TYPE_POS) & PMP_EXT_TYPE_MASK) | (uint8_t)(code & PMP_EXT_CODE_MASK);
+}
+
+/*! \brief Sets the sequence id within a given message header
+ *  \param header The message header 
+ *  \param sid    The sequence id
+ */
+void Pmp_SetSid(uint8_t header[], uint8_t sid)
+{
+    header[PMP_IDX_SID] = sid;
+}
+
+/*! \brief  Retrieves the port message length of a given port message buffer 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \return The port message length in bytes or 0 if the PML is greater than 255.
+ */
+uint8_t Pmp_GetPml(uint8_t header[]) 
+{
+    uint8_t pml;
+    if (header[PMP_IDX_PML_H] != 0U)
+    {
+        pml = 0U;
+    }
+    else
+    {
+        pml = header[PMP_IDX_PML_L];
+    }
+
+    return pml;
+}
+
+/*! \brief  Retrieves the port message header length of a given port message buffer 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \return The port message header length in bytes
+ */
+uint8_t Pmp_GetPmhl(uint8_t header[])
+{
+    return ((uint8_t)(header[PMP_IDX_PMHL] & (uint8_t)PMP_PMHL_MASK));
+}
+
+/*! \brief  Retrieves the FIFO number of a given port message buffer 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \return The FIFO number
+ */
+Pmp_FifoId_t Pmp_GetFifoId(uint8_t header[])
+{
+    return (Pmp_FifoId_t)(((uint8_t)PMP_FPH_ID_MASK & (header)[PMP_IDX_FPH]) >> PMP_FPH_ID_POS);
+}
+
+/*! \brief  Retrieves the FIFO Type of a given port message buffer 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \return The FIFO type
+ */
+Pmp_MsgType_t Pmp_GetMsgType(uint8_t header[])
+{
+    return ((Pmp_MsgType_t)((PMP_FPH_TYPE_MASK & (header)[PMP_IDX_FPH]) >> PMP_FPH_TYPE_POS));
+}
+
+/*! \brief  Retrieves the SequenceID of a given port message buffer 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \return The SequenceID
+ */
+uint8_t Pmp_GetSid(uint8_t header[])
+{
+    return ((header)[PMP_IDX_SID]);
+}
+
+/*! \brief  Retrieves payload data of a port message
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \param  index   The index of the payload byte starting with '0'
+ *  \return The content of a payload data byte
+ */
+uint8_t Pmp_GetData(uint8_t header[], uint8_t index)
+{
+    return header[Pmp_GetPmhl(header) + 3U + index];
+}
+
+/*! \brief   Retrieves the payload size of the port message
+ *  \param   header  Data buffer containing the port message.
+ *                   The required size of this buffer is 6 bytes.
+ *  \details The function Pmp_VerifyHeader() must be called before
+ *           to verify that the port message fields are consistent.
+ *  \return  The payload size of a port message
+ */
+uint8_t Pmp_GetDataSize(uint8_t header[])
+{
+    return Pmp_GetPml(header) - (Pmp_GetPmhl(header) + 1U);
+}
+
+/*! \brief  Checks if header length fields are set to valid values 
+ *  \param  header  Data buffer containing the port message.
+ *                  The required size of this buffer is 6 bytes.
+ *  \param  buf_len Length of the complete port message in bytes
+ *  \return Returns \c true if the header was checked successfully,
+ *          otherwise \c false.
+ */
+bool Pmp_VerifyHeader(uint8_t header[], uint8_t buf_len)
+{
+    uint8_t pml = Pmp_GetPml(header);
+    uint8_t pmhl = Pmp_GetPmhl(header);
+    bool ok = true;
+
+    ok = ((pmhl >= 3U)&&(pmhl <= 5U))       ? ok : false;
+    ok = ((header[PMP_IDX_PMHL] & PMP_VERSION_MASK) == PMP_VERSION) ? ok : false;
+    ok = (pml >= (pmhl + 1U))               ? ok : false;
+    ok = ((pml + 2U) <= buf_len)            ? ok : false;
+    ok = (pml <= PMP_PML_MAX_SIZE_CTRL)     ? ok : false;
+    ok = ((header[PMP_IDX_FPH] & PMP_FPH_DIR_MASK) == PMP_FPH_DIR_RX) ? ok : false;
+
+    return ok;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Creates a Port Message Header instance 
+ *  \param  self  The instance
+ */
+void Pmh_Ctor(CPmh *self)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+}
+
+/*! \brief  Inserts a port message header of the specified size into a given buffer 
+ *  \param  self        Header content to be written to the buffer (source)
+ *  \param  data        Data buffer the header shall be written to (target)
+ */
+void Pmh_BuildHeader(CPmh *self, uint8_t data[])
+{
+    uint8_t cnt;
+
+    data[PMP_IDX_PML_H]   = 0U;
+    data[PMP_IDX_PML_L]   = (uint8_t)self->pml;
+    data[PMP_IDX_PMHL]    = (uint8_t)PMP_VERSION | self->pmhl;
+    data[PMP_IDX_FPH]     = (uint8_t)PMP_DIR_TX | ((uint8_t)((self->fifo_id) << PMP_FPH_ID_POS)) |
+                            ((uint8_t)((self->msg_type) << PMP_FPH_TYPE_POS));
+
+    data[PMP_IDX_SID]     = self->sid;
+    data[PMP_IDX_EXT_TYPE]= self->ext_type;
+ 
+    for (cnt=3U; cnt < self->pmhl; cnt++)
+    {
+        data[3U + cnt] = 0U;                        /* add stuffing bytes */
+    }
+}
+
+/*! \brief  Decodes a given data buffer into a provided port message header structure 
+ *  \param  self        Header content structure (target)
+ *  \param  data        Data buffer containing the port message with a minimum size
+ *                      of 6 bytes (source)
+ */
+void Pmh_DecodeHeader(CPmh *self, uint8_t data[])
+{
+    self->pml = Pmp_GetPml(data);
+    self->pmhl  = data[PMP_IDX_PMHL] & PMP_PMHL_MASK;        /* ignore version */
+
+    self->fifo_id = Pmp_GetFifoId(data);
+    self->msg_type = Pmp_GetMsgType(data);
+    self->sid   = data[PMP_IDX_SID];
+    self->ext_type = data[PMP_IDX_EXT_TYPE];
+}
+
+/*! \brief      Setter function for FIFO protocol header which contains several subfields
+ *  \details    The "retransmitted" flag is currently not supported (always Tx)
+ *  \param      self        Reference to the PM content structure that shall be modified
+ *  \param      fifo_id     Id of the PM FIFO
+ *  \param      msg_type    PM type
+ */
+void Pmh_SetFph(CPmh *self, Pmp_FifoId_t fifo_id, Pmp_MsgType_t msg_type)
+{
+    self->msg_type = msg_type;
+    self->fifo_id = fifo_id;
+}
+
+/*! \brief  Retrieves the ExtType StatusType
+ *  \param  self    The instance
+ *  \return Returns The Status Type
+ */
+Pmp_StatusType_t Pmh_GetExtStatusType(CPmh *self)
+{
+    return ((Pmp_StatusType_t)((uint8_t)(PMP_EXT_TYPE_MASK & self->ext_type) >> PMP_EXT_TYPE_POS));
+}
+
+/*! \brief  Retrieves the ExtType StatusCode
+ *  \param  self    The instance
+ *  \return Returns The Status Code
+ */
+Pmp_CommandCode_t Pmh_GetExtCommandCode(CPmh *self)
+{
+    return ((Pmp_CommandCode_t)(uint8_t)(PMP_EXT_CODE_MASK & self->ext_type));
+}
+
+/*! \brief  Retrieves the ExtType StatusType
+ *  \param  self    The instance
+ *  \return Returns The Status Type
+ */
+Pmp_CommandType_t Pmh_GetExtCommandType(CPmh *self)
+{
+    return ((Pmp_CommandType_t)((uint8_t)(PMP_EXT_TYPE_MASK & self->ext_type) >> PMP_EXT_TYPE_POS));
+}
+
+/*! \brief  Retrieves the ExtType StatusCode
+ *  \param  self    The instance
+ *  \return Returns The Status Code
+ */
+Pmp_StatusCode_t Pmh_GetExtStatusCode(CPmh *self)
+{
+    return ((Pmp_StatusCode_t)(uint8_t)(PMP_EXT_CODE_MASK & self->ext_type));
+}
+
+/*! \brief      Sets the ExtType field by passing the values for type and code 
+ *  \details    The function is applicable for status and command
+ *  \param      self    The Instance
+ *  \param      type    The status or command type
+ *  \param      code    The status or command code
+ */
+void Pmh_SetExtType(CPmh *self, uint8_t type, uint8_t code)
+{
+    self->ext_type = (uint8_t)((type << PMP_EXT_TYPE_POS) & PMP_EXT_TYPE_MASK) | (uint8_t)(code & PMP_EXT_CODE_MASK);
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pmp.h b/mnsl/mns_pmp.h
new file mode 100644
index 0000000..96b22b0
--- /dev/null
+++ b/mnsl/mns_pmp.h
@@ -0,0 +1,211 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of Port Message Protocol
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_PMH
+ * @{
+ */
+
+#ifndef MNS_PMP_H
+#define MNS_PMP_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+#define PMP_PM_MAX_SIZE_HEADER    8U        /*!< \brief     Maximum size of a port message header */
+#define PMP_PM_MIN_SIZE_HEADER    6U        /*!< \brief     Minimum size of a port message header */
+#define PMP_MAX_NUM_FIFOS         7U        /*!< \brief     Maximum number if FIFOs an an array
+                                             *   \details   Means "3" if FIFO "0" and "2" is used
+                                             */
+#define PMP_CREDITS_MASK       0x3FU        /*!< \brief     Valid bits for credits: 5..0 */
+#define PMP_CREDITS_MIN           1U        /*!< \brief     Minimum value for credits: 1 */
+#define PMP_CREDITS_MAX          63U        /*!< \brief     Maximum value for credits: 63 */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+ 
+/*! \brief Specifies the FIFO */
+typedef enum Pmp_FifoId_
+{
+    PMP_FIFO_ID_MCM  = 0U,                  /*!< \brief FIFO dedicated to MOST Control Messages (MCM) */
+ /* PMP_FIFO_ID_MDP = 1U,                      < (reserved identifier) */
+    PMP_FIFO_ID_ICM  = 2U,                  /*!< \brief FIFO dedicated to INIC Control Messages (ICM) */
+    PMP_FIFO_ID_ALL  = 3U,                  /*!< \brief All FIFOs (ICM, MCM) */
+ /* PMP_FIFO_ID_MEP = 4U                       < (reserved identifier) */
+ /* PMP_FIFO_ID_IOCM = 5U                      < (reserved identifier) */
+    PMP_FIFO_ID_RCM  = 6U                   /*!< \brief FIFO dedicated to Remote Control Messages (RCM) */
+ /* PMP_FIFO_ID_RSVD = 7U                      < (reserved identifier) */
+
+} Pmp_FifoId_t;
+
+/*! \brief Specifies the messages type */
+typedef enum Pmp_MsgType_
+{
+    PMP_MSG_TYPE_CMD       = 0U,            /*!< \brief FIFO command message */
+    PMP_MSG_TYPE_STATUS    = 1U,            /*!< \brief FIFO status message */
+    PMP_MSG_TYPE_DATA      = 2U             /*!< \brief FIFO data message */
+
+} Pmp_MsgType_t;
+
+/*! \brief Specifies the direction of the Port Message */
+typedef enum Pmp_Direction_
+{
+    PMP_DIR_TX = 0,                         /*!< \brief Direction Tx (EHC -> INIC) */
+    PMP_DIR_RX = 1                          /*!< \brief Direction Rx (INIC -> EHC) */
+
+} Pmp_Direction_t;
+
+/*! \brief Specifies FIFO status types */
+typedef enum Pmp_StatusType_
+{
+    PMP_STATUS_TYPE_FAILURE         = 0U,   /*!< \brief PMP status type "failure" */
+    PMP_STATUS_TYPE_FLOW            = 1U,   /*!< \brief PMP status type "flow" */
+    PMP_STATUS_TYPE_SYNCED          = 4U,   /*!< \brief PMP status type "synced" */
+    PMP_STATUS_TYPE_UNSYNCED_BSY    = 5U,   /*!< \brief PMP status type "unsynced_busy" */
+    PMP_STATUS_TYPE_UNSYNCED_RDY    = 6U    /*!< \brief PMP status type "unsynced_ready" */
+
+} Pmp_StatusType_t;
+
+/*! \brief Specifies FIFO status codes */
+typedef enum Pmp_StatusCode_
+{
+    PMP_STATUS_CODE_BUSY            = 0U,   /*!< \brief PMP status code "busy" */
+    PMP_STATUS_CODE_SUCCESS         = 1U,   /*!< \brief PMP status code "success" */
+    PMP_STATUS_CODE_CANCELED        = 3U,   /*!< \brief PMP status code "canceled" */
+    PMP_STATUS_CODE_NACK            = 8U    /*!< \brief PMP status code "not_acknowledge" */
+
+} Pmp_StatusCode_t;
+
+/*! \brief Specifies FIFO status codes */
+typedef enum Pmp_UnsyncReason_
+{
+    PMP_UNSYNC_R_STARTUP            = 1U,   /*!< \brief PMP status code, UnsyncReason "INIC Startup" */
+    PMP_UNSYNC_R_REINIT             = 2U,   /*!< \brief PMP status code, UnsyncReason "Re-init of another FIFO" */
+    PMP_UNSYNC_R_COMMAND            = 3U,   /*!< \brief PMP status code, UnsyncReason "By sync or un-sync command" */
+    PMP_UNSYNC_R_ACK_TIMEOUT        = 4U,   /*!< \brief PMP status code, UnsyncReason "Missing EHC Rx acknowledge" */
+    PMP_UNSYNC_R_WD_TIMEOUT         = 5U,   /*!< \brief PMP status code, UnsyncReason "Missing EHC status request" */
+    PMP_UNSYNC_R_TX_TIMEOUT         = 6U    /*!< \brief PMP status code, UnsyncReason "Missing EHC read, or blocked communication" */
+
+} Pmp_UnsyncReason_t;
+
+/*! \brief Specifies FIFO command types */
+typedef enum Pmp_CommandType_
+{
+    PMP_CMD_TYPE_REQ_STATUS         = 0U,   /*!< \brief PMP command type "request_status" */
+    PMP_CMD_TYPE_MSG_ACTION         = 1U,   /*!< \brief PMP command type "message_action" */
+ /* PMP_CMD_TYPE_TRIGGER_NAOMDP     = 2U,      < (reserved identifier) */
+    PMP_CMD_TYPE_SYNCHRONIZATION    = 4U    /*!< \brief PMP command type "synchronization" */
+
+} Pmp_CommandType_t;
+
+/*! \brief Specifies FIFO command codes */
+typedef enum Pmp_CommandCode_
+{
+    PMP_CMD_CODE_REQ_STATUS         = 0U,   /*!< \brief PMP command code "request_status" */
+ /* PMP_CMD_CODE_TRIGGER_NAOMDP     = 0U,      <  (reserved identifier)*/
+    PMP_CMD_CODE_ACTION_RETRY       = 1U,   /*!< \brief PMP command type "request_status" */
+    PMP_CMD_CODE_ACTION_CANCEL      = 2U,   /*!< \brief PMP command type "request_status" */
+    PMP_CMD_CODE_ACTION_CANCEL_ALL  = 3U,   /*!< \brief PMP command type "request_status" */
+    PMP_CMD_CODE_UNSYNC             = 10U,  /*!< \brief PMP command type "request_status" */
+    PMP_CMD_CODE_SYNC               = 21U   /*!< \brief PMP command type "request_status" */
+
+} Pmp_CommandCode_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Header buffer operations                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+extern void Pmp_SetPml(uint8_t header[], uint8_t length);
+extern void Pmp_SetPmhl(uint8_t header[], uint8_t length);
+extern void Pmp_SetFph(uint8_t header[], Pmp_FifoId_t id, Pmp_MsgType_t type);
+extern void Pmp_SetExtType(uint8_t header[], uint8_t type, uint8_t code);
+extern void Pmp_SetSid(uint8_t header[], uint8_t sid);
+
+extern uint8_t       Pmp_GetPml(uint8_t header[]);
+extern uint8_t       Pmp_GetPmhl(uint8_t header[]);
+extern Pmp_FifoId_t  Pmp_GetFifoId(uint8_t header[]);
+extern Pmp_MsgType_t Pmp_GetMsgType(uint8_t header[]);
+extern uint8_t       Pmp_GetSid(uint8_t header[]);
+extern uint8_t       Pmp_GetDataSize(uint8_t header[]);
+extern uint8_t       Pmp_GetData(uint8_t header[], uint8_t index);
+extern bool          Pmp_VerifyHeader(uint8_t header[], uint8_t buf_len);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class CPmh                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Defines the content of a Port Message Header 
+ *  \details The current structure does not support  "direction" and "retransmitted" flag.
+ */
+typedef struct CPmh_
+{
+    uint8_t         pml;        /*!< \brief Port Message length */
+    uint8_t         pmhl;       /*!< \brief Port Message Header length */
+    Pmp_MsgType_t   msg_type;   /*!< \brief Port Message type */
+    Pmp_FifoId_t    fifo_id;    /*!< \brief FIFO identifier */
+    uint8_t         sid;        /*!< \brief The SequenceId */
+    uint8_t         ext_type;   /*!< \brief status or content type */
+ 
+} CPmh;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Function Prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+extern void Pmh_Ctor(CPmh *self);
+extern void Pmh_BuildHeader(CPmh *self, uint8_t data[]);
+extern void Pmh_DecodeHeader(CPmh *self, uint8_t data[]);
+extern void Pmh_SetFph(CPmh *self, Pmp_FifoId_t fifo_id, Pmp_MsgType_t msg_type);
+extern Pmp_StatusType_t Pmh_GetExtStatusType(CPmh *self);
+extern Pmp_StatusCode_t Pmh_GetExtStatusCode(CPmh *self);
+extern Pmp_CommandCode_t Pmh_GetExtCommandCode(CPmh *self);
+extern Pmp_CommandType_t Pmh_GetExtCommandType(CPmh *self);
+extern void Pmh_SetExtType(CPmh *self, uint8_t type, uint8_t code);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif                                              /* MNS_PMP_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_pool.c b/mnsl/mns_pool.c
new file mode 100644
index 0000000..870efd3
--- /dev/null
+++ b/mnsl/mns_pool.c
@@ -0,0 +1,127 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 message pool class
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_POOL
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_pool.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+ 
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of message pool class
+ *  \param  self            The instance
+ *  \param  messages        Reference to an array of message objects
+ *  \param  size            Number of message objects the \c messages array is comprising.
+ *  \param  mns_inst_id     MOST NetServices instance ID
+ */
+void Pool_Ctor(CPool *self, CMessage messages[], uint16_t size, uint8_t mns_inst_id)
+{
+    uint16_t index;
+
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->mns_inst_id = mns_inst_id;
+    self->initial_size = size;
+    self->messages = messages;
+
+    Dl_Ctor(&self->message_list, self->mns_inst_id); 
+
+    for (index = 0U; index < size; index++)
+    {
+        Msg_Ctor(&messages[index]);
+        Msg_SetPoolReference(&messages[index], self);
+        Dl_InsertTail(&self->message_list, Msg_GetNode(&messages[index]));
+    }
+}
+
+/*! \brief  Retrieves a message object from the pool
+ *  \param  self    The instance
+ *  \return Reference to the CMessage structure if a message is available.
+ *          Otherwise \c NULL.
+ */
+CMessage* Pool_GetMsg(CPool *self)
+{
+    CMessage *msg = NULL;
+    CDlNode *node = Dl_PopHead(&self->message_list);
+ 
+    if (node != NULL)
+    {
+        msg = (CMessage*)node->data_ptr;
+    }
+ 
+    return msg;
+}
+
+/*! \brief  Returns a message object to the pool pre-assigned pool
+ *  \param  msg_ptr Reference to the message object which needs
+ *                  to be returned to the pool. 
+ */
+void Pool_ReturnMsg(CMessage *msg_ptr)
+{
+    CPool *pool_ptr = (CPool*)Msg_GetPoolReference(msg_ptr);
+
+    if (pool_ptr != NULL)
+    {
+        TR_ASSERT(pool_ptr->mns_inst_id, "[POOL]", (Pool_GetCurrentSize(pool_ptr) < pool_ptr->initial_size));
+        Dl_InsertTail(&pool_ptr->message_list, Msg_GetNode(msg_ptr));
+    }
+    else
+    {
+        TR_ERROR((pool_ptr->mns_inst_id, "[POOL]", "Pool_ReturnMsg(): released msg_ptr=0x%p without pool reference", 1U, msg_ptr));
+    }
+}
+
+/*! \brief  Retrieves the current number of available message objects in the pool 
+ *  \param  self    The instance
+ *  \return The current number of available message objects in the pool
+ */
+uint16_t Pool_GetCurrentSize(CPool *self)
+{
+    uint16_t list_size = Dl_GetSize(&self->message_list);
+
+    return list_size;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
diff --git a/mnsl/mns_pool.h b/mnsl/mns_pool.h
new file mode 100644
index 0000000..c9b6edd
--- /dev/null
+++ b/mnsl/mns_pool.h
@@ -0,0 +1,82 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of message pool class
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_POOL
+ * @{
+ */
+#ifndef MNS_POOL_H
+#define MNS_POOL_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+#include "mns_dl.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/*------------------------------------------------------------------------------------------------*/
+/* Class CPool                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Class CMessage 
+ *  \details Common internal message class which embeds a list of MOST telegrams 
+ */
+typedef struct CPool_
+{
+    uint16_t    initial_size;   /*! \brief  The size of a provided message array */
+    CMessage   *messages;       /*! \brief  Reference to a message array provided by another module */
+    CDlList     message_list;   /*! \brief  Doubly linked list required providing available messages */
+    uint8_t     mns_inst_id;    /*! \brief  MOST NetServices instance ID */
+
+} CPool;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Methods                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+extern void Pool_Ctor(CPool *self, CMessage messages[], uint16_t size, uint8_t mns_inst_id);
+extern CMessage* Pool_GetMsg(CPool *self);
+extern void Pool_ReturnMsg(CMessage *msg_ptr);
+extern uint16_t Pool_GetCurrentSize(CPool *self);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_POOL_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_ret.h b/mnsl/mns_ret.h
new file mode 100644
index 0000000..50305bf
--- /dev/null
+++ b/mnsl/mns_ret.h
@@ -0,0 +1,115 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 This header file contains standard return values used by MOST NetServices functions 
+ *        and methods.
+ * \addtogroup G_MNS_MISC_RET_RES
+ * @{
+ */
+
+#ifndef MNS_RET_H
+#define MNS_RET_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Enumerations                                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Standard return codes used for synchronous response */
+typedef enum Mns_Return_
+{
+    MNS_RET_SUCCESS             = 0x00,     /*!< \brief Operation successfully completed */
+    MNS_RET_ERR_PARAM           = 0x01,     /*!< \brief At least one parameter exceeds its 
+                                                        admissible range */
+    MNS_RET_ERR_BUFFER_OVERFLOW = 0x02,     /*!< \brief Buffer overflow or service busy */
+    MNS_RET_ERR_NOT_AVAILABLE   = 0x03,     /*!< \brief Functionality not available */
+    MNS_RET_ERR_NOT_SUPPORTED   = 0x04,     /*!< \brief This function is not supported by this 
+                                                        derivative of INIC / physical layer / MOST 
+                                                        speed */
+    MNS_RET_ERR_INVALID_SHADOW  = 0x05,     /*!< \brief The requested information is not yet 
+                                                        available */
+    MNS_RET_ERR_ALREADY_SET     = 0x06,     /*!< \brief The value to be set is already set. The 
+                                                        application can therefore be aware that no 
+                                                        message will be send to INIC and no 
+                                                        callback will be called */
+    MNS_RET_ERR_API_LOCKED      = 0x07,     /*!< \brief INIC performs already requested function. */
+    MNS_RET_ERR_NOT_INITIALIZED = 0x08      /*!< \brief MOST NetServices is not initialized */
+
+} Mns_Return_t;
+
+/*! \brief Result codes used for asynchronous response */
+typedef enum Mns_Result_
+{
+    MNS_RES_SUCCESS           = 0x00,       /*!< \brief Operation successfully completed */
+    MNS_RES_ERR_MOST_STANDARD = 0x01,       /*!< \brief MOST standard error occurred */
+    MNS_RES_ERR_BUSY          = 0x02,       /*!< \brief Function currently busy */
+    MNS_RES_ERR_PROCESSING    = 0x03,       /*!< \brief Processing error occurred */
+    MNS_RES_ERR_CONFIGURATION = 0x04,       /*!< \brief Configuration error occurred */
+    MNS_RES_ERR_SYSTEM        = 0x05,       /*!< \brief System error occurred */
+    MNS_RES_ERR_TIMEOUT       = 0x06,       /*!< \brief Timeout occurred */
+    MNS_RES_ERR_TRANSMISSION  = 0x07        /*!< \brief Transmission error occurred */
+
+} Mns_Result_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Standard result structure which provides fields for detailed status and 
+ *          error information
+ *  \details \mns_ic_started{ The \ref P_UM_SYNC_AND_ASYNC_RESULTS section in \c Getting \c Started will provide you with more detailed information concerning the info pointer and the error code. }
+ */
+typedef struct Mns_StdResult_
+{
+    Mns_Result_t code;  /*!< \brief Result/Error code */
+    uint8_t *info_ptr;  /*!< \brief INIC error data */
+    uint8_t info_size;  /*!< \brief Size of the INIC error data in bytes */
+
+} Mns_StdResult_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Function signature used for MOST NetServices standard result callbacks
+ *  \param  result  Result of the callback
+ */
+typedef void (*Mns_StdResultCb_t)(Mns_StdResult_t result);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_RET_H */
+
+/*!
+ * @}
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_scheduler.c b/mnsl/mns_scheduler.c
new file mode 100644
index 0000000..1fc5273
--- /dev/null
+++ b/mnsl/mns_scheduler.c
@@ -0,0 +1,259 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the scheduler module. The module consists of the two classes
+ *        CScheduler and CService.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_SCHEDULER
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_scheduler.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Constants                                                                                      */
+/*------------------------------------------------------------------------------------------------*/
+const Srv_Event_t SRV_EMPTY_EVENT_MASK = (Srv_Event_t)0x00000000;   /*!< \brief Empty event mask */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static bool Scd_SearchSlot(void *current_prio_ptr, void *new_prio_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CScheduler                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the scheduler class.
+ *  \param self        Instance pointer
+ *  \param init_ptr    Reference to the initialization data
+ */
+void Scd_Ctor(CScheduler *self, Scd_InitData_t *init_ptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->mns_inst_id = init_ptr->mns_inst_id;
+    Dl_Ctor(&self->srv_list, self->mns_inst_id);
+    Ssub_Ctor(&self->service_request_subject, self->mns_inst_id);
+    (void)Ssub_AddObserver(&self->service_request_subject,
+                           init_ptr->service_request_obs_ptr);
+    self->scd_srv_is_running = false;
+}
+
+/*! \brief  Add the given service to the scheduler. All services are arranged in priority order.
+ *          A service with a higher priority will execute before a service with a lower priority.
+ *  \param  self       Instance pointer
+ *  \param  srv_ptr    Reference of the service which shall be added
+ *  \return SCD_OK: Service added
+ *  \return SCD_SRV_ALREADY_LISTED: Services already listed
+ */
+Scd_Ret_t Scd_AddService(CScheduler *self, CService *srv_ptr)
+{
+    Scd_Ret_t ret_val;
+
+    /* Check that service is not already part of scheduler */
+    if(false == Dl_IsNodeInList(&self->srv_list, &srv_ptr->list_node))
+    {
+        /* Search slot where the service must be inserted depending on the priority value.  */
+        CDlNode *result_ptr = Dl_Foreach(&self->srv_list, &Scd_SearchSlot, &srv_ptr->priority);
+ 
+        if(NULL != result_ptr)  /* Slot found? */
+        {
+            Dl_InsertBefore(&self->srv_list, result_ptr, &srv_ptr->list_node);
+        }
+        else                    /* No slot found -> Insert as last node */
+        {
+            Dl_InsertTail(&self->srv_list, &srv_ptr->list_node);
+        }
+        /* Create back link service -> scheduler */
+        srv_ptr->scd_ptr = self;
+        Dln_SetData(&srv_ptr->list_node, &srv_ptr->priority);
+        ret_val = SCD_OK;
+    }
+    else    /* Service is already part of schedulers list */
+    {
+        ret_val = SCD_SRV_ALREADY_LISTED;
+    }
+
+    return ret_val;
+}
+
+/*! \brief  Remove the given service from the schedulers list.
+ *  \param  self       Instance pointer
+ *  \param  srv_ptr    Reference of the service which shall be removed
+ *  \return SCD_OK: Service removed
+ *  \return SCD_UNKNOWN_SRV: Unknown service can not be removed
+ */
+Scd_Ret_t Scd_RemoveService(CScheduler *self, CService *srv_ptr)
+{
+    Scd_Ret_t ret_val = SCD_OK;
+
+    /* Error occurred? */
+    if(DL_UNKNOWN_NODE == Dl_Remove(&self->srv_list, &srv_ptr->list_node))
+    {
+        ret_val = SCD_UNKNOWN_SRV;
+    }
+
+    return ret_val;
+}
+
+/*! \brief Service function of the scheduler module.
+ *  \param self   Instance pointer
+ */
+void Scd_Service(CScheduler *self)
+{
+    CService *current_srv_ptr = (CService *)(void*)self->srv_list.head;
+
+    /* Scheduler service is running. Important for event handling */
+    self->scd_srv_is_running = true;
+
+    while(NULL != current_srv_ptr)  /* Process registered services */
+    {
+        if(NULL != current_srv_ptr->service_fptr)
+        {
+            /* Are events pending for the current service */
+            if(SRV_EMPTY_EVENT_MASK != current_srv_ptr->event_mask)
+            {
+                /* Execute service callback function */
+                current_srv_ptr->service_fptr(current_srv_ptr->instance_ptr);
+                /* Was the current service removed from the schedulers list? */
+                if((current_srv_ptr->list_node.prev == NULL) && (current_srv_ptr->list_node.next == NULL))
+                {
+                    break;  /* Abort scheduler service */
+                }
+            }
+        }
+        current_srv_ptr = (CService *)(void*)current_srv_ptr->list_node.next;
+    }
+    /* Scheduler services finished */
+    self->scd_srv_is_running = false;
+}
+
+/*! \brief  Searches for pending events.
+ *  \param  self   Instance pointer
+ *  \return true: At least one event is active
+ *  \return false: No event is pending
+ */
+bool Scd_AreEventsPending(CScheduler *self)
+{
+    bool ret_val = false;
+    CService *current_srv_ptr = (CService *)(void*)self->srv_list.head;
+
+    while(NULL != current_srv_ptr)
+    {
+        if(SRV_EMPTY_EVENT_MASK != current_srv_ptr->event_mask)
+        {
+            ret_val = true;
+            break;
+        }
+        current_srv_ptr = (CService *)(void*)current_srv_ptr->list_node.next;
+    }
+
+    return ret_val;
+}
+
+/*! \brief  Searches the slot where the new service has to be inserted. The position depends on 
+ *          the given priority. If a the priority of the new service is higher than the priority
+ *          of the current service \c true is returned which stops the search.
+ *  \param  current_prio_ptr   Current service which is analyzed 
+ *  \param  new_prio_ptr       Priority of the new service
+ *  \return false: The priority of the current service is greater than the new priority
+ *  \return true: The priority of the current service is less than or equal to the new priority
+ */
+static bool Scd_SearchSlot(void *current_prio_ptr, void *new_prio_ptr)
+{
+    uint8_t current_prio_ptr_ = *((uint8_t *)current_prio_ptr);
+    uint8_t new_prio_ = *((uint8_t*)new_prio_ptr);
+    bool ret_val = false;
+
+    if(current_prio_ptr_ <= new_prio_)
+    {
+        ret_val = true;
+    }
+
+    return ret_val;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CService                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Parameter constructor of the service class.
+ *  \param self            Instance pointer
+ *  \param instance_ptr    Reference to object which contains the corresponding service
+ *  \param priority        Priority of the service
+ *  \param service_fptr    Service callback
+ */
+void Srv_Ctor(CService *self, uint8_t priority, void *instance_ptr, Srv_Cb_t service_fptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    Dln_Ctor(&self->list_node, NULL);
+    self->priority = priority;
+    self->instance_ptr = instance_ptr;
+    self->service_fptr = service_fptr;
+}
+
+/*! \brief Sets events for the given service according to the given event mask.
+ *  \param self        Instance pointer
+ *  \param event_mask  Mask of the events to be set
+ */
+void Srv_SetEvent(CService *self, Srv_Event_t event_mask)
+{
+    self->event_mask |= event_mask;
+    if(false == self->scd_ptr->scd_srv_is_running)
+    {
+        Ssub_Notify(&self->scd_ptr->service_request_subject, NULL, false);
+    }
+}
+
+/*! \brief The function returns the current state of all event bits of the service.
+ *  \param self            Instance pointer
+ *  \param event_mask_ptr  Reference to the memory of the returned event mask
+ */
+void Srv_GetEvent(CService *self, Srv_Event_t *event_mask_ptr)
+{
+    *event_mask_ptr = self->event_mask;
+}
+
+/*! \brief Clears events for the given service according to the given event mask.
+ *  \param self       Instance pointer
+ *  \param event_mask Mask of the events to be clear
+ */
+void Srv_ClearEvent(CService *self, Srv_Event_t event_mask)
+{
+    self->event_mask &= ~event_mask;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_scheduler.h b/mnsl/mns_scheduler.h
new file mode 100644
index 0000000..624d0ad
--- /dev/null
+++ b/mnsl/mns_scheduler.h
@@ -0,0 +1,148 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the scheduler module. The module consists of the two classes
+ *        CScheduler and CService.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_SCHEDULER
+ * @{
+ */
+
+#ifndef MNS_SCHEDULER_H
+#define MNS_SCHEDULER_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_dl.h"
+#include "mns_obs.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Type definitions                                                                               */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Function signature used for MNS request callback function */
+typedef void (*Scd_MnsServiceRequest_t)(void);
+/*! \brief Function signature used for service callback functions
+ *  \param self Instance pointer
+ */
+typedef void (*Srv_Cb_t)(void *self);
+/*! \brief Data type of event masks */
+typedef uint32_t Srv_Event_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Definitions                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+extern const Srv_Event_t SRV_EMPTY_EVENT_MASK;  /*!< \brief Empty event mask */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Enumerators                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Standard return values of scheduler module. */
+typedef enum Scd_Ret_
+{
+    SCD_OK,                         /*!< \brief No error */
+    SCD_UNKNOWN_SRV,                /*!< \brief Service is unknown */
+    SCD_SRV_ALREADY_LISTED          /*!< \brief Service is already part of the schedulers list */
+
+} Scd_Ret_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Initialization structure of the scheduler module. */
+typedef struct Scd_InitData_
+{
+    /*! \brief Observer to request a MNS service call */
+    CSingleObserver *service_request_obs_ptr;
+    /*! \brief MOST NetServices instance ID */
+    uint8_t mns_inst_id;
+
+} Scd_InitData_t;
+
+/*! \brief   Class structure of the scheduler. */
+typedef struct CScheduler_
+{
+    /*! \brief Subject to request a MNS service call */
+    CSingleSubject service_request_subject;
+    /*! \brief Service list of the scheduler */
+    CDlList srv_list;
+    /*! \brief Indicates if the scheduler services is running */
+    bool scd_srv_is_running;
+    /*! \brief MOST NetServices instance ID */
+    uint8_t mns_inst_id;
+
+} CScheduler;
+
+/*! \brief   Class structure of services used by the scheduler. */
+typedef struct CService_
+{
+    CDlNode list_node;              /*!< \brief Administration area for the linked list */
+    CScheduler *scd_ptr;            /*!< \brief Back link to scheduler */
+    void *instance_ptr;             /*!< \brief Reference of instance passed to service_fptr() */
+    Srv_Cb_t service_fptr;          /*!< \brief Reference of the service callback function */
+    Srv_Event_t event_mask;         /*!< \brief Event mask of the service */
+    uint8_t priority;               /*!< \brief Priority of the service */
+
+} CService;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CScheduler                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+extern void Scd_Ctor(CScheduler *self, Scd_InitData_t *init_ptr);
+extern void Scd_Service(CScheduler *self);
+extern Scd_Ret_t Scd_AddService(CScheduler *self, CService *srv_ptr);
+extern Scd_Ret_t Scd_RemoveService(CScheduler *self, CService *srv_ptr);
+extern bool Scd_AreEventsPending(CScheduler *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CService                                                                   */
+/*------------------------------------------------------------------------------------------------*/
+extern void Srv_Ctor(CService *self, uint8_t priority, void *instance_ptr, Srv_Cb_t service_fptr);
+extern void Srv_SetEvent(CService *self, Srv_Event_t event_mask);
+extern void Srv_GetEvent(CService *self, Srv_Event_t *event_mask_ptr);
+extern void Srv_ClearEvent(CService *self, Srv_Event_t event_mask);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_SCHEDULER_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_segmentation.c b/mnsl/mns_segmentation.c
new file mode 100644
index 0000000..7bfa2ff
--- /dev/null
+++ b/mnsl/mns_segmentation.c
@@ -0,0 +1,555 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 AMS Segmentation Class
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_AMSSEGM
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_segmentation.h"
+#include "mns_ams.h"
+#include "mns_misc.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+ /*!\brief Timeout for garbage collector */
+static const uint16_t SEGM_GC_TIMEOUT = 5000U;  /* parasoft-suppress  MISRA2004-8_7 "intended usage as configuration parameter" */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal typedefs                                                                              */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static Mns_AmsRx_Msg_t *Segm_RxRetrieveProcessingHandle(CSegmentation *self, Msg_MostTel_t *tel_ptr);
+static void Segm_RxStoreProcessingHandle(CSegmentation *self, Mns_AmsRx_Msg_t *msg_ptr);
+static bool Segm_RxSearchProcessingHandle(void *current_data, void *search_data);
+static bool Segm_RxGcSetLabel(void *current_data, void *search_data);
+static Mns_AmsRx_Msg_t* Segm_RxProcessTelId0(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr);
+static void             Segm_RxProcessTelId1(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr);
+static void             Segm_RxProcessTelId2(CSegmentation *self, Msg_MostTel_t *tel_ptr);
+static Mns_AmsRx_Msg_t* Segm_RxProcessTelId3(CSegmentation *self, Msg_MostTel_t *tel_ptr);
+static void             Segm_RxProcessTelId4(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Initialization methods                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of class CSegmentation
+ *  \param self              The instance
+ *  \param base_ptr          Reference to base services
+ *  \param pool_ptr          Reference to the (Rx) message pool
+ *  \param rx_def_payload_sz Default memory size that is allocated when receiving segmented messages 
+ *                           without size prefix
+ */
+void Segm_Ctor(CSegmentation *self, CBase *base_ptr, CAmsMsgPool *pool_ptr, uint16_t rx_def_payload_sz)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->base_ptr = base_ptr;                  /* initialize members */
+    self->pool_ptr = pool_ptr;
+
+    self->rx_default_payload_sz = rx_def_payload_sz;
+
+    Dl_Ctor(&self->processing_list, self->base_ptr->mns_inst_id);
+    T_Ctor(&self->gc_timer);
+    Tm_SetTimer(&self->base_ptr->tm,            /* start garbage collector timer */
+                &self->gc_timer, 
+                &Segm_RxGcScanProcessingHandles, 
+                self, 
+                SEGM_GC_TIMEOUT, 
+                SEGM_GC_TIMEOUT
+                );
+}
+
+/*! \brief Constructor of class CSegmentation
+ *  \param self           The instance
+ *  \param error_fptr     Reference to segmentation error callback function
+ *  \param error_inst     Reference to segmentation error instance
+ */
+void Segm_AssignRxErrorHandler(CSegmentation *self, Segm_OnError_t error_fptr, void *error_inst)
+{
+    self->error_fptr = error_fptr;
+    self->error_inst = error_inst;
+}
+
+/*! \brief Performs cleanup of pending messages
+ *  \param  self    The instance
+ */
+void Segm_Cleanup(CSegmentation *self)
+{
+    CDlNode *node_ptr = NULL;
+                                                                    /* cleanup Tx queue */
+    for (node_ptr = Dl_PopHead(&self->processing_list); node_ptr != NULL; node_ptr = Dl_PopHead(&self->processing_list))
+    {
+        Mns_AmsRx_Msg_t *rx_ptr = (Mns_AmsRx_Msg_t*)Dln_GetData(node_ptr);
+
+        Amsp_FreeRxPayload(self->pool_ptr, rx_ptr);
+        Amsp_FreeRxObj(self->pool_ptr, rx_ptr);
+    }
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Tx segmentation                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Builds next MOST telegram according to given Application Messages
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the Application Message Tx handle
+ *  \param  tel_ptr Reference to the MOST Telegram handle
+ *  \return Returns \c True if segmentation was completed for the Application Message. Otherwise \c false.
+ */
+bool Segm_TxBuildSegment(CSegmentation *self, Mns_AmsTx_Msg_t* msg_ptr, Msg_MostTel_t *tel_ptr)
+{
+    bool finished = false;
+    MISC_UNUSED(self);
+
+    tel_ptr->destination_addr = msg_ptr->destination_address;
+    tel_ptr->id.fblock_id     = msg_ptr->fblock_id;
+    tel_ptr->id.instance_id   = msg_ptr->instance_id;
+    tel_ptr->id.function_id   = msg_ptr->function_id;
+    tel_ptr->id.op_type       = msg_ptr->op_type;
+    tel_ptr->opts.llrbc       = msg_ptr->llrbc;
+    tel_ptr->info_ptr         = msg_ptr;                            /* info_ptr must carry the reference to AMS Tx message object */
+    tel_ptr->opts.cancel_id   = Amsg_TxGetFollowerId(msg_ptr);
+
+    if (msg_ptr->data_size <= SEGM_MAX_SIZE_TEL)                      /* is single transfer? */
+    {
+        Msg_SetExtPayload((CMessage*)(void*)tel_ptr, msg_ptr->data_ptr, (uint8_t)msg_ptr->data_size, NULL);
+        finished = true;
+    }
+    else                                                            /* is segmented transfer? */
+    {
+        uint16_t next_segm_cnt = Amsg_TxGetNextSegmCnt(msg_ptr);
+
+        if (next_segm_cnt == 0xFFFFU)                               /* first segment: size prefixed segmented message TelId = "4" */
+        {
+            tel_ptr->tel.tel_id = 4U;
+            tel_ptr->tel.tel_data_ptr[0] = MISC_HB(msg_ptr->data_size);
+            tel_ptr->tel.tel_data_ptr[1] = MISC_LB(msg_ptr->data_size);
+            tel_ptr->tel.tel_len = 2U;
+        }
+        else                                                        /* further segments: TelId = "1,2,3" */
+        {
+            uint16_t index = next_segm_cnt * ((uint16_t)SEGM_MAX_SIZE_TEL - 1U);
+            uint16_t remaining_sz = msg_ptr->data_size - index;
+            uint8_t tel_sz = SEGM_MAX_SIZE_TEL - 1U;
+
+            if (remaining_sz < SEGM_MAX_SIZE_TEL)
+            {
+                tel_ptr->tel.tel_id = 3U;                           /* is last segment */
+                tel_sz = (uint8_t)remaining_sz;
+                finished = true;
+            }
+            else
+            {
+                if (0U == index)
+                {
+                    tel_ptr->tel.tel_id = 1U;                       /* is first segment */
+                }
+                else
+                {
+                    tel_ptr->tel.tel_id = 2U;                       /* is subsequent segment */
+                }
+            }
+
+            tel_ptr->tel.tel_cnt = (uint8_t)next_segm_cnt;
+            Msg_SetExtPayload((CMessage*)(void*)tel_ptr, &msg_ptr->data_ptr[index], tel_sz, NULL);
+        }
+
+        Amsg_TxIncrementNextSegmCnt(msg_ptr);
+    }
+
+    return finished;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Rx pools                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Retrieves a processing Rx Application message object to a corresponding MOST telegram
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the MOST telegram
+ *  \return The reference to the corresponding Rx Application Message or \c NULL if no appropriate 
+ *          Rx Application Message is available.
+ */
+static Mns_AmsRx_Msg_t* Segm_RxRetrieveProcessingHandle(CSegmentation *self, Msg_MostTel_t *tel_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+    CDlNode *result_node_ptr = Dl_Foreach(&self->processing_list, &Segm_RxSearchProcessingHandle, tel_ptr);
+
+    if (result_node_ptr != NULL)
+    {
+        Dl_Ret_t ret = Dl_Remove(&self->processing_list, result_node_ptr);
+        TR_ASSERT(self->base_ptr->mns_inst_id, "[SEGM]", (ret == DL_OK));
+        msg_ptr = (Mns_AmsRx_Msg_t*)Dln_GetData(result_node_ptr);
+        MISC_UNUSED(ret);
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Stores a processing Rx Application message object into a dedicated list
+ *  \param  self    The instance
+ *  \param  msg_ptr Reference to the Rx Application Message
+ */
+static void Segm_RxStoreProcessingHandle(CSegmentation *self, Mns_AmsRx_Msg_t *msg_ptr)
+{
+    Amsg_RxSetGcMarker(msg_ptr, false);
+    Amsg_RxEnqueue(msg_ptr, &self->processing_list);        /* insert at tail, since garbage collector starts at head */ 
+}
+
+/*! \brief  Performs garbage collection of outdated message objects
+ *  \param  self    The instance
+ */
+void Segm_RxGcScanProcessingHandles(void *self)
+{
+    CSegmentation *self_ = (CSegmentation*)self;
+                                                                            /* first remove outdated messages */
+    CDlNode *node_ptr = Dl_PeekHead(&self_->processing_list);               /* get first candidate from head */
+
+    while (node_ptr != NULL) 
+    {
+        Mns_AmsRx_Msg_t *msg_ptr = (Mns_AmsRx_Msg_t*)Dln_GetData(node_ptr);
+
+        if (Amsg_RxGetGcMarker(msg_ptr) != false)
+        {
+            Msg_MostTel_t tel;
+
+            Amsg_RxCopySignatureToTel(msg_ptr, &tel);
+            self_->error_fptr(self_->error_inst, &tel, SEGM_ERR_5);
+
+            (void)Dl_Remove(&self_->processing_list, node_ptr);
+
+            Amsp_FreeRxPayload(self_->pool_ptr, msg_ptr);
+            Amsp_FreeRxObj(self_->pool_ptr, msg_ptr);
+
+            node_ptr = Dl_PeekHead(&self_->processing_list);                /* get next candidate from head */
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    (void)Dl_Foreach(&self_->processing_list, &Segm_RxGcSetLabel, NULL);    /* set label of all remaining messages */
+}
+ 
+/*! \brief  Sets garbage collector flags for all list members
+ *  \param  current_data    The Application message object present in list
+ *  \param  search_data     unused (\c NULL)
+ *  \return Returns always false in order to handle all list members */
+static bool Segm_RxGcSetLabel(void *current_data, void *search_data)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = (Mns_AmsRx_Msg_t*)current_data;
+    Amsg_RxSetGcMarker(msg_ptr, true);
+    MISC_UNUSED(search_data);
+    return false;
+}
+
+/*! \brief  Search routine to identify message objects with the same signature
+ *          than a given MOST telegram
+ *  \param  current_data    The Application message object present in list
+ *  \param  search_data     The MOST Telegram object
+ *  \return Returns \c true if both handles have the same functional signature,
+ *          otherwise \c false. */
+static bool Segm_RxSearchProcessingHandle(void *current_data, void *search_data)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = (Mns_AmsRx_Msg_t*)current_data;
+    Msg_MostTel_t *tel_ptr = (Msg_MostTel_t*)search_data;
+
+    return Amsg_RxHandleIsIdentical(msg_ptr, tel_ptr);
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* Rx segmentation                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Processes segmentation for a received MOST telegram
+ *  \param  self        The instance
+ *  \param  tel_ptr     The received MOST telegram
+ *  \param  result_ptr  The result of the segmentation process
+ *  \return The completed Rx Application Message or \c NULL if segmentation process is still
+ *          ongoing.
+ */
+Mns_AmsRx_Msg_t* Segm_RxExecuteSegmentation(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = NULL;
+    *result_ptr = SEGM_RES_OK;
+
+    switch (tel_ptr->tel.tel_id) /* parasoft-suppress  MISRA2004-15_3 "ignore unexpected TelIds" */
+    {
+        case 0U:
+            msg_ptr = Segm_RxProcessTelId0(self, tel_ptr, result_ptr);
+            break;
+        case 1U:
+            Segm_RxProcessTelId1(self, tel_ptr, result_ptr);
+            break;
+        case 2U:
+            Segm_RxProcessTelId2(self, tel_ptr);
+            break;
+        case 3U:
+            msg_ptr = Segm_RxProcessTelId3(self, tel_ptr);
+            break;
+        case 4U:
+            Segm_RxProcessTelId4(self, tel_ptr, result_ptr);
+            break;
+        default:
+            break;
+    }
+
+    return msg_ptr;    /* return completed message */
+}
+
+/*! \brief  Processes segmentation for a received MOST telegram with \c TelId="0"
+ *  \param  self        The instance
+ *  \param  tel_ptr     The received MOST telegram
+ *  \param  result_ptr  Result of segmentation process
+ *  \return The completed Rx Application Message or \c NULL if segmentation process
+ *          does not finish successfully.
+ */
+static Mns_AmsRx_Msg_t* Segm_RxProcessTelId0(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = Segm_RxRetrieveProcessingHandle(self, tel_ptr);
+    *result_ptr = SEGM_RES_OK;
+
+    if (msg_ptr != NULL)                            /* treat error: segmentation process is ongoing */ 
+    {
+        self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_7);
+        Amsp_FreeRxPayload(self->pool_ptr, msg_ptr);/* free assigned user payload and throw segmentation error */
+        Amsp_FreeRxObj(self->pool_ptr, msg_ptr);
+        msg_ptr = NULL;
+    }
+                                                    /* try to allocate handle, memory is NetServices provided (payload <= 45 bytes) */
+    msg_ptr = Amsp_AllocRxObj(self->pool_ptr, (uint16_t)tel_ptr->tel.tel_len);
+
+    if (msg_ptr == NULL)
+    {
+        msg_ptr = Amsp_AllocRxRsvd(self->pool_ptr);
+    }
+
+    if (msg_ptr != NULL)                            /* handle available: setup Rx Application Message */
+    {
+        Amsg_RxCopySignatureFromTel(msg_ptr, tel_ptr);
+
+        if (tel_ptr->tel.tel_len > 0U)
+        {                                           /* copy payload to message */
+            Amsg_RxCopyToPayload(msg_ptr, tel_ptr->tel.tel_data_ptr, tel_ptr->tel.tel_len);
+        }
+        else
+        {                                           /* set payload length to zero */
+            msg_ptr->data_ptr = NULL;
+            msg_ptr->data_size = 0U;
+        }
+    }
+    else
+    {
+        *result_ptr = SEGM_RES_RETRY;               /* retry when next Rx object is released */
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Processes segmentation for a received MOST telegram with \c TelId="1"
+ *  \param  self        The instance
+ *  \param  tel_ptr     The received MOST telegram
+ *  \param  result_ptr  Result of segmentation process
+ */
+static void Segm_RxProcessTelId1(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr)
+{
+    *result_ptr = SEGM_RES_OK;
+
+    if (tel_ptr->tel.tel_cnt != 0U)                             /* handle incorrect tel_cnt */
+    {
+        self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_3);
+    }
+    else                                                        /* tel_cnt is correct -> continue segmentation */
+    {
+        Mns_AmsRx_Msg_t *msg_ptr = Segm_RxRetrieveProcessingHandle(self, tel_ptr);
+        bool is_size_prefixed = false;
+
+        if (msg_ptr != NULL)                                    /* has previous message */
+        {
+            if ((Amsg_RxGetExpTelCnt(msg_ptr) != 0U) || (msg_ptr->data_size > 0U)) 
+            {                                                   /* error: previous message already contains segments */
+                self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_7);
+                Amsp_FreeRxPayload(self->pool_ptr, msg_ptr);
+                Amsg_RxHandleSetup(msg_ptr);                    /* initialize message for re-use */
+            }
+            else                                                /* message and payload had been allocated by TelId '4' */
+            {
+                is_size_prefixed = true;
+            }
+        }
+        else                                                    /* allocate message object if pre-allocation was not initiated by TelId "4" */
+        {
+            msg_ptr = Amsp_AllocRxObj(self->pool_ptr, 0U);
+        }
+
+        if (msg_ptr != NULL)                                    /* now allocate payload */
+        {
+            if (is_size_prefixed == false)
+            {
+                Amsg_RxCopySignatureFromTel(msg_ptr, tel_ptr);  /* save signature and try to allocate */
+                (void)Amsp_AllocRxPayload(self->pool_ptr, self->rx_default_payload_sz, msg_ptr);
+            }
+
+            if (!Amsg_RxHasExternalPayload(msg_ptr))            /* allocation of payload failed */
+            {
+                self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_2);
+                Amsp_FreeRxObj(self->pool_ptr, msg_ptr);
+                msg_ptr = NULL;
+            }
+            else                                                /* allocation of payload succeeded */
+            {
+                (void)Amsg_RxAppendPayload(msg_ptr, tel_ptr);
+                Segm_RxStoreProcessingHandle(self, msg_ptr);
+                msg_ptr = NULL;
+            }
+        }
+        else                                                    /* no message object allocated */
+        {                                                       /* send segmentation error */
+            self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_4);
+        }
+    }
+}
+
+/*! \brief  Processes segmentation for a received MOST telegram with \c TelId="2"
+ *  \param  self    The instance
+ *  \param  tel_ptr The received MOST telegram
+ */
+static void Segm_RxProcessTelId2(CSegmentation *self, Msg_MostTel_t *tel_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = Segm_RxProcessTelId3(self, tel_ptr); /* pretend having TelId '2' but store the */
+                                                                    /* assembled message again */
+    if (msg_ptr != NULL)
+    {
+        Segm_RxStoreProcessingHandle(self, msg_ptr);
+    }
+}
+
+/*! \brief  Processes segmentation for a received MOST telegram with \c TelId="3"
+ *  \param  self    The instance
+ *  \param  tel_ptr The received MOST telegram
+ *  \return The assembled Rx Application Message or \c NULL if segmentation process
+ *          did not process successfully.
+ */
+static Mns_AmsRx_Msg_t* Segm_RxProcessTelId3(CSegmentation *self, Msg_MostTel_t *tel_ptr)
+{
+    Mns_AmsRx_Msg_t *msg_ptr = Segm_RxRetrieveProcessingHandle(self, tel_ptr);
+
+    if (msg_ptr == NULL)                                    /* is first segment missing */
+    {
+        self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_1);
+    }
+    else
+    {
+        uint8_t exp_tel_cnt = Amsg_RxGetExpTelCnt(msg_ptr);
+
+        if ((exp_tel_cnt == 0U) && (msg_ptr->data_size == 0U)) 
+        {                                                   /* error: did not receive first segment */
+            self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_1);
+            Segm_RxStoreProcessingHandle(self, msg_ptr);
+            msg_ptr = NULL;
+        }
+        else if (exp_tel_cnt != tel_ptr->tel.tel_cnt) 
+        {                                                   /* has wrong TelCnt */
+            self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_3);
+            Segm_RxStoreProcessingHandle(self, msg_ptr);
+            msg_ptr = NULL;
+        }
+
+        if (msg_ptr != NULL)
+        {
+            bool succ = Amsg_RxAppendPayload(msg_ptr, tel_ptr);
+
+            if (succ == false)
+            {
+                self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_2);
+                Amsp_FreeRxPayload(self->pool_ptr, msg_ptr);
+                Amsp_FreeRxObj(self->pool_ptr, msg_ptr);
+                msg_ptr = NULL;
+            }
+        }
+    }
+
+    return msg_ptr;
+}
+
+/*! \brief  Processes segmentation for a received MOST telegram with \c TelId="4"
+ *  \param  self        The instance
+ *  \param  tel_ptr     The received MOST telegram
+ *  \param  result_ptr  Result of segmentation process
+ */
+static void Segm_RxProcessTelId4(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr)
+{
+    *result_ptr = SEGM_RES_OK;
+
+    if (tel_ptr->tel.tel_len >= 2U)                         /* telegrams has necessary length */
+    {
+        uint16_t msg_size;
+        MISC_DECODE_WORD(&msg_size, tel_ptr->tel.tel_data_ptr);
+
+        if (msg_size > SEGM_MAX_SIZE_TEL)                     /* application message has correct size */
+        {
+            Mns_AmsRx_Msg_t *msg_ptr = Segm_RxRetrieveProcessingHandle(self, tel_ptr);
+
+            if (msg_ptr != NULL)                            /* treat error: segmentation process is ongoing */
+            {
+                Amsp_FreeRxPayload(self->pool_ptr, msg_ptr);
+                self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_7);
+                Amsg_RxHandleSetup(msg_ptr);                /* initialize message for re-use */
+            }
+            else
+            {                                               /* try to allocate handle, memory is NetServices provided (payload <= 45 bytes) */
+                msg_ptr = Amsp_AllocRxObj(self->pool_ptr, 0U);
+            }
+
+            if (msg_ptr != NULL)                            /* allocation succeeded: decode length and allocate payload */
+            {
+                Amsg_RxCopySignatureFromTel(msg_ptr, tel_ptr);
+                (void)Amsp_AllocRxPayload(self->pool_ptr, msg_size, msg_ptr);
+                Segm_RxStoreProcessingHandle(self, msg_ptr);/* store handle and don't care if payload was allocated or not */
+                msg_ptr = NULL;                             /* segmentation error 2 is treated by TelId 1 */
+            }
+            else
+            {
+                self->error_fptr(self->error_inst, tel_ptr, SEGM_ERR_4);
+            }
+        }
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_segmentation.h b/mnsl/mns_segmentation.h
new file mode 100644
index 0000000..1295be3
--- /dev/null
+++ b/mnsl/mns_segmentation.h
@@ -0,0 +1,146 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of AMS Segmentation Class
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_AMSSEGM
+ * @{
+ */
+
+#ifndef MNS_SEGMENTATION_H
+#define MNS_SEGMENTATION_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+#include "mns_amsmessage.h"
+#include "mns_amspool.h"
+#include "mns_base.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Defines the maximum payload size of a single transfer in bytes */
+#define SEGM_MAX_SIZE_TEL  45U
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Collection of possible segmentation errors */
+typedef enum Segm_Error_
+{
+    SEGM_ERR_1 = 1,     /*!< \brief  The first segment is missing. */
+
+    SEGM_ERR_2 = 2,     /*!< \brief  The device is not able to receive a message of this size.
+                         *           MNS specific: The allocation of user provided payload failed. 
+                         */
+    SEGM_ERR_3 = 3,     /*!< \brief  Unexpected segment number. */
+
+    SEGM_ERR_4 = 4,     /*!< \brief  Too many unfinished segmentation messages were pending. */
+
+    SEGM_ERR_5 = 5,     /*!< \brief  A timeout occurred while waiting for the next segment. */
+
+    SEGM_ERR_6 = 6,     /*!< \brief  The Device is not capable to handle segmented messages.
+                         *           MNS specific: The application did not assign the payload allocation 
+                         *           function in Mns_Ams_InitData_t prior calling Mns_Init().
+                         */
+    SEGM_ERR_7 = 7      /*!< \brief  Segmented message has not been finished before the arrival of 
+                         *           another message with the identical FBlockID, InstID, FktID, and 
+                         *           OPType sent by the same node.
+                         */
+} Segm_Error_t;
+
+/*! \brief Segmentation result */
+typedef enum Segm_Result_
+{
+    SEGM_RES_OK,        /*!< \brief Telegram was processed */
+    SEGM_RES_RETRY      /*!< \brief Telegram shall be processed again as soon as messages are freed to the Rx pool */
+
+} Segm_Result_t;
+
+/*! \brief  Callback function to notify that a segmentation error has occurred
+ *  \param  self    The instance
+ *  \param  tel_ptr The affected telegram
+ *  \param  error   The segmentation error code (1..7)
+ */
+typedef void (*Segm_OnError_t)(void *self, Msg_MostTel_t *tel_ptr, Segm_Error_t error);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief      AMS Segmentation Class
+ *  \details    Performs Tx and Rx Segmentation
+ */
+typedef struct CSegmentation_
+{
+    CBase                       *base_ptr;              /*!< \brief Reference to base services */
+    CAmsMsgPool                 *pool_ptr;              /*!< \brief Reference to object/payload pool */
+
+    Segm_OnError_t               error_fptr;            /*!< \brief Callback function to notify segmentation errors */
+    void                        *error_inst;            /*!< \brief Instance which is notified on segmentation errors */
+
+    CDlList                      processing_list;       /*!< \brief  Segmented and un-finished Rx messages */
+    CTimer                       gc_timer;              /*!< \brief  Timer to trigger the garbage collector */
+    uint16_t                     rx_default_payload_sz; /*!< \brief  Payload size that shall be allocated if size-prefixes
+                                                         *           segmentation message is missing */
+
+} CSegmentation;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Initialization Methods                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+extern void Segm_Ctor(CSegmentation *self, CBase *base_ptr, CAmsMsgPool *pool_ptr, uint16_t rx_def_payload_sz);
+extern void Segm_AssignRxErrorHandler(CSegmentation *self, Segm_OnError_t error_fptr, void *error_inst);
+extern void Segm_Cleanup(CSegmentation *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Public method prototypes                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+extern bool Segm_TxBuildSegment(CSegmentation *self, Mns_AmsTx_Msg_t *msg_ptr, Msg_MostTel_t *tel_ptr);
+extern Mns_AmsRx_Msg_t* Segm_RxExecuteSegmentation(CSegmentation *self, Msg_MostTel_t *tel_ptr, Segm_Result_t *result_ptr);
+extern void Segm_RxGcScanProcessingHandles(void *self);
+
+#ifdef __cplusplus
+}               /* extern "C" */
+#endif
+
+#endif          /* MNS_SEGMENTATION_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_telqueue.c b/mnsl/mns_telqueue.c
new file mode 100644
index 0000000..c250507
--- /dev/null
+++ b/mnsl/mns_telqueue.c
@@ -0,0 +1,119 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 class CTelQueue
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_MSG_QUEUE
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_telqueue.h"
+#include "mns_misc.h"
+ 
+/*------------------------------------------------------------------------------------------------*/
+/* Internal constants                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of class CTelQueue
+ *  \param  self            The instance
+ *  \param  mns_inst_id     MOST NetServices instance id
+ */
+void Telq_Ctor(CTelQueue *self, uint8_t mns_inst_id)
+{
+    self->mns_inst_id = mns_inst_id;
+    Dl_Ctor(&self->list, self->mns_inst_id);
+}
+
+/*! \brief  Retrieves the head object of the telegram queue
+ *  \param  self    The instance
+ *  \return Reference to the telegram if a telegram object is available.
+ *          Otherwise \c NULL.
+ */
+Msg_MostTel_t* Telq_Dequeue(CTelQueue *self)
+{
+    Msg_MostTel_t *tel_ptr = NULL;
+    CDlNode *node_ptr = Dl_PopHead(&self->list);
+ 
+    if (node_ptr != NULL)
+    {
+        tel_ptr = (Msg_MostTel_t*)Dln_GetData(node_ptr);
+    }
+ 
+    return tel_ptr;
+}
+
+/*! \brief  Retrieves a reference to the head object 
+ *          without removing it from the telegram queue
+ *  \param  self    The instance
+ *  \return Reference to the telegram if a telegram object is available.
+ *          Otherwise \c NULL.
+ */
+Msg_MostTel_t* Telq_Peek(CTelQueue *self)
+{
+    Msg_MostTel_t *tel_ptr = NULL;
+    CDlNode *node_ptr = Dl_PeekHead(&self->list);
+ 
+    if (node_ptr != NULL)
+    {
+        tel_ptr = (Msg_MostTel_t*)Dln_GetData(node_ptr);
+    }
+ 
+    return tel_ptr;
+}
+
+/*! \brief  Adds a telegram to the tail of the queue
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the telegram 
+ */
+void Telq_Enqueue(CTelQueue *self, Msg_MostTel_t *tel_ptr)
+{
+    Dl_InsertTail(&self->list, Msg_GetNode((CMessage*)(void*)tel_ptr));
+}
+
+/*! \brief  Retrieves the current number of objects in the telegram queue 
+ *  \param  self    The instance
+ *  \return The current number of available telegram objects in the pool
+ */
+uint8_t Telq_GetSize(CTelQueue *self)
+{
+    return (uint8_t)Dl_GetSize(&self->list);
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_telqueue.h b/mnsl/mns_telqueue.h
new file mode 100644
index 0000000..2a86387
--- /dev/null
+++ b/mnsl/mns_telqueue.h
@@ -0,0 +1,93 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of class CTelQueue
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_MSG_QUEUE
+ * @{
+ */
+
+#ifndef MNS_MSGQUEUE_H
+#define MNS_MSGQUEUE_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+#include "mns_dl.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class CTelQueue                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Class CTelQueue 
+ *  \details Internal class to queue MOST telegrams
+ */
+typedef struct CTelQueue_
+{
+    CDlList     list;           /*! \brief  Doubly linked list */
+    uint8_t     mns_inst_id;    /*! \brief  MOST NetServices instance ID */
+
+} CTelQueue;
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Methods                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+extern void Telq_Ctor(CTelQueue *self, uint8_t mns_inst_id);
+extern Msg_MostTel_t* Telq_Dequeue(CTelQueue *self);
+extern Msg_MostTel_t* Telq_Peek(CTelQueue *self);
+extern void Telq_Enqueue(CTelQueue *self, Msg_MostTel_t *tel_ptr);
+extern uint8_t Telq_GetSize(CTelQueue *self);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_MSGQUEUE_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_timer.c b/mnsl/mns_timer.c
new file mode 100644
index 0000000..c28d32b
--- /dev/null
+++ b/mnsl/mns_timer.c
@@ -0,0 +1,454 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 the timer management module.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_TIMER
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_timer.h"
+#include "mns_misc.h"
+#include "mns_trace.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Service parameters                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! Priority of the TM service used by scheduler */
+static const uint8_t TM_SRV_PRIO = 255U;    /* parasoft-suppress  MISRA2004-8_7 "Value shall be part of the module, not part of a function." */
+/*! Main event for the TM service */
+static const Srv_Event_t TM_EVENT_UPDATE_TIMERS = 1U;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Tm_Service(void *self);
+static void Tm_UpdateTimers(CTimerManagement *self);
+static bool Tm_HandleElapsedTimer(CTimerManagement *self);
+static bool Tm_UpdateTimersAdd(void *c_timer_ptr, void *n_timer_ptr);
+static void Tm_SetTimerInternal(CTimerManagement *self,
+                                CTimer *timer_ptr,
+                                Tm_Handler_t handler_fptr,
+                                void *args_ptr,
+                                uint16_t elapse,
+                                uint16_t period);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CTimerManagement                                                       */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the timer management class.
+ *  \param self        Instance pointer
+ *  \param scd         Scheduler instance
+ *  \param init_ptr    Reference to the initialization data
+ */
+void Tm_Ctor(CTimerManagement *self, CScheduler *scd, const Tm_InitData_t *init_ptr)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->mns_inst_id = init_ptr->mns_inst_id;
+    /* Initialize subjects and add observers */
+    Ssub_Ctor(&self->get_tick_count_subject, self->mns_inst_id);
+    (void)Ssub_AddObserver(&self->get_tick_count_subject,
+                           init_ptr->get_tick_count_obs_ptr);
+    if(init_ptr->set_application_timer_obs_ptr != NULL)
+    {
+        self->delayed_tm_service_enabled = true;
+        Ssub_Ctor(&self->set_application_timer_subject, self->mns_inst_id);
+        (void)Ssub_AddObserver(&self->set_application_timer_subject,
+                               init_ptr->set_application_timer_obs_ptr);
+    }
+    /* Initialize timer management service */
+    Srv_Ctor(&self->tm_srv, TM_SRV_PRIO, self, &Tm_Service);
+    /* Add timer management service to scheduler */
+    (void)Scd_AddService(scd, &self->tm_srv);
+}
+
+/*! \brief Service function of the timer management.
+ *  \param self    Instance pointer
+ */
+static void Tm_Service(void *self)
+{
+    CTimerManagement *self_ = (CTimerManagement *)self;
+    Srv_Event_t event_mask;
+
+    Srv_GetEvent(&self_->tm_srv, &event_mask);
+
+    if(TM_EVENT_UPDATE_TIMERS == (event_mask & TM_EVENT_UPDATE_TIMERS))     /* Is event pending? */
+    {
+        Srv_ClearEvent(&self_->tm_srv, TM_EVENT_UPDATE_TIMERS);
+        Tm_UpdateTimers(self_); 
+    }
+}
+
+/*! \brief If event TM_EVENT_UPDATE_TIMERS is set this function is called. Handles the update
+ *         of the timer list. If a timer has expired the corresponding callback function is
+ *         executed. If the expired timer is a periodic timer, the timer will be set again.
+ *  \param self    Instance pointer
+ */
+static void Tm_UpdateTimers(CTimerManagement *self)
+{
+    uint16_t current_tick_count;
+    Ssub_Notify(&self->get_tick_count_subject, &current_tick_count, false);
+
+    if(self->timer_list.head != NULL)      /* At least one timer is running? */
+    {
+        bool continue_loop = true;
+        /* Calculate time difference between the current and the last TM service run */
+        uint16_t tick_count_diff = (uint16_t)(current_tick_count - self->last_tick_count);
+        /* Save current tick count for next service run */
+        self->last_tick_count = current_tick_count;
+
+        /* Loop while timer list is not empty */
+        while((self->timer_list.head != NULL) && (continue_loop!= false))
+        {
+            /* Is not first timer in list elapsed yet? */
+            if(tick_count_diff <= ((CTimer *)self->timer_list.head->data_ptr)->delta)
+            {
+                /* Update delta of first timer in list */
+                ((CTimer *)self->timer_list.head->data_ptr)->delta -= tick_count_diff;
+                tick_count_diff = 0U;
+            }
+            else    /* At least first timer in list elapsed */
+            {
+                /* Update tick count difference for next timer in list */
+                tick_count_diff -= ((CTimer *)self->timer_list.head->data_ptr)->delta;
+                /* First timer elapsed */
+                ((CTimer *)self->timer_list.head->data_ptr)->delta = 0U;
+            }
+
+            /* First timer in list elapsed? */
+            if(0U == ((CTimer *)self->timer_list.head->data_ptr)->delta)
+            {
+                /* Handle elapsed timer */
+                continue_loop = Tm_HandleElapsedTimer(self);
+            }
+            else    /* No elapsed timer in list. */
+            {
+                /* First timer in list updated! Set trigger to inform application (see 
+                   Tm_CheckForNextService()) and stop TM service. */
+                self->set_service_timer = true;
+                continue_loop = false;
+            }
+        }
+    }
+}
+
+/*! \brief  This function is called if the first timer in list is elapsed. The timer handler 
+ *          callback function is invoked. If the timer is a periodic timer it is wound up again.
+ *  \param  self    Instance pointer
+ *  \return \c true if the next timer must be check.
+ *  \return \c false if the wound up timer (periodic timer) is new head of timer list
+ */
+static bool Tm_HandleElapsedTimer(CTimerManagement *self)
+{
+    bool ret_val = true;
+
+    CDlNode *node = self->timer_list.head;
+    /* Reset flag to be able to check if timer object has changed within handler 
+        callback function */
+    ((CTimer *)node->data_ptr)->changed = false;
+    /* Call timer handler callback function */
+    ((CTimer *)node->data_ptr)->handler_fptr(((CTimer *)node->data_ptr)->args_ptr);
+
+    /* Timer object hasn't changed within handler callback function? */
+    if(false == ((CTimer *)node->data_ptr)->changed)
+    {
+        /* Remove current timer from list */
+        (void)Dl_Remove(&self->timer_list, node);
+        /* Mark timer as unused */
+        ((CTimer *)node->data_ptr)->in_use = false;
+        /* Is current timer a periodic timer? */
+        if(((CTimer *)node->data_ptr)->period > 0U)
+        {
+            /* Reload current timer */
+            Tm_SetTimerInternal(self,
+                                ((CTimer *)node->data_ptr),
+                                ((CTimer *)node->data_ptr)->handler_fptr,
+                                ((CTimer *)node->data_ptr)->args_ptr,
+                                ((CTimer *)node->data_ptr)->period,
+                                ((CTimer *)node->data_ptr)->period);
+
+            if(node == self->timer_list.head)  /* Is current timer new head of list? */
+            {
+                /* Set trigger to inform application (see Tm_CheckForNextService()) and
+                   stop TM service. */
+                self->set_service_timer = true;
+                ret_val = false;
+            }
+        }
+    }
+
+    return ret_val;
+}
+
+/*! \brief Calls an application callback function to inform the application that the MNS must be 
+ *         serviced not later than the passed time period. If the timer list is empty a possible
+ *         running application timer will be stopped. This function is called at the end of
+ *         Mns_Service().
+ *  \param self    Instance pointer
+ */
+void Tm_CheckForNextService(CTimerManagement *self)
+{
+    if(self->delayed_tm_service_enabled != false)
+    {
+        uint16_t current_tick_count;
+        Ssub_Notify(&self->get_tick_count_subject, &current_tick_count, false);
+        /* Has head of timer list changed? */
+        if(self->set_service_timer != false)
+        {
+            uint16_t new_time;
+            uint16_t diff = current_tick_count - self->last_tick_count;
+            self->set_service_timer = false;
+            /* Timer expired since last TM service? */
+            if(diff >= ((CTimer *)self->timer_list.head->data_ptr)->delta)
+            {
+                new_time = 1U;  /* Return minimum value */
+            }
+            else
+            {
+                /* Calculate new timeout */
+                new_time = (uint16_t)(((CTimer *)self->timer_list.head->data_ptr)->delta - diff);
+            }
+            /* Inform the application that the MNS must be serviced not later than the passed
+               time period. */
+            Ssub_Notify(&self->set_application_timer_subject, &new_time, false);
+        }
+    }
+    else
+    {
+        Tm_TriggerService(self);    /* Application timer not implemented -> Retrigger TM */
+    }
+}
+
+/*! \brief Helper function to set the TM service event.
+ *  \details  This function is used by the application to trigger a service call of the Timer 
+ *            Management if the application timer has expired.
+ *  \param self            Instance pointer
+ */
+void Tm_TriggerService(CTimerManagement *self)
+{
+    if(self->timer_list.head != NULL)      /* At least one timer is running? */
+    {
+        Srv_SetEvent(&self->tm_srv, TM_EVENT_UPDATE_TIMERS);
+    }
+}
+
+/*! \brief Helper function to stop the TM service.
+ *  \param self            Instance pointer
+ */
+void Tm_StopService(CTimerManagement *self)
+{
+    uint16_t new_time = 0U;
+
+    /* Clear probable running application timer */
+    Ssub_Notify(&self->set_application_timer_subject, &new_time, false);
+
+    /* Reset the service timer. Not necessary ?  */
+    self->set_service_timer = false;
+
+    /* Clear the timer head queue to prevent any event to be set */
+    self->timer_list.head = NULL;
+}
+
+/*! \brief Creates a new timer. The timer expires at the specified elapse time and then after 
+ *         every specified period. When the timer expires the specified callback function is
+ *         called.
+ *  \param self            Instance pointer
+ *  \param timer_ptr       Reference to the timer object
+ *  \param handler_fptr    Callback function which is called when the timer expires
+ *  \param args_ptr        Reference to an optional parameter which is passed to the specified
+ *                         callback function
+ *  \param elapse          The elapse value before the timer expires for the first time, in
+ *                         milliseconds
+ *  \param period          The period of the timer, in milliseconds. If this parameter is zero, the
+ *                         timer is signaled once. If the parameter is greater than zero, the timer
+ *                         is periodic.
+ */
+void Tm_SetTimer(CTimerManagement *self,
+                 CTimer *timer_ptr,
+                 Tm_Handler_t handler_fptr,
+                 void *args_ptr,
+                 uint16_t elapse,
+                 uint16_t period)
+{
+    (void)Tm_ClearTimer(self, timer_ptr);       /* Clear timer if running */
+    /* Call the internal method to set the new timer (-> does not trigger TM service!) */
+    Tm_SetTimerInternal(self, timer_ptr, handler_fptr, args_ptr, elapse, period);
+    Tm_TriggerService(self);                    /* New timer added -> trigger timer list update */
+}
+
+/*! \brief This function contains the internal part when adding a new timer. The function is
+ *         called within Tm_SetTimer() and within Tm_UpdateTimers().
+ *  \param self            Instance pointer
+ *  \param timer_ptr       Reference to the timer object
+ *  \param handler_fptr    Callback function which is called when the timer expires
+ *  \param args_ptr        Reference to an optional parameter which is passed to the specified
+ *                         callback function
+ *  \param elapse          The elapse value before the timer expires for the first time, in
+ *                         milliseconds
+ *  \param period          The period of the timer, in milliseconds. If this parameter is zero, the
+ *                         timer is signaled once. If the parameter is greater than zero, the timer
+ *                         is periodic.
+ */
+static void Tm_SetTimerInternal(CTimerManagement *self,
+                                CTimer *timer_ptr,
+                                Tm_Handler_t handler_fptr,
+                                void *args_ptr,
+                                uint16_t elapse,
+                                uint16_t period)
+{
+    uint16_t current_tick_count;
+    Ssub_Notify(&self->get_tick_count_subject, &current_tick_count, false);
+ 
+    /* Save timer specific values */
+    timer_ptr->changed = true;                  /* Flag is needed by Tm_UpdateTimers() */
+    timer_ptr->in_use = true;
+    timer_ptr->handler_fptr = handler_fptr;
+    timer_ptr->args_ptr = args_ptr;
+    timer_ptr->elapse = elapse;
+    timer_ptr->period = period;
+    timer_ptr->delta = elapse;
+
+    /* Create back link to be able to point from node to timer object */
+    timer_ptr->node.data_ptr = (void *)timer_ptr;
+
+    if(NULL == self->timer_list.head)           /* Is timer list empty? */
+    {
+        Dl_InsertHead(&self->timer_list, &timer_ptr->node);    /* Add first timer to list */
+        /* Save current tick count */
+        Ssub_Notify(&self->get_tick_count_subject, &self->last_tick_count, false);
+    }
+    else                                        /* Timer list is not empty */
+    {
+        CDlNode *result_ptr = NULL;
+
+        /* Set delta value in relation to last saved tick count (last TM service) */
+        timer_ptr->delta += (uint16_t)(current_tick_count - self->last_tick_count);
+
+        /* Search slot where new timer must be inserted. Update delta of new timer
+           and delta of the following timer in the list. */
+        result_ptr = Dl_Foreach(&self->timer_list, &Tm_UpdateTimersAdd, (void *)timer_ptr);
+ 
+        if(NULL != result_ptr)                  /* Slot found? */
+        {
+            /* Insert new timer at found position */
+            Dl_InsertBefore(&self->timer_list, result_ptr, &timer_ptr->node);
+        }
+        else                                    /* No slot found -> Insert as last node */
+        {
+            /* Add new timer to end of list */
+            Dl_InsertTail(&self->timer_list, &timer_ptr->node);
+        }
+    }
+}
+
+/*! \brief     Removes the specified timer from the timer list.
+ *  \param     self        Instance pointer
+ *  \param     timer_ptr   Reference to the timer object
+ *  \attention Make sure that for a timer object Tm_SetTimer() is called before Tm_ClearTimer()
+ *             is called!
+ */
+void Tm_ClearTimer(CTimerManagement *self, CTimer *timer_ptr)
+{
+    if(timer_ptr->in_use != false)          /* Is timer currently in use? */
+    {
+        timer_ptr->changed = true;          /* Flag is needed by Tm_UpdateTimers() */
+
+        if(NULL != timer_ptr->node.next)    /* Has deleted timer a follower? */
+        {
+            /* Adjust delta of following timer */
+            ((CTimer *)timer_ptr->node.next->data_ptr)->delta += timer_ptr->delta;
+        }
+
+        (void)Dl_Remove(&self->timer_list, &timer_ptr->node);
+        timer_ptr->in_use = false;
+
+        Tm_TriggerService(self);            /* Timer removed -> trigger timer list update */
+    }
+}
+
+/*! \brief  Used by Tm_SetTimer() to find the slot where the new timer must be inserted.
+ *  \param  c_timer_ptr Reference to current timer processed by foreach loop
+ *  \param  n_timer_ptr Reference to new timer
+ *  \return \c true: Slot found, stop foreach loop
+ *  \return \c false: Slot not found, continue foreach loop
+ */
+static bool Tm_UpdateTimersAdd(void *c_timer_ptr, void *n_timer_ptr)
+{
+    CTimer *current_timer_ptr = (CTimer *)c_timer_ptr;
+    CTimer *new_timer_ptr = (CTimer *)n_timer_ptr;
+    bool ret_val;
+
+    /* Is current timer lesser than new timer? */
+    if(current_timer_ptr->delta <= new_timer_ptr->delta)
+    {
+        /* Update delta of new timer and continue foreach loop */
+        new_timer_ptr->delta -= current_timer_ptr->delta;
+        ret_val = false;
+    }
+    else                                                    /* Slot found! */
+    {
+        /* Correct delta of current timer and stop foreach loop */
+        current_timer_ptr->delta -= new_timer_ptr->delta;
+        ret_val = true;
+    }
+
+    return ret_val;
+}
+
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CTimer                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Constructor of the Timer class.
+ *  \param self        Instance pointer
+ */
+void T_Ctor(CTimer *self)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+}
+
+/*! \brief  Returns the status of the given timer.
+ *  \param  self        Instance pointer
+ *  \return \c true if the timer is currently in use
+ *  \return \c false if the timer is not currently in use
+ */
+bool T_IsTimerInUse(CTimer *self)
+{
+    return self->in_use;
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_timer.h b/mnsl/mns_timer.h
new file mode 100644
index 0000000..9e5c02a
--- /dev/null
+++ b/mnsl/mns_timer.h
@@ -0,0 +1,146 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the timer management module.
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup G_TIMER
+ * @{
+ */
+
+#ifndef MNS_TIMER_H
+#define MNS_TIMER_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_cfg.h"
+#include "mns_dl.h"
+#include "mns_scheduler.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Function signature used for timer handler 
+ *  \param args Void pointer to optional data
+ */
+typedef void (*Tm_Handler_t)(void *args);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Structures                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Initialization structure of the timer management module. */
+typedef struct Tm_InitData_
+{
+    /*! \brief Observer used to request current tick count value */
+    CSingleObserver *get_tick_count_obs_ptr;
+    /*! \brief Observer used to start application timer for delayed TM service calls */
+    CSingleObserver *set_application_timer_obs_ptr;
+    /*! \brief MOST NetServices instance ID */
+    uint8_t mns_inst_id;
+
+} Tm_InitData_t;
+
+/*! \brief   Class structure of the a timer object. */
+typedef struct CTimer_
+{
+    /*! \brief Node of the doubly linked (timer-) list */
+    CDlNode node;
+    /*! \brief Handler function which is invoked when the timer expires */
+    Tm_Handler_t handler_fptr;
+    /*! \brief Reference to optional parameter */
+    void *args_ptr;
+    /*! \brief The Timeout value before the timer expires for the first time, in milliseconds */
+    uint16_t elapse;
+    /*! \brief The period of the timer, in milliseconds */
+    uint16_t period;
+    /*! \brief Delta time related to next timer in list */
+    uint16_t delta;
+    /*! \brief Flag which signals that the timer is in use */
+    bool in_use;
+    /*! \brief Flag to check if timer object has changed within timer handler callback function */
+    bool changed;
+
+} CTimer;
+
+/*! \brief   Class structure of the timer management */
+typedef struct CTimerManagement_
+{
+    /*! \brief Doubly linked list to manage the active timers */
+    CDlList timer_list;
+    /*! \brief Subject to request current tick count */
+    CSingleSubject get_tick_count_subject;
+    /*! \brief Subject to start the application timer which triggers a MNS service call */
+    CSingleSubject set_application_timer_subject;
+    /*! \brief Service instance to add the timer management to the scheduler */
+    CService tm_srv;
+    /*! \brief Last tick count value (saved at TM service) */
+    uint16_t last_tick_count;
+    /*! \brief Signals that the application timer callbacks are used */
+    bool delayed_tm_service_enabled;
+    /*! \brief Indicates that the application timer must be started */
+    bool set_service_timer;
+    /*! \brief MOST NetServices instance ID */
+    uint8_t mns_inst_id;
+
+} CTimerManagement;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CTimerManagement                                                           */
+/*------------------------------------------------------------------------------------------------*/
+extern void Tm_Ctor(CTimerManagement *self, CScheduler *scd, const Tm_InitData_t *init_ptr);
+extern void Tm_SetTimer(CTimerManagement *self, CTimer *timer_ptr, Tm_Handler_t handler_fptr, 
+                        void *args_ptr, uint16_t elapse, uint16_t period);
+extern void Tm_ClearTimer(CTimerManagement *self, CTimer *timer_ptr);
+extern void Tm_CheckForNextService(CTimerManagement *self);
+extern void Tm_TriggerService(CTimerManagement *self);
+extern void Tm_StopService(CTimerManagement *self);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes of class CTimer                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+extern void T_Ctor(CTimer *self);
+extern bool T_IsTimerInUse(CTimer *self);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNS_TIMER_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_trace.h b/mnsl/mns_trace.h
new file mode 100644
index 0000000..7ef4758
--- /dev/null
+++ b/mnsl/mns_trace.h
@@ -0,0 +1,87 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Internal header file of the trace interface
+ */
+
+#ifndef MNSL_TRACE_H
+#define MNSL_TRACE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Unit and entry ids                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+#define TR_MNSL_ASSERT             "ASSERT failed in line %d"
+#define TR_MNSL_INIC_RESULT_ID_1   "INIC error data:"
+#define TR_MNSL_INIC_RESULT_ID_2   "--> Data[%u]: 0x%02X"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal macros                                                                                */
+/*------------------------------------------------------------------------------------------------*/
+
+/* parasoft suppress MISRA2004-19_7 MISRA2004-19_4 reason "function-like macros are allowed for tracing" */
+#ifdef MNS_TR_ERROR
+#   define TR_ERROR(args) MNS_TR_ERROR args;
+#   define TR_FAILED_ASSERT(mns_inst_id, unit) TR_ERROR(((mns_inst_id), (unit), TR_MNSL_ASSERT, 1U, __LINE__))
+#   define TR_ASSERT(mns_inst_id, unit, expr)  if (!(expr)) {TR_FAILED_ASSERT((mns_inst_id), (unit));}
+#   define TR_ERROR_INIC_RESULT(mns_inst_id, unit, info_ptr, info_size)                                  \
+            {                                                                                       \
+                uint8_t i;                                                                          \
+                TR_ERROR(((mns_inst_id), (unit), TR_MNSL_INIC_RESULT_ID_1, 0U));                    \
+                for(i=0U; i<info_size; i++)                                                              \
+                {                                                                                   \
+                    TR_ERROR(((mns_inst_id), (unit), TR_MNSL_INIC_RESULT_ID_2, 2U, i, info_ptr[i])) \
+                }                                                                                   \
+            }
+#else
+#   define MNS_TR_ERROR
+#   define TR_ERROR(args)
+#   define TR_FAILED_ASSERT(mns_inst_id, unit)
+#   define TR_ASSERT(mns_inst_id, unit, expr)
+#   define TR_ERROR_INIC_RESULT(mns_inst_id, unit, info_ptr, info_size)
+#endif
+
+#ifdef MNS_TR_INFO
+#   define TR_INFO(args) MNS_TR_INFO args;
+#else
+#   define MNS_TR_INFO
+#   define TR_INFO(args)
+#endif
+/* parasoft unsuppress item MISRA2004-19_7 item MISRA2004-19_4 reason "function-like macros are allowed for tracing" */
+
+#ifdef __cplusplus
+}       /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNSL_TRACE_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_transceiver.c b/mnsl/mns_transceiver.c
new file mode 100644
index 0000000..ed5e3af
--- /dev/null
+++ b/mnsl/mns_transceiver.c
@@ -0,0 +1,292 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 class CTransceiver
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_TRCV
+ * @{
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_transceiver.h"
+#include "mns_misc.h"
+#include "mns_pmp.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Trcv_OnTxStatusInternal(void *self, Msg_MostTel_t *tel_ptr, Mns_MsgTxStatus_t status);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation                                                                                 */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief  Constructor of class CTransceiver
+ *  \param  self        The instance
+ *  \param  fifo_ptr    Reference to the dedicated port message FIFO
+ *  \param  def_src_addr Source address that is preset in Tx message object
+ *  \param  mns_inst_id MOST NetServices instance ID
+ *  \param  trace_id     ID specifies FIFO in traces if multiple transceivers are running
+ */
+void Trcv_Ctor(CTransceiver *self, CPmFifo *fifo_ptr, uint16_t def_src_addr, uint8_t mns_inst_id, uint8_t trace_id)
+{
+    MISC_MEM_SET(self, 0, sizeof(*self));
+    self->fifo_ptr = fifo_ptr;
+    self->tx_def_src = def_src_addr;
+    self->mns_inst_id = mns_inst_id;
+    self->own_id = trace_id;
+    Pool_Ctor(&self->tx_msg_pool, self->tx_msgs, TRCV_SIZE_TX_POOL, mns_inst_id);
+    TR_ASSERT(self->mns_inst_id, "[TRCV]", (fifo_ptr != NULL));
+}
+
+/*! \brief   Assigns a function of another class to receive messages
+ *  \details The assigned function is responsible to call Trcv_RxReleaseMsg() it has finished to process it
+ *  \param   self            The instance
+ *  \param   callback_fptr   Callback function
+ *  \param   inst_ptr        The instance of the receiver class
+ */
+void Trcv_RxAssignReceiver(CTransceiver *self, Trcv_RxCompleteCb_t callback_fptr, void *inst_ptr)
+{
+    self->rx_complete_fptr = callback_fptr;
+    self->rx_complete_inst = inst_ptr;
+}
+
+/*! \brief   Assigns a function of another class to filter Rx messages
+ *  \details The assigned function is responsible to discard or pass Rx messages
+ *  \param   self            The instance
+ *  \param   callback_fptr   Callback function
+ *  \param   inst_ptr        The instance of the filter class
+ */
+void Trcv_RxAssignFilter(CTransceiver *self, Trcv_RxFilterCb_t callback_fptr, void *inst_ptr)
+{
+    self->rx_filter_fptr = callback_fptr;
+    self->rx_filter_inst = inst_ptr;
+}
+
+/*! \brief  Releases an Rx message which was received by the assigned receiver
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the received message
+ */
+void Trcv_RxReleaseMsg(CTransceiver *self, Msg_MostTel_t *tel_ptr)
+{
+    CMessage *msg_ptr = (CMessage*)(void*)tel_ptr;
+    bool check_ok = !Dln_IsNodePartOfAList(Msg_GetNode(msg_ptr));   /* message object shall not be part of a list */
+                                                                    /* because it was provided in an earlier step */
+    TR_ASSERT(self->mns_inst_id, "[TRCV]", check_ok);
+    if (check_ok)
+    {
+        Fifo_RxReleaseMsg(self->fifo_ptr, msg_ptr);
+    }
+}
+
+/*! \brief  Retrieves a message object from the pool
+ *  \param  self    The instance
+ *  \param  size    Size of the message in bytes. Valid range: 0..45.
+ *  \return Reference to the Msg_MostTel_t structure if a message is available.
+ *          Otherwise \c NULL.
+ */
+extern Msg_MostTel_t* Trcv_TxAllocateMsg(CTransceiver *self, uint8_t size)
+{
+    const uint8_t TRCV_CTRL_MAX_SIZE = 45U;         /* replace by PMS constant in future */
+    CMessage        *handle = NULL;
+    Msg_MostTel_t   *tel_ptr = NULL;
+
+    if (size <= TRCV_CTRL_MAX_SIZE)
+    {
+        handle = Pool_GetMsg(&self->tx_msg_pool);
+
+        if (handle != NULL)
+        {
+            Msg_Cleanup(handle);                   /* reset headers and fields */
+            Msg_ReserveHeader(handle, PMP_PM_MAX_SIZE_HEADER + ENC_MAX_SIZE_CONTENT);
+            tel_ptr = Msg_GetMostTel(handle);      /* return public struct of the message object */
+            tel_ptr->tel.tel_id = 0U;
+            tel_ptr->tel.tel_len = size;
+            tel_ptr->tel.tel_cnt = 0U;
+            tel_ptr->source_addr = self->tx_def_src;
+        }
+    }
+
+    return tel_ptr;
+}
+
+/*! \brief  Returns a message object to the transceiver pool a message was allocated from
+ *  \param  tel_ptr Reference to the message object which needs to be returned. 
+ */
+void Trcv_TxReleaseMsg(Msg_MostTel_t *tel_ptr)
+{
+    CMessage* msg_ptr = (CMessage*)(void*)tel_ptr;                  /* avoid MISRA-C warning by converting to "void*" */
+    bool check_ok = !Dln_IsNodePartOfAList(Msg_GetNode(msg_ptr));   /* message object shall not be part of a list */
+    TR_ASSERT(0U, "[TRCV]", check_ok);                              /* because it was provided in an earlier step */
+
+    if (check_ok)
+    {
+        Pool_ReturnMsg(msg_ptr);
+    }
+}
+
+/*! \brief  Prepares a message object for re-transmission
+ *  \param  tel_ptr Reference to the Tx message object which needs
+ *                  to be reused. 
+ */
+void Trcv_TxReuseMsg(Msg_MostTel_t *tel_ptr)
+{
+    CMessage* msg_ptr = (CMessage*)(void*)tel_ptr; 
+    TR_ASSERT(0U, "[TRCV]", (!Dln_IsNodePartOfAList(Msg_GetNode(msg_ptr)))); /* message object shall not be part of a list */
+                                                                             /* because it was provided in an earlier step */
+    Msg_Cleanup(msg_ptr);        /* reset headers and fields */
+    Msg_ReserveHeader(msg_ptr, PMP_PM_MAX_SIZE_HEADER + ENC_MAX_SIZE_CONTENT);
+}
+
+/*! \brief  Transmits a given message object to the INIC
+ *  \details After completed transmission the message object is released automatically
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the message object
+ */
+void Trcv_TxSendMsg(CTransceiver *self, Msg_MostTel_t *tel_ptr)
+{
+    CMessage *msg_ptr; 
+
+    TR_ASSERT(self->mns_inst_id, "[TRCV]", (tel_ptr != NULL));
+    msg_ptr = (CMessage*)(void*)tel_ptr;
+
+    TR_INFO((self->mns_inst_id, "[TRCV]", "Trcv_TxSendMsg(): FIFO: %u, MSG(tgt:0x%04X, id:%02X.%01X.%04X.%01X)", 6U, self->own_id, tel_ptr->destination_addr, tel_ptr->id.fblock_id, tel_ptr->id.instance_id, tel_ptr->id.function_id, tel_ptr->id.op_type));
+    Msg_SetTxStatusHandler(msg_ptr, &Trcv_OnTxStatusInternal, self);        /* just release the message */
+    Fifo_Tx(self->fifo_ptr, msg_ptr, false);
+}
+
+/*! \brief  Transmits a given message object to the INIC with a dedicated result callback 
+ *  \param  self          The instance
+ *  \param  tel_ptr       Reference to the message object
+ *  \param  callback_fptr Callback function which is invoked after message transmission has finished.
+ *                        Must be \c NULL to avoid that a callback function is invoked. In this case
+ *                        the message object is freed internally. Hence, the message object must 
+ *                        not provide external payload.
+ *  \param  inst_ptr      Reference to the instance which is invoked with callback_fptr. Has to be \c 
+ *                        NULL if callback_fptr is \c NULL.
+ *  \note   The provided callback function is responsible to free the message object by calling 
+ *          Trcv_TxReleaseMsg() or to reuse the message object by calling Trcv_TxReuseMsg() before
+ *          passing it to one of the transmit functions again.
+ */
+void Trcv_TxSendMsgExt(CTransceiver *self, Msg_MostTel_t *tel_ptr, Msg_TxStatusCb_t callback_fptr, void *inst_ptr)
+{
+    CMessage *msg_ptr; 
+
+    TR_ASSERT(self->mns_inst_id, "[TRCV]", (tel_ptr != NULL));
+    msg_ptr = (CMessage*)(void*)tel_ptr;
+
+    if (callback_fptr == NULL)
+    {
+        TR_ASSERT(self->mns_inst_id, "[TRCV]", (inst_ptr == NULL));
+        callback_fptr = &Trcv_OnTxStatusInternal;
+        inst_ptr = self;
+    }
+
+    TR_INFO((self->mns_inst_id, "[TRCV]", "Trcv_TxSendMsgExt(): FIFO: %u, MSG(tgt:0x%04X, id:%02X.%01X.%04X.%01X)", 6U, self->own_id, tel_ptr->destination_addr, tel_ptr->id.fblock_id, tel_ptr->id.instance_id, tel_ptr->id.function_id, tel_ptr->id.op_type));
+    Msg_SetTxStatusHandler(msg_ptr, callback_fptr, inst_ptr);
+    Fifo_Tx(self->fifo_ptr, msg_ptr, false);
+}
+
+/*! \brief  Transmits a given message object to the INIC bypassing all other messages in the FIFO
+ *  \param  self          The instance
+ *  \param  tel_ptr       Reference to the message object
+ *  \param  callback_fptr Callback function which is invoked after message transmission has finished.
+ *                        Must be \c NULL to avoid that a callback function is invoked. In this case
+ *                        the message object is freed internally. Hence, the message object must 
+ *                        not provide external payload.
+ *  \param  inst_ptr      Reference to the instance which is invoked
+ *  \note   The provided callback function is responsible to free the message object by calling 
+ *          Trcv_TxReleaseMsg() or to reuse the message object by calling Trcv_TxReuseMsg() before
+ *          passing it to one of the transmit functions again.
+ */
+void Trcv_TxSendMsgBypass(CTransceiver *self, Msg_MostTel_t *tel_ptr, Msg_TxStatusCb_t callback_fptr, void *inst_ptr)
+{
+    CMessage *msg_ptr;
+
+    TR_ASSERT(self->mns_inst_id, "[TRCV]", (tel_ptr != NULL));
+    msg_ptr = (CMessage*)(void*)tel_ptr;
+
+    if (callback_fptr == NULL)
+    {
+        TR_ASSERT(self->mns_inst_id, "[TRCV]", (inst_ptr == NULL));
+        callback_fptr = &Trcv_OnTxStatusInternal;
+        inst_ptr = self;
+    }
+
+    Msg_SetTxStatusHandler(msg_ptr, callback_fptr, inst_ptr);
+    Fifo_Tx(self->fifo_ptr, msg_ptr, true);
+}
+
+/*! \brief  Callback function which is invoked instead of an external callback 
+ *          as soon as channel transmission was finished in PMS. 
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the message object
+ *  \param  status  Transmission status
+ */
+static void Trcv_OnTxStatusInternal(void *self, Msg_MostTel_t *tel_ptr, Mns_MsgTxStatus_t status)
+{
+    Trcv_TxReleaseMsg(tel_ptr);
+    MISC_UNUSED(self);
+    MISC_UNUSED(status);
+}
+
+/*! \brief  Internal callback function which is intended to be 
+ *          invoked by the port message channel on completed reception.
+ *  \param  self    The instance
+ *  \param  tel_ptr Reference to the message object
+ */
+void Trcv_RxOnMsgComplete(void *self, CMessage *tel_ptr)
+{
+    CTransceiver *self_ = (CTransceiver*)self;
+    bool discard = false;
+ 
+    TR_INFO((self_->mns_inst_id, "[TRCV]", "Trcv_RxOnMsgComplete(): FIFO: %u, MSG(src:0x%04X, id:%02X.%01X.%04X.%01X)", 6U, self_->own_id, tel_ptr->pb_msg.source_addr, tel_ptr->pb_msg.id.fblock_id, tel_ptr->pb_msg.id.instance_id, tel_ptr->pb_msg.id.function_id, tel_ptr->pb_msg.id.op_type));
+    if (self_->rx_filter_fptr != NULL)
+    {
+        discard = self_->rx_filter_fptr(self_->rx_filter_inst, Msg_GetMostTel(tel_ptr));
+    }
+
+    if ((self_->rx_complete_fptr != NULL) && (discard == false))
+    {
+        /* the assigned Rx function is responsible to release the message */
+        self_->rx_complete_fptr(self_->rx_complete_inst, Msg_GetMostTel(tel_ptr));
+    }
+    else
+    {
+        Fifo_RxReleaseMsg(self_->fifo_ptr, tel_ptr);
+    }
+}
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_transceiver.h b/mnsl/mns_transceiver.h
new file mode 100644
index 0000000..b1701c5
--- /dev/null
+++ b/mnsl/mns_transceiver.h
@@ -0,0 +1,135 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 Declaration of class CTransceiver
+ *
+ * \cond MNS_INTERNAL_DOC
+ * \addtogroup  G_TRCV
+ * @{
+ */
+
+#ifndef MNS_TRANSCEIVER_H
+#define MNS_TRANSCEIVER_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_message.h"
+#include "mns_pool.h"
+#include "mns_pmfifo.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/    
+/*! \brief  Assignable callback function which is invoked for message reception 
+ *  \param  self    The instance
+ *  \param   tel_ptr Reference to the message object
+ */
+typedef void (*Trcv_RxCompleteCb_t)(void *self, Msg_MostTel_t *tel_ptr);
+
+/*! \brief   Assignable callback function which is invoked to filter Rx messages
+ *  \details Filtering is a synchronous operation. Hence, it is not possible to keep a message
+ *           object for delayed processing. The invoked function has to decide whether a 
+ *           message shall be discarded and freed to the Rx pool. Therefore, it has to return 
+ *           \c true. By returning \ false, the message will be received in the usual way.
+ *  \param   self    The instance
+ *  \param   tel_ptr Reference to the message object
+ *  \return  Returns \c true to discard the message and free it to the pool (no-pass). Otherwise, returns 
+ *           \c false (pass).
+ */
+typedef bool (*Trcv_RxFilterCb_t)(void *self, Msg_MostTel_t *tel_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Macros                                                                                         */
+/*------------------------------------------------------------------------------------------------*/
+#define TRCV_SIZE_TX_POOL    100U                    /*!< \brief Number of messages in the message pool */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Class CTransceiver                                                                             */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Class CTransceiver 
+ *  \details Provides MOST message objects and communication methods to further classes
+ */
+typedef struct CTransceiver_
+{
+    CMessage             tx_msgs[TRCV_SIZE_TX_POOL];/*!< \brief Messages in message pool */
+    CPool                tx_msg_pool;               /*!< \brief The message pool */
+    uint16_t             tx_def_src;                /*!< \brief Default source address for Tx message object */
+    uint8_t              mns_inst_id;               /*!< \brief MOST NetServices instance ID */
+    uint8_t              own_id;                    /*!< \brief ID of the transceiver required for tracing */
+    CPmFifo             *fifo_ptr;                  /*!< \brief Reference to dedicated port message FIFO */
+
+    Trcv_RxCompleteCb_t  rx_complete_fptr;          /*!< \brief Callback function which is invoked on 
+                                                     *          message reception 
+                                                     */
+    void                *rx_complete_inst;          /*!< \brief Instance which is notified on 
+                                                     *          message reception 
+                                                     */
+    Trcv_RxFilterCb_t    rx_filter_fptr;            /*!< \brief Callback function which is invoked 
+                                                     *          to filter Rx messages
+                                                     */
+    void                *rx_filter_inst;            /*!< \brief Instance which is notified to
+                                                     *          filter Rx messages
+                                                     */
+} CTransceiver;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Methods                                                                                        */
+/*------------------------------------------------------------------------------------------------*/
+/* Constructor */
+extern void Trcv_Ctor(CTransceiver *self, CPmFifo *fifo_ptr, uint16_t def_src_addr, uint8_t mns_inst_id, uint8_t trace_id);
+/* Tx */
+extern Msg_MostTel_t* Trcv_TxAllocateMsg(CTransceiver *self, uint8_t size);
+extern void Trcv_TxSendMsg(CTransceiver *self, Msg_MostTel_t *tel_ptr);
+extern void Trcv_TxSendMsgExt(CTransceiver *self, Msg_MostTel_t *tel_ptr, Msg_TxStatusCb_t callback_fptr, void *inst_ptr);
+extern void Trcv_TxSendMsgBypass(CTransceiver *self, Msg_MostTel_t *tel_ptr, Msg_TxStatusCb_t callback_fptr, void *inst_ptr);
+extern void Trcv_TxReleaseMsg(Msg_MostTel_t *tel_ptr);
+extern void Trcv_TxReuseMsg(Msg_MostTel_t *tel_ptr);
+/* Rx */
+extern void Trcv_RxAssignReceiver(CTransceiver *self, Trcv_RxCompleteCb_t callback_fptr, void *inst_ptr);
+extern void Trcv_RxAssignFilter(CTransceiver *self, Trcv_RxFilterCb_t callback_fptr, void *inst_ptr);
+extern void Trcv_RxReleaseMsg(CTransceiver *self, Msg_MostTel_t *tel_ptr);
+extern void Trcv_RxOnMsgComplete(void *self, CMessage *tel_ptr);
+
+#ifdef __cplusplus
+}                                                   /* extern "C" */
+#endif
+
+#endif /* #ifndef MNS_TRANSCEIVER_H */
+
+/*!
+ * @}
+ * \endcond
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mns_types_cfg.h b/mnsl/mns_types_cfg.h
new file mode 100644
index 0000000..32ce84e
--- /dev/null
+++ b/mnsl/mns_types_cfg.h
@@ -0,0 +1,70 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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 MOST NetServices data types.
+ */
+
+#ifndef MNS_TYPES_H
+#define MNS_TYPES_H
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Data Types                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+/* Definition of standard integer typed, typically defined in <stdint.h> */
+/*   typedef signed char int8_t; */
+/*   typedef short int16_t; */
+/*   typedef int int32_t; */
+/*   typedef unsigned char uint8_t; */
+/*   typedef unsigned short uint16_t; */
+/*   typedef unsigned int uint32_t; */
+
+/* Definition of size_t, typically defined in <stddef.h> */
+/*   typedef uint32_t size_t; */
+
+/* Definition of character type */
+     typedef char char_t;
+
+#ifdef __cplusplus
+}           /* extern "C" */
+#endif
+
+#endif      /* #ifndef MNS_TYPES_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+
diff --git a/mnsl/mnsl.c b/mnsl/mnsl.c
new file mode 100644
index 0000000..2b59746
--- /dev/null
+++ b/mnsl/mnsl.c
@@ -0,0 +1,435 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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.
+ *
+ */
+
+/* parasoft suppress item * reason "not part of MOST NetServices delivery" */
+
+/*!
+ * \file
+ * \brief Implementation of MOST NetServices Light
+ */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_types_cfg.h"
+#include "mnsl.h"
+#include "mns_base.h"
+#include "mns_misc.h"
+#include "mns_pmchannel.h"
+#include "mns_ams.h"
+#include "mns_transceiver.h"
+#include "mns_pmfifos.h"
+
+#include <assert.h> //TKU
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal prototypes                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+static void Mnsl_OnPmsEvent(void *self, void *event_code);
+static void Mnsl_OnServiceRequest(void *self, void *data_ptr);
+static void Mnsl_OnGetTickCount(void *self, void *tick_count_value_ptr);
+static void Mnsl_OnSetApplicationTimer(void *self, void *new_time_value_ptr);
+
+/*------------------------------------------------------------------------------------------------*/
+/* Implementation of class CMnsl                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief   Assigns default values to a provided MNSL init structure
+ *  \param   init_ptr         Reference to MNSL init structure.
+ *  \param   enable_watchdog  Set to \c true for normal use. Set to \c false to disable the watchdog 
+ *                            supervision for debugging purpose only.
+ */
+extern void Mnsl_SetDefaultConfig(Mnsl_InitData_t *init_ptr, bool enable_watchdog)
+{
+    MISC_MEM_SET(init_ptr, 0, sizeof(Mnsl_InitData_t));
+
+    init_ptr->pms.active_fifos = MNSL_FIFOS_MCM_ICM;
+    init_ptr->pms.compressed = false;
+    
+    init_ptr->pms.icm_config.fifo_id = PMP_FIFO_ID_ICM;
+    init_ptr->pms.icm_config.tx_wd_timeout = 0U;
+    init_ptr->pms.icm_config.tx_wd_timer_value = 0U;
+    init_ptr->pms.icm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.icm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.icm_config.rx_credits = PMCH_FIFO_CREDITS;
+    init_ptr->pms.icm_config.rx_threshold = PMCH_FIFO_THRESHOLD;
+
+    init_ptr->pms.rcm_config.fifo_id = PMP_FIFO_ID_RCM;
+    init_ptr->pms.rcm_config.tx_wd_timeout = 10U;       /* watchdog timeout: 1s */
+    init_ptr->pms.rcm_config.tx_wd_timer_value = 600U;  /* watchdog trigger every 600 ms */
+    init_ptr->pms.rcm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.rcm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.rcm_config.rx_credits = PMCH_FIFO_CREDITS;
+    init_ptr->pms.rcm_config.rx_threshold = PMCH_FIFO_THRESHOLD;
+
+    init_ptr->pms.mcm_config.fifo_id = PMP_FIFO_ID_MCM;
+    init_ptr->pms.mcm_config.tx_wd_timeout = 10U;       /* watchdog timeout: 1s */
+    init_ptr->pms.mcm_config.tx_wd_timer_value = 600U;  /* watchdog trigger every 600 ms */
+    init_ptr->pms.mcm_config.rx_ack_timeout = 10U;
+    init_ptr->pms.mcm_config.rx_busy_allowed = 0xFU;
+    init_ptr->pms.mcm_config.rx_credits = PMCH_MCM_CREDITS;
+    init_ptr->pms.mcm_config.rx_threshold = PMCH_MCM_THRESHOLD;
+                                                          
+    if (enable_watchdog == false)
+    {
+        init_ptr->pms.icm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+        init_ptr->pms.rcm_config.tx_wd_timeout = 0U;    /* watchdog timeout:    0 -> infinite */
+        init_ptr->pms.rcm_config.tx_wd_timer_value = 0U;/* watchdog timer:      0 -> no timer */
+        init_ptr->pms.rcm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+        init_ptr->pms.mcm_config.tx_wd_timeout = 0U;    /* watchdog timeout:    0 -> infinite */
+        init_ptr->pms.mcm_config.tx_wd_timer_value = 0U;/* watchdog timer:      0 -> no timer */
+        init_ptr->pms.mcm_config.rx_ack_timeout = 0U;   /* acknowledge timeout: 0 -> infinite */
+    }
+}
+
+/*! \brief  Initialize MNS Light class
+ *  \param  init_ptr    Reference to the MNSL init structure.
+ *                      The memory of the init structure can be freed after the function returns.
+ */
+void Mnsl_Init(CMnsl *mnsl, Mnsl_InitData_t *init_ptr, void *inst_ptr)
+{
+    assert(NULL != mnsl);
+    CSingleObserver *srv_request_obs_ptr = NULL;
+    CSingleObserver *app_timer_obs_ptr = NULL;
+    Base_InitData_t base_init_data;
+    Pmch_InitData_t pmch_init_data;
+    CPmFifo *icm_ptr = NULL;
+    CPmFifo *rcm_ptr = NULL;
+    CPmFifo *mcm_ptr = NULL;
+    CTransceiver *trcv_mcm_ptr = NULL;
+    CTransceiver *trcv_rcm_ptr = NULL;
+
+    MISC_MEM_SET(mnsl, 0, sizeof(mnsl));
+    MISC_MEM_SET(&base_init_data, 0, sizeof(base_init_data));
+
+    mnsl->inst_ptr = inst_ptr; //TKU
+    mnsl->inst_id = 1U;
+    mnsl->get_tick_count_fptr = init_ptr->general.get_tickcount_fptr;
+    mnsl->srv_request_fptr = init_ptr->general.request_service_fptr;
+    mnsl->set_app_timer_fptr = init_ptr->general.set_app_timer_fptr;
+
+    if(mnsl->srv_request_fptr != NULL)
+    {
+        Sobs_Ctor(&mnsl->srv_request_obs, mnsl, &Mnsl_OnServiceRequest);
+        srv_request_obs_ptr = &mnsl->srv_request_obs;
+    }
+    if (mnsl->set_app_timer_fptr != NULL)
+    {
+        Sobs_Ctor(&mnsl->set_app_timer_obs, mnsl, &Mnsl_OnSetApplicationTimer);
+        app_timer_obs_ptr = &mnsl->set_app_timer_obs;
+    }
+
+    base_init_data.mns_inst_id = 1U;
+    base_init_data.tm.mns_inst_id = 1U;
+    base_init_data.scd.mns_inst_id = 1U;
+
+    Sobs_Ctor(&mnsl->get_tick_count_obs, mnsl, &Mnsl_OnGetTickCount);
+    base_init_data.tm.get_tick_count_obs_ptr = &mnsl->get_tick_count_obs;
+    base_init_data.scd.service_request_obs_ptr = srv_request_obs_ptr;
+    base_init_data.tm.set_application_timer_obs_ptr = app_timer_obs_ptr;
+
+    Base_Ctor(&mnsl->base, &base_init_data);
+    
+    /* Initialize port message service */
+    pmch_init_data.mns_inst_id = 1U;
+    pmch_init_data.tx_release_fptr = &Fifo_TxOnRelease;
+    pmch_init_data.lld_iface = init_ptr->lld;
+    Pmch_Ctor(&mnsl->pm_channel, &pmch_init_data, inst_ptr);
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_ICM) == MNSL_FIFOS_ICM)
+    {
+        Fifo_InitData_t icm_init;
+
+        icm_init.base_ptr = &mnsl->base;
+        icm_init.channel_ptr = &mnsl->pm_channel;
+        icm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        icm_init.rx_cb_inst = &mnsl->icm_transceiver;
+
+        if (init_ptr->pms.compressed)
+        {
+            icm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+            icm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+        }
+        else
+        {
+            icm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+            icm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        }
+
+        Fifo_Ctor(&mnsl->icm_fifo, &icm_init, &init_ptr->pms.icm_config);
+        Trcv_Ctor(&mnsl->icm_transceiver, &mnsl->icm_fifo, MSG_ADDR_EHC_CFG, base_init_data.mns_inst_id, PMP_FIFO_ID_ICM);/* initialize ICM transceiver and set link to PMS instance */
+
+        icm_ptr = &mnsl->icm_fifo;
+    }
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_RCM) == MNSL_FIFOS_RCM)
+        {
+        Fifo_InitData_t rcm_init;
+
+        rcm_init.base_ptr = &mnsl->base;
+        rcm_init.channel_ptr = &mnsl->pm_channel;
+        rcm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        rcm_init.rx_cb_inst = &mnsl->rcm_transceiver;
+        rcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        rcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        /* Note: RCM compressed data format is not supported */
+
+        Fifo_Ctor(&mnsl->rcm_fifo, &rcm_init, &init_ptr->pms.rcm_config);
+        Trcv_Ctor(&mnsl->rcm_transceiver, &mnsl->rcm_fifo, MSG_ADDR_EHC_CFG, base_init_data.mns_inst_id, PMP_FIFO_ID_RCM);/* initialize ICM transceiver and set link to PMS instance */
+
+        rcm_ptr = &mnsl->rcm_fifo;
+        trcv_rcm_ptr = &mnsl->rcm_transceiver;
+    }
+
+    if((init_ptr->pms.active_fifos & MNSL_FIFOS_MCM) == MNSL_FIFOS_MCM)
+    {
+        Fifo_InitData_t mcm_init;
+
+        mcm_init.base_ptr = &mnsl->base;
+        mcm_init.channel_ptr = &mnsl->pm_channel;
+        mcm_init.rx_cb_fptr = &Trcv_RxOnMsgComplete;
+        mcm_init.rx_cb_inst = &mnsl->mcm_transceiver;
+
+        if (init_ptr->pms.compressed)
+        {
+            mcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_81);
+            mcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_80);
+        }
+        else
+        {
+            mcm_init.tx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+            mcm_init.rx_encoder_ptr = Enc_GetEncoder(ENC_CONTENT_00);
+        }
+
+        Fifo_Ctor(&mnsl->mcm_fifo, &mcm_init, &init_ptr->pms.mcm_config);
+        Trcv_Ctor(&mnsl->mcm_transceiver, &mnsl->mcm_fifo, MSG_ADDR_EHC_APP, base_init_data.mns_inst_id, PMP_FIFO_ID_MCM);/* initialize ICM transceiver and set link to PMS instance */
+
+        mcm_ptr = &mnsl->mcm_fifo;
+        trcv_mcm_ptr = &mnsl->mcm_transceiver;
+        }
+
+    if ((trcv_mcm_ptr != NULL) || (trcv_rcm_ptr != NULL))       /* initialize AMS if MCM or RCM is active */
+    {
+        mnsl->ams_allocator.alloc_fptr = init_ptr->ams.rx_alloc_mem_fptr;
+        mnsl->ams_allocator.free_fptr = init_ptr->ams.rx_free_mem_fptr;
+        Amsp_Ctor(&mnsl->ams_pool, &mnsl->ams_allocator, mnsl->base.mns_inst_id);
+        Ams_Ctor(&mnsl->ams, &mnsl->base, trcv_mcm_ptr, trcv_rcm_ptr, &mnsl->ams_pool, AMS_RX_DEF_SIZE_PAYLOAD);
+    }
+
+    /* initialize FIFO handler */
+    Fifos_Ctor(&mnsl->fifos, &mnsl->base, &mnsl->pm_channel, icm_ptr, mcm_ptr, rcm_ptr);
+
+    /* register event callback */
+    mnsl->event_fptr = init_ptr->general.event_fptr;
+    Obs_Ctor(&mnsl->pms_observer, mnsl, &Mnsl_OnPmsEvent);
+    Fifos_AddEventObserver(&mnsl->fifos, &mnsl->pms_observer);
+}
+
+/*! \brief   Synchronizes the PMS
+ *  \details Accordingly MNSL_EVENT_SYNC_COMPLETE or MNSL_EVENT_SYNC_FAILED will be notified.
+ */
+void Mnsl_Synchronize(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    /* initializes the port message service & LLD interface  */
+    Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_SYNC_RETRIES, FIFOS_SYNC_TIMEOUT);
+    Fifos_Synchronize(&mnsl->fifos, true, true);
+}
+
+/*! \brief   Un-synchronizes the PMS
+ *  \details Accordingly MNSL_EVENT_UNSYNC_COMPLETE or MNSL_EVENT_UNSYNC_FAILED will be notified.
+ *           Calling this function if MNSL is already un-synced will report MNSL_EVENT_UNSYNC_FAILED,
+ *           since the low-level driver interface is not active.
+ *  \param   initial    MNSL is able to trigger un-synchronization in advance of the initial
+ *                      synchronization. In this case, timeouts and retries behave like a synchronization
+ *                      and on MNSL_EVENT_UNSYNC_COMPLETE the LLD interface will stay running.
+ *                      I.e. if set to \c true the un-synchronization behaves like MNS initial un-synchronization.
+ *                      If set to \c false, the un-synchronization behaves like MNS final un-synchronization.
+ */
+void Mnsl_Unsynchronize(CMnsl *mnsl, bool initial)
+{    
+    assert(NULL != mnsl);
+    if (initial == false)
+    {
+        Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_UNSYNC_RETRIES, FIFOS_UNSYNC_TIMEOUT); /* final sync */
+    }
+    else
+    {
+        Fifos_ConfigureSyncParams(&mnsl->fifos, FIFOS_SYNC_RETRIES, FIFOS_SYNC_TIMEOUT); /* initial sync */
+    }
+    
+    Fifos_Unsynchronize(&mnsl->fifos, true, initial);
+}
+
+/*! \brief  Handles PMS event and notifies MNSL registered event callback
+ *  \param  self         Reference to instance
+ *  \param  event_code  Event notified by the PMS
+ */
+static void Mnsl_OnPmsEvent(void *self, void *event_code)
+{
+    assert(NULL != self);
+    Fifos_Event_t *code = (Fifos_Event_t*)event_code;
+    CMnsl *mnsl = (CMnsl *)self;    
+
+    if (mnsl->event_fptr != NULL)
+    {
+        switch (*code)
+        {
+            case FIFOS_EV_SYNC_LOST:
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_SYNC_LOST);        /* event is necessary for AMS cleanup */
+                mnsl->event_fptr(MNSL_EVENT_SYNC_LOST, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_SYNC_ESTABLISHED:
+                mnsl->event_fptr(MNSL_EVENT_SYNC_COMPLETE, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_SYNC_FAILED:
+                mnsl->event_fptr(MNSL_EVENT_SYNC_FAILED, mnsl->inst_ptr);
+                break;
+            case FIFOS_EV_UNSYNC_COMPLETE:
+                mnsl->event_fptr(MNSL_EVENT_UNSYNC_COMPLETE, mnsl->inst_ptr);
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_UNSYNC_COMPLETE);   /* event is necessary for AMS cleanup */
+                break;
+            case FIFOS_EV_UNSYNC_FAILED:
+                mnsl->event_fptr(MNSL_EVENT_UNSYNC_FAILED, mnsl->inst_ptr);
+                Eh_ReportEvent(&mnsl->base.eh, EH_E_UNSYNC_FAILED);    /* event is necessary for AMS cleanup */
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+/*! \brief  Service function of MNS Light
+ */
+void Mnsl_Service(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    bool pending_events;
+
+    TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service()", 0U));
+    Scd_Service(&mnsl->base.scd);                                                        /* Run the scheduler */
+    pending_events = Scd_AreEventsPending(&mnsl->base.scd);                              /* Check if events are still pending? */
+
+    if (pending_events != false)                                                        /* At least one event is pending? */
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service(): events still pending", 0U));
+        Mnsl_OnServiceRequest(mnsl, NULL);
+    }
+    else                                                                                /* No event is pending */
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_Service(): calling Tm_CheckForNextService()", 0U));
+        mnsl->base.scd.scd_srv_is_running = true;                                        /* prevent continuous service requests if no app timer is provided */
+        Tm_CheckForNextService(&mnsl->base.tm);                                          /* If MNS timers are running: What is the next time that the timer management must be */
+        mnsl->base.scd.scd_srv_is_running = false;                                       /* serviced again? */
+    }
+}
+
+/*! \brief  Reports that the application provided timer has expired.
+ */
+void Mnsl_ReportTimeout(CMnsl *mnsl)
+{
+    assert(NULL != mnsl);
+    TR_INFO((mnsl->inst_id, "[API]", "Mns_ReportTimeout()", 0U));
+    Tm_TriggerService(&mnsl->base.tm);  /* Trigger TM service call */
+}
+
+/*! \brief  Callback function which is invoked by the scheduler
+ *  \param self                     Parameter not used with single instance API
+ *  \param data_ptr                 Currently unused
+ */
+static void Mnsl_OnServiceRequest(void *self, void *data_ptr)
+{
+    assert(NULL != self);
+    CMnsl *mnsl = (CMnsl *)self;    
+    MISC_UNUSED(data_ptr);
+
+    if (mnsl->srv_request_fptr != NULL)
+    {
+        TR_INFO((mnsl->inst_id, "[API]", "Mnsl_OnServiceRequest(): calling srv_request_fptr()", 0U));
+        mnsl->srv_request_fptr(mnsl->inst_ptr);
+    }
+}
+
+/*! \brief This function is used in combination with the observer \c mns.get_tick_count_obs
+ *         which is used to request the current tick count value form the application.
+ *  \param self                     Parameter not used with single instance API
+ *  \param tick_count_value_ptr     Reference to the requested tick count value. The pointer must 
+ *                                  be casted into data type uint16_t.
+ */
+static void Mnsl_OnGetTickCount(void *self, void *tick_count_value_ptr)
+{
+    assert(NULL != self);
+    CMnsl *mnsl = (CMnsl *)self;    
+    *((uint16_t *)tick_count_value_ptr) = mnsl->get_tick_count_fptr();
+}
+
+/*! \brief  Callback function which is invoked to start the application timer when the MNSL service
+ *          is implemented event driven         
+ *  \param  self                The instance
+ *  \param  new_time_value_ptr  Reference to the new timer value. The pointer must be casted into 
+ *                              data type uint16_t.
+ */
+static void Mnsl_OnSetApplicationTimer(void *self, void *new_time_value_ptr)
+{
+    CMnsl *self_ = (CMnsl*)self;
+    TR_INFO((mnsl->inst_id, "[API]", "Mnsl_OnSetApplicationTimer(): set_app_timer_fptr(%d)", 1U, *((uint16_t *)new_time_value_ptr)));
+    self_->set_app_timer_fptr(*((uint16_t *)new_time_value_ptr), self_->inst_ptr);
+}
+
+/*! \brief  Returns the ICM transceiver object
+ *  \return Reference to the ICM transceiver 
+ */
+CTransceiver * Mnsl_GetIcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->icm_transceiver;
+}
+
+/*! \brief  Returns the RCM transceiver object
+ *  \return Reference to the RCM transceiver 
+ */
+CTransceiver * Mnsl_GetRcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->rcm_transceiver;
+}
+
+/*! \brief  Returns the MCM transceiver object
+ *  \return Reference to the MCM transceiver 
+ */
+CTransceiver * Mnsl_GetMcmTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->mcm_transceiver;
+}
+
+/*! \brief      Returns the AMS transceiver object
+ *  \details    It is important not make usage of competing transceivers
+ *              AMS, MCM and RCM. Either use AMS exclusively or MCM and RCM.
+ *              Important: Do not use AMS in mode \c MNSL_FIFOS_ICM. 
+ *  \return     Reference to the AMS
+ */
+CAms * Mnsl_GetAmsTransceiver(CMnsl *mnsl)
+{
+    return &mnsl->ams;
+}
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
diff --git a/mnsl/mnsl.h b/mnsl/mnsl.h
new file mode 100644
index 0000000..7288f50
--- /dev/null
+++ b/mnsl/mnsl.h
@@ -0,0 +1,195 @@
+/*
+ * MOST NetServices "Light" V3.2.7.0.1796 MultiInstance Patch
+ *
+ * Copyright (C) 2015 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 3 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.
+ *
+ */
+
+/* parasoft suppress item * reason "not part of MOST NetServices delivery" */
+
+/*!
+ * \file
+ * \brief Header file of MOST NetServices Light
+ */
+
+#ifndef MNSL_H
+#define MNSL_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*------------------------------------------------------------------------------------------------*/
+/* Includes                                                                                       */
+/*------------------------------------------------------------------------------------------------*/
+#include "mns_transceiver.h"
+#include "mns_ams.h"
+#include "mns_pmfifos.h"
+
+/*------------------------------------------------------------------------------------------------*/
+/* Definitions                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief MNS Major Version Number */
+#define MNSL_VERSION_MAJOR   3
+/*! \brief MNS Minor Version Number */
+#define MNSL_VERSION_MINOR   2
+/*! \brief MNS Release Version Number */
+#define MNSL_VERSION_RELEASE 7
+/*! \brief MNS Service Release Number */
+#define MNSL_VERSION_SR      0
+/*! \brief MNS Build Number */
+#define MNSL_VERSION_BUILD   1796
+
+/*------------------------------------------------------------------------------------------------*/
+/* Types                                                                                          */
+/*------------------------------------------------------------------------------------------------*/
+/*! \brief Defines which FIFOs shall be built on the Port Message Channel */
+typedef enum Mnsl_ActiveFifos_
+{
+    MNSL_FIFOS_MCM         = 0x01U,     /*!< \brief Initialize PM channel with MCM FIFO only */
+    MNSL_FIFOS_ICM         = 0x02U,     /*!< \brief Initialize PM channel with ICM FIFO only */
+    MNSL_FIFOS_MCM_ICM     = 0x03U,     /*!< \brief Initialize PM channel with MCM and ICM FIFO */
+    MNSL_FIFOS_RCM         = 0x04U,     /*!< \brief Initialize PM channel with RCM FIFO only */
+    MNSL_FIFOS_MCM_RCM     = 0x05U,     /*!< \brief Initialize PM channel with MCM and RCM FIFO */
+    MNSL_FIFOS_ICM_RCM     = 0x06U,     /*!< \brief Initialize PM channel with ICM and RCM FIFO */
+    MNSL_FIFOS_MCM_ICM_RCM = 0x07U      /*!< \brief Initialize PM channel with MCM, ICM and RCM FIFO */
+
+} Mnsl_ActiveFifos_t;
+
+/*! \brief Possible MNSL events */
+typedef enum Mnsl_Event_
+{
+    MNSL_EVENT_SYNC_COMPLETE    = 0,    /*!< \brief The initial synchronization completed successfully */
+    MNSL_EVENT_SYNC_FAILED      = 1,    /*!< \brief The initial synchronization failed */
+    MNSL_EVENT_SYNC_LOST        = 2,    /*!< \brief The synchronization to the INIC was lost irrecoverably */
+    MNSL_EVENT_UNSYNC_COMPLETE  = 3,    /*!< \brief The un-synchronization was completed successfully */
+    MNSL_EVENT_UNSYNC_FAILED    = 4     /*!< \brief The un-synchronization failed */
+
+} Mnsl_Event_t;
+
+typedef uint16_t (*Mnsl_GetTickCountCb_t)(void);
+typedef void (*Mnsl_EventCb_t)(Mnsl_Event_t event_code, void *inst_ptr);
+typedef void (*Mnsl_ServiceRequestCb_t)(void *inst_ptr);
+typedef void (*Mnsl_SetAppTimerCb_t)(uint16_t timeout, void *inst_ptr);
+
+/*! \brief General initialization settings */
+typedef struct Mnsl_General_InitData_
+{
+    Mnsl_EventCb_t          event_fptr;         /*!< \brief Reports an MNSL event (mandatory callback) */
+    Mnsl_GetTickCountCb_t   get_tickcount_fptr; /*!< \brief Requests the current tick count in milliseconds (mandatory callback) */
+    Mnsl_ServiceRequestCb_t request_service_fptr;/*!< \brief Reports that the application shall call Mnsl_Service() (optional callback) */
+    Mnsl_SetAppTimerCb_t    set_app_timer_fptr; /*!< \brief Triggers the application to call Mnsl_ReportTimeout() after a specific time (mandatory callback) */
+
+} Mnsl_General_InitData_t;
+
+/*! \brief Port Message Service (PMS) settings */
+typedef struct Mnsl_Pms_InitData_
+{
+    Mnsl_ActiveFifos_t  active_fifos;           /*!< \brief Defines which FIFOs shall be initialized */
+    Fifo_Config_t       icm_config;             /*!< \brief Setup of ICM FIFO */
+    Fifo_Config_t       mcm_config;             /*!< \brief Setup of MCM FIFO */
+    Fifo_Config_t       rcm_config;             /*!< \brief Setup of RCM FIFO */
+    bool                compressed;             /*!< \brief Set to \c true in order to use OS81118 Rev.C */
+
+} Mnsl_Pms_InitData_t;
+
+/*! \brief Application Message Service (AMS) settings */
+typedef struct Mnsl_Ams_InitData_
+{
+    Mns_Ams_AllocMemCb_t rx_alloc_mem_fptr;     /*!< \brief Required to allocate memory for an AMS Rx message */
+    Mns_Ams_FreeMemCb_t rx_free_mem_fptr;       /*!< \brief Required to free memory for an AMS Rx message */
+
+} Mnsl_Ams_InitData_t;
+
+/*! \brief Initialization settings */
+typedef struct Mnsl_InitData_
+{
+    Mnsl_General_InitData_t general;    /*!< \brief Basic settings to drive MNSL */
+    Mns_Lld_Callbacks_t     lld;        /*!< \brief Mandatory callback functions of the driver */
+    Mnsl_Pms_InitData_t     pms;        /*!< \brief Port Message Service settings */
+    Mnsl_Ams_InitData_t     ams;        /*!< \brief Application Message Service settings */    
+
+} Mnsl_InitData_t;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Helper Macros                                                                                  */
+/*------------------------------------------------------------------------------------------------*/
+#define MNSL_UNUSED(p)   ((p) = (p)) /* parasoft-suppress  MISRA2004-19_7 "suppress warning" */
+
+/*------------------------------------------------------------------------------------------------*/
+/* Internal structures                                                                            */
+/*------------------------------------------------------------------------------------------------*/
+typedef struct CMnsl_
+{
+    uint8_t inst_id;
+    CBase base;
+    CPmChannel pm_channel;
+    CPmFifos fifos;
+    CPmFifo icm_fifo;
+    CPmFifo rcm_fifo;
+    CPmFifo mcm_fifo;
+
+    Mnsl_GetTickCountCb_t get_tick_count_fptr;
+    CSingleObserver get_tick_count_obs;
+
+    Mnsl_ServiceRequestCb_t srv_request_fptr;
+    CSingleObserver srv_request_obs;
+
+    Mnsl_SetAppTimerCb_t set_app_timer_fptr;
+    CSingleObserver set_app_timer_obs;
+
+    CTransceiver icm_transceiver;
+    CTransceiver rcm_transceiver;
+    CTransceiver mcm_transceiver;
+    CAms ams;
+    CAmsMsgPool ams_pool;
+    Ams_MemAllocator_t ams_allocator;
+
+    Mnsl_EventCb_t  event_fptr;
+    CObserver       pms_observer;
+    
+    void *inst_ptr; //TKU: added
+
+} CMnsl;
+
+/*------------------------------------------------------------------------------------------------*/
+/* Prototypes                                                                                     */
+/*------------------------------------------------------------------------------------------------*/
+extern void Mnsl_SetDefaultConfig(Mnsl_InitData_t *init_ptr, bool enable_watchdog);
+extern void Mnsl_Init(CMnsl *mnsl, Mnsl_InitData_t *init_ptr, void *inst_ptr);
+extern void Mnsl_Synchronize(CMnsl *mnsl);
+extern void Mnsl_Unsynchronize(CMnsl *mnsl, bool initial);
+extern void Mnsl_Service(CMnsl *mnsl);
+extern void Mnsl_ReportTimeout(CMnsl *mnsl);
+extern CTransceiver * Mnsl_GetIcmTransceiver(CMnsl *mnsl);
+extern CTransceiver * Mnsl_GetRcmTransceiver(CMnsl *mnsl);
+extern CTransceiver * Mnsl_GetMcmTransceiver(CMnsl *mnsl);
+extern CAms         * Mnsl_GetAmsTransceiver(CMnsl *mnsl);
+
+#ifdef __cplusplus
+}   /* extern "C" */
+#endif
+
+#endif  /* #ifndef MNSL_H */
+
+/*------------------------------------------------------------------------------------------------*/
+/* End of file                                                                                    */
+/*------------------------------------------------------------------------------------------------*/
+