integrating transport layer instance into shellmatta instance

api/shellmatta.h

@@ -114,45 +114,111 @@ typedef struct shellmatta_cmd
     struct shellmatta_cmd   *next;      /**< pointer to next command or NULL        */
 } shellmatta_cmd_t;
 
+/**
+ * @brief definition of shellmatta transport layer states
+ */
+typedef enum
+{
+    STATE_GET_SOH                =0u,   /**< start of header state of transport layer */
+    STATE_MANUAL_INPUT              ,
+    STATE_GET_PROTOCOL_VERSION      ,   /**< protocol version state of transport layer */
+    STATE_GET_PACKET_TYPE           ,   /**< packet type state of transport layer */
+    STATE_GET_PAYLOAD_LENGTH        ,   /**< payload length state of transport layer */
+    STATE_GET_SOURCE                ,   /**< source state of transport layer */
+    STATE_GET_DESTINATION           ,   /**< destination state of transport layer */
+    STATE_GET_H2S_SEQUENCE_CNT      ,   /**< host to shellmatta sequence counter state of transport layer */
+    STATE_GET_S2H_SEQUENCE_CNT      ,   /**< shellmatta to host sequence counter state of transport layer */
+    STATE_GET_PAYLOAD               ,   /**< payload state of transport layer */
+    STATE_GET_CRC                   ,   /**< crc state of transport layer */
+    STATE_PROCESS_PAYLOAD
+} shellmatta_transport_state_t;
+
+/**
+ * @brief definition of shellmatta transport layer packet types
+ */
+typedef enum
+{
+    PACKET_DATA                     = 0x00u,    /**< packet type to send plain data */
+    PACKET_SEQ_CNT_REQUEST          = 0x01u,    /**< packet type to request sequence counters */
+    PACKET_SEQ_CNT_RESPOND          = 0x81u,    /**< packet type to respond with sequence counters */
+    PACKET_MAX_BUFFERSIZE_REQUEST   = 0x02u,    /**< packet type to set and request max buffersize */
+    PACKET_MAX_BUFFERSIZE_RESPOND   = 0x82u,    /**< packet type to respond with max buffersize */
+    PACKET_SEARCH_DEVICE_REQUEST    = 0x03u,    /**< UNUSED: packet type to request search for a device by unique id */
+    PACKET_SEARCH_DEVICE_RESPOND    = 0x83u,    /**< UNUSED: packet type to respond with search results */
+    PACKET_SET_ADDRESS_REQUEST      = 0x04u,    /**< UNUSED: packet type to set and request an address */
+    PACKET_SET_ADDRESS_RESPOND      = 0x84u     /**< UNUSED: packet type to respond with a set address */
+} shellmatta_transport_packet_t;
+
+/* payload length defines */
+/** @brief max length of a plain data payload */
+#define SHELLMATTA_PAYLOAD_MAXLENGTH        ((uint8_t)(255))
+
+/**
+ * @brief structure of one shellmatta transport layer instance
+ */
+typedef struct
+{
+    uint8_t h2s_sequenceCnt;                /**<  */
+    uint8_t s2h_sequenceCnt;                /**<  */
+    shellmatta_transport_state_t state;     /**<  */
+    bool mandatory;                         /**<  */
+    bool active;                            /**<  */
+    bool continueStep;                      /**<  */
+    shellmatta_write_t originalWrite;       /**<  */
+    /* init global variables */
+    uint8_t protocolVersion;
+    shellmatta_transport_packet_t packetType;
+    uint32_t payloadLength;
+    uint8_t source;
+    uint8_t destination;
+    uint32_t crc32;
+    uint8_t payloadCounter;
+    uint8_t crcCounter;
+    uint8_t packetSequenceCounter_h2s;
+    uint8_t packetSequenceCounter_s2h;
+    char payloadBuffer[SHELLMATTA_PAYLOAD_MAXLENGTH];
+} shellmatta_transport_layer_t;
+
 /**
  * @brief structure of one shellmatta instance
  */
 typedef struct
 {
-    uint32_t            magic;              /**< magic number to check if initialized   */
-    char                *buffer;            /**< input buffer                           */
-    uint32_t            bufferSize;         /**< size of the input buffer               */
-    uint32_t            inputCount;         /**< offset of the current write operation  */
-    uint32_t            byteCounter;        /**< counter used to loop over input data   */
-    uint32_t            lastNewlineIdx;     /**< index of the lest newline              */
-    uint32_t            cursor;             /**< offset where the cursor is at          */
-    uint32_t            stdinIdx;           /**< start index of stdin in buffer         */
-    uint32_t            stdinLength;        /**< length of the stdin data               */
-    char                *historyBuffer;     /**< buffer to store the last commands      */
-    uint32_t            historyBufferSize;  /**< size of the history buffer             */
-    uint32_t            historyStart;       /**< index of the oldest stored command     */
-    uint32_t            historyEnd;         /**< index of the newest stored command     */
-    uint32_t            historyRead;        /**< index of the current search            */
-    bool                historyReadUp;      /**< flag to show the last history dir      */
-    uint32_t            tabCounter;         /**< counts the tabulator key presses       */
-    uint32_t            escapeCounter;      /**< counts the characters of an escape seq */
-    char                escapeChars[4u];    /**< buffer to save the escape characters   */
-    uint32_t            hereStartIdx;       /**< heredoc start of "<<"                  */
-    uint32_t            hereDelimiterIdx;   /**< heredoc delimiter index in input       */
-    uint32_t            hereLength;         /**< length of the heredoc delimiter        */
-    bool                echoEnabled;        /**< if true the input is printed           */
-    bool                dirty;              /**< dirty flag to show changes             */
-    const char          *prompt;            /**< prompt is printed after every command  */
-    char                delimiter;          /**< delimiter (return) to terminate a cmd  */
-    shellmatta_mode_t   mode;               /**< mode of the shell                      */
-    shellmatta_write_t  write;              /**< pointer to write function              */
-    shellmatta_cmd_t    helpCmd;            /**< help command structure                 */
-    shellmatta_cmd_t    *cmdList;           /**< pointer to the first command           */
-    shellmatta_cmd_t    *continuousCmd;     /**< command to be called continuously      */
-    shellmatta_cmd_t    *busyCmd;           /**< command to be polled (busy mode)       */
-    bool                cmdListIsConst;     /**< true if the #cmdList was passed during
-                                                 initialization                         */
-    shellmatta_opt_t    optionParser;       /**< option parser sructure                 */
+    uint32_t                        magic;              /**< magic number to check if initialized   */
+    char                            *buffer;            /**< input buffer                           */
+    uint32_t                        bufferSize;         /**< size of the input buffer               */
+    uint32_t                        inputCount;         /**< offset of the current write operation  */
+    uint32_t                        byteCounter;        /**< counter used to loop over input data   */
+    uint32_t                        lastNewlineIdx;     /**< index of the lest newline              */
+    uint32_t                        cursor;             /**< offset where the cursor is at          */
+    uint32_t                        stdinIdx;           /**< start index of stdin in buffer         */
+    uint32_t                        stdinLength;        /**< length of the stdin data               */
+    char                            *historyBuffer;     /**< buffer to store the last commands      */
+    uint32_t                        historyBufferSize;  /**< size of the history buffer             */
+    uint32_t                        historyStart;       /**< index of the oldest stored command     */
+    uint32_t                        historyEnd;         /**< index of the newest stored command     */
+    uint32_t                        historyRead;        /**< index of the current search            */
+    bool                            historyReadUp;      /**< flag to show the last history dir      */
+    uint32_t                        tabCounter;         /**< counts the tabulator key presses       */
+    uint32_t                        escapeCounter;      /**< counts the characters of an escape seq */
+    char                            escapeChars[4u];    /**< buffer to save the escape characters   */
+    uint32_t                        hereStartIdx;       /**< heredoc start of "<<"                  */
+    uint32_t                        hereDelimiterIdx;   /**< heredoc delimiter index in input       */
+    uint32_t                        hereLength;         /**< length of the heredoc delimiter        */
+    bool                            echoEnabled;        /**< if true the input is printed           */
+    bool                            dirty;              /**< dirty flag to show changes             */
+    const char                      *prompt;            /**< prompt is printed after every command  */
+    char                            delimiter;          /**< delimiter (return) to terminate a cmd  */
+    shellmatta_mode_t               mode;               /**< mode of the shell                      */
+    shellmatta_write_t              write;              /**< pointer to write function              */
+    shellmatta_cmd_t                helpCmd;            /**< help command structure                 */
+    shellmatta_cmd_t                *cmdList;           /**< pointer to the first command           */
+    shellmatta_cmd_t                *continuousCmd;     /**< command to be called continuously      */
+    shellmatta_cmd_t                *busyCmd;           /**< command to be polled (busy mode)       */
+    bool                            cmdListIsConst;     /**< true if the #cmdList was passed during
+                                                             initialization                         */
+    shellmatta_opt_t                optionParser;       /**< option parser sructure                 */
+    shellmatta_transport_layer_t    transportLayer;     /**< transport layer instance               */
 } shellmatta_instance_t;
 
 

src/shellmatta.c

@@ -120,8 +120,8 @@ shellmatta_retCode_t shellmatta_doInit(
         utils_terminateInput(inst);
 
         /* init transport layer */
-        shellmatta_init_transport_inst();
-        transportLayerInst.originalWrite = inst->write;
+        shellmatta_init_transport_inst(&inst->transportLayer);
+        inst->transportLayer.originalWrite = inst->write;
     }
 
     return SHELLMATTA_OK;
@@ -387,74 +387,74 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
     if(     (NULL               != inst)
         &&  (SHELLMATTA_MAGIC   == inst->magic))
     {
-        if (    (transportLayerInst.state != STATE_PROCESS_PAYLOAD)
-            &&  (transportLayerInst.state != STATE_MANUAL_INPUT))
+        if (    (inst->transportLayer.state != STATE_PROCESS_PAYLOAD)
+            &&  (inst->transportLayer.state != STATE_MANUAL_INPUT))
         {
             // TODO: Move this into shellmatta_transport.c
             /* use headerCounter to watch how many header fields have been worked on */
             uint8_t headerCounter = 0u;
             while ( (size > headerCounter) 
-                ||  (   (true == transportLayerInst.mandatory)
+                ||  (   (true == inst->transportLayer.mandatory)
                     &&  (size > headerCounter))
-                ||  (true == transportLayerInst.continueStep))
+                ||  (true == inst->transportLayer.continueStep))
             {
-                switch (transportLayerInst.state)
+                switch (inst->transportLayer.state)
                 {
                 case STATE_GET_SOH:
                     /* wait for SOH or go to payload */
                     break;
 
                 case STATE_GET_PROTOCOL_VERSION:
-                    protocolVersion = data[headerCounter];
+                    inst->transportLayer.protocolVersion = data[headerCounter];
                     break;
 
                 case STATE_GET_PACKET_TYPE:
-                    packetType = (shellmatta_transport_packet_t)data[headerCounter];
+                    inst->transportLayer.packetType = (shellmatta_transport_packet_t)data[headerCounter];
                     break;
 
                 case STATE_GET_PAYLOAD_LENGTH:
-                    payloadLength = (uint8_t)data[headerCounter];
+                    inst->transportLayer.payloadLength = (uint8_t)data[headerCounter];
                     break;
 
                 case STATE_GET_SOURCE:
-                    source = data[headerCounter];
+                    inst->transportLayer.source = data[headerCounter];
                     break;
 
                 case STATE_GET_DESTINATION:
-                    destination = data[headerCounter];
+                    inst->transportLayer.destination = data[headerCounter];
                     break;
                 
                 case STATE_GET_H2S_SEQUENCE_CNT:
-                    packetSequenceCounter_h2s = data[headerCounter];
+                    inst->transportLayer.packetSequenceCounter_h2s = data[headerCounter];
                     break;
                 
                 case STATE_GET_S2H_SEQUENCE_CNT:
-                    packetSequenceCounter_s2h = data[headerCounter];
+                    inst->transportLayer.packetSequenceCounter_s2h = data[headerCounter];
                     break;
 
                 case STATE_GET_PAYLOAD:
-                    if (0u == payloadLength)
+                    if (0u == inst->transportLayer.payloadLength)
                     {
-                        transportLayerInst.continueStep = true;
+                        inst->transportLayer.continueStep = true;
                     }
-                    payloadBuffer[payloadCounter++] = data[headerCounter];
+                    inst->transportLayer.payloadBuffer[inst->transportLayer.payloadCounter++] = data[headerCounter];
                     break;
 
                 case STATE_GET_CRC:
-                    transportLayerInst.continueStep = false;
-                    crc32 |= (uint8_t)data[headerCounter] << (SHELLMATTA_LENGTH_CRC - 1u - crcCounter++) * 8u;
+                    inst->transportLayer.continueStep = false;
+                    inst->transportLayer.crc32 |= (uint8_t)data[headerCounter] << (SHELLMATTA_LENGTH_CRC - 1u - inst->transportLayer.crcCounter++) * 8u;
                     break;
                 
                 default:
                     break;
                 }
                 /* handling of transport layer fsm */
-                ret = shellmatta_handle_transport_fsm(data);
+                ret = shellmatta_handle_transport_fsm(&inst->transportLayer, data);
                 
                 /* crc error handling */
                 if (SHELLMATTA_ERROR == ret)
                 {
-                    shellmatta_reset_transport();
+                    shellmatta_reset_transport(&inst->transportLayer);
                     utils_writeEcho(inst, "crc error\r\n", 11);
                     utils_terminateInput(inst);
                     return SHELLMATTA_OK;
@@ -463,26 +463,28 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
                 headerCounter++;
 
                 /* processes payload by forwarding it recursively without transport layer to processData() */
-                if (transportLayerInst.state == STATE_PROCESS_PAYLOAD)
+                if (inst->transportLayer.state == STATE_PROCESS_PAYLOAD)
                 {
                     /* replace inst->write function pointer with transport layer write function */
-                    transportLayerInst.originalWrite = inst->write;
+                    inst->transportLayer.originalWrite = inst->write;
                     inst->write = shellmatta_write_transport;
                     
                     /* recursive call with complete payload */
-                    shellmatta_processData(handle, payloadBuffer, payloadLength);
+                    shellmatta_processData(handle,
+                                           inst->transportLayer.payloadBuffer,
+                                           inst->transportLayer.payloadLength);
                     
                     /* set back inst->write function pointer to original */
-                    inst->write = transportLayerInst.originalWrite;
-                    shellmatta_handle_transport_fsm(data);
+                    inst->write = inst->transportLayer.originalWrite;
+                    shellmatta_handle_transport_fsm(&inst->transportLayer, data);
                     return SHELLMATTA_OK;
                 }
             }
         }
 
-        if (    (transportLayerInst.active)
-            &&  (transportLayerInst.state != STATE_PROCESS_PAYLOAD)
-            &&  (transportLayerInst.state != STATE_MANUAL_INPUT))
+        if (    (inst->transportLayer.active)
+            &&  (inst->transportLayer.state != STATE_PROCESS_PAYLOAD)
+            &&  (inst->transportLayer.state != STATE_MANUAL_INPUT))
         {
             return SHELLMATTA_OK;
         }
@@ -815,9 +817,9 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
     }
 
     /* if manual input happened, reset transport layer fsm back to initial state */
-    if (transportLayerInst.state == STATE_MANUAL_INPUT)
+    if (inst->transportLayer.state == STATE_MANUAL_INPUT)
     {
-        transportLayerInst.state = STATE_GET_SOH;
+        inst->transportLayer.state = STATE_GET_SOH;
     }
 
     return ret;

src/shellmatta_transport.c

@@ -8,41 +8,17 @@
 #include "shellmatta_crc.h"
 #include <string.h>
 
-/* init global variables */
-uint8_t protocolVersion                     = 0u;
-shellmatta_transport_packet_t packetType    = PACKET_DATA;
-uint32_t payloadLength                      = 0u;
-uint8_t source                              = 0u;
-uint8_t destination                         = 0u;
-uint32_t crc32                              = 0u;
-uint8_t payloadCounter                      = 0u;
-uint8_t crcCounter                          = 0u;
-uint8_t packetSequenceCounter_h2s           = 0u;
-uint8_t packetSequenceCounter_s2h           = 0u;
-shellmatta_transport_layer_t transportLayerInst = {
-    0u,
-    0u,
-    STATE_GET_SOH,
-    false,
-    false,
-    false,
-    NULL
-};
-char payloadBuffer[SHELLMATTA_PAYLOAD_MAXLENGTH];
+
+static shellmatta_transport_layer_t *transportLayerInt;
 
 /**
  * @brief       Initializes the transportLayerInst
  * @return      errorcode   #SHELLMATTA_OK
  */
-shellmatta_retCode_t shellmatta_init_transport_inst(void)
+shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t *transportLayer)
 {
-    transportLayerInst.h2s_sequenceCnt = 0u;
-    transportLayerInst.s2h_sequenceCnt = 0u;
-    transportLayerInst.state = STATE_GET_SOH;
-    transportLayerInst.mandatory = false;
-    transportLayerInst.active = false;
-    transportLayerInst.continueStep = false;
-    memset(payloadBuffer, 0u, SHELLMATTA_PAYLOAD_MAXLENGTH);
+    transportLayerInt = transportLayer;
+    memset(transportLayer, 0u, sizeof(shellmatta_transport_layer_t));
 
     return SHELLMATTA_OK;
 }
@@ -51,19 +27,14 @@ shellmatta_retCode_t shellmatta_init_transport_inst(void)
  * @brief       Resets all values of tranportLayerInst except for sequence counters
  * @return      errorcode   #SHELLMATTA_OK
  */
-shellmatta_retCode_t shellmatta_reset_transport(void)
+shellmatta_retCode_t shellmatta_reset_transport(shellmatta_transport_layer_t *transportLayer)
 {
-    transportLayerInst.state = STATE_GET_SOH;
-    protocolVersion = 0u;
-    packetType      = PACKET_DATA;
-    payloadLength   = 0u;
-    source          = 0u;
-    destination     = 0u;
-    crc32           = 0u;
-    payloadCounter  = 0u;
-    crcCounter      = 0u;
-    transportLayerInst.active = false;
-    memset(payloadBuffer, 0u, SHELLMATTA_PAYLOAD_MAXLENGTH);
+    uint8_t h2s_sequenceCnt = transportLayer->h2s_sequenceCnt;
+    uint8_t s2h_sequenceCnt = transportLayer->s2h_sequenceCnt;
+    memset(transportLayer, 0u, sizeof(shellmatta_transport_layer_t));
+
+    transportLayer->h2s_sequenceCnt = h2s_sequenceCnt;
+    transportLayer->s2h_sequenceCnt = s2h_sequenceCnt;
 
     return SHELLMATTA_OK;
 }
@@ -74,25 +45,26 @@ shellmatta_retCode_t shellmatta_reset_transport(void)
  * @return      errorcode   #SHELLMATTA_OK\n
  *                          #SHELLMATTA_ERROR   in case of crc error
  */
-shellmatta_retCode_t shellmatta_handle_transport_fsm(char *data)
+shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_t *transportLayer,
+                                                     char *data)
 {
     shellmatta_retCode_t ret = SHELLMATTA_OK;
 
-    switch (transportLayerInst.state)
+    switch (transportLayer->state)
     {
         /* look for start of header */
     case STATE_GET_SOH:
         /* if start of header is found, continue transport layer fsm */
         if (SHELLMATTA_START_OF_HEADER == *data)
         {
-            transportLayerInst.state = STATE_GET_PROTOCOL_VERSION;
-            transportLayerInst.active = true;
+            transportLayer->state = STATE_GET_PROTOCOL_VERSION;
+            transportLayer->active = true;
         }
         else if (0x00 != *data)
         {
             /* if SOH is not found, handle data as manual input */
-            transportLayerInst.state = STATE_MANUAL_INPUT;
-            transportLayerInst.active = false;
+            transportLayer->state = STATE_MANUAL_INPUT;
+            transportLayer->active = false;
         }
         break;
 
@@ -104,102 +76,102 @@ shellmatta_retCode_t shellmatta_handle_transport_fsm(char *data)
         /* check protocol version */
         if (PROTOCOL_VERSION == *data)
         {
-            transportLayerInst.state = STATE_GET_PACKET_TYPE;
+            transportLayer->state = STATE_GET_PACKET_TYPE;
         }
         else
         {
             /* reset fsm in case of wrong protocol version */
-            transportLayerInst.state = STATE_GET_SOH;
-            transportLayerInst.active = false;
+            transportLayer->state = STATE_GET_SOH;
+            transportLayer->active = false;
         }
         break;
 
     /* read packet type */
     case STATE_GET_PACKET_TYPE:
-        transportLayerInst.state = STATE_GET_PAYLOAD_LENGTH;
+        transportLayer->state = STATE_GET_PAYLOAD_LENGTH;
         break;
 
     /* look for length of payload */
     case STATE_GET_PAYLOAD_LENGTH:
-        transportLayerInst.state = STATE_GET_SOURCE;
+        transportLayer->state = STATE_GET_SOURCE;
         break;
 
     /* look for source */
     case STATE_GET_SOURCE:
-        transportLayerInst.state = STATE_GET_DESTINATION;
+        transportLayer->state = STATE_GET_DESTINATION;
         break;
 
     /* look for destination */
     case STATE_GET_DESTINATION:
-        transportLayerInst.state = STATE_GET_H2S_SEQUENCE_CNT;
+        transportLayer->state = STATE_GET_H2S_SEQUENCE_CNT;
         break;
 
     /* look for h2s sequence counter*/
     case STATE_GET_H2S_SEQUENCE_CNT:
-        transportLayerInst.state = STATE_GET_S2H_SEQUENCE_CNT;
+        transportLayer->state = STATE_GET_S2H_SEQUENCE_CNT;
         break;
 
     /* look for s2h sequence counter */
     case STATE_GET_S2H_SEQUENCE_CNT:
-        if (packetType == PACKET_SEQ_CNT_REQUEST)
+        if (transportLayer->packetType == PACKET_SEQ_CNT_REQUEST)
         {
-            transportLayerInst.state = STATE_GET_CRC;
+            transportLayer->state = STATE_GET_CRC;
         }
         else
         {
-            transportLayerInst.state = STATE_GET_PAYLOAD;
+            transportLayer->state = STATE_GET_PAYLOAD;
         }
         break;
 
     /* read payload for previously read length of payload */
     case STATE_GET_PAYLOAD:
-        if (    (payloadLength <= payloadCounter)
-            &&  (true == transportLayerInst.active))
+        if (    (transportLayer->payloadLength <= transportLayer->payloadCounter)
+            &&  (true == transportLayer->active))
         {
-            transportLayerInst.state = STATE_GET_CRC;
+            transportLayer->state = STATE_GET_CRC;
         }
         break;
 
     /* read crc32 for four bytes */
     case STATE_GET_CRC:
         /* if crc32 is read, start computing */
-        if (SHELLMATTA_LENGTH_CRC <= crcCounter)
+        if (SHELLMATTA_LENGTH_CRC <= transportLayer->crcCounter)
         {
             /* for crc computation only */
             char crcdata[SHELLMATTA_PAYLOAD_MAXLENGTH + SHELLMATTA_HEADER_LENGTH];
             memset(crcdata, 0u, SHELLMATTA_PAYLOAD_MAXLENGTH + SHELLMATTA_HEADER_LENGTH);
             crcdata[SHELLMATTA_POS_SOH]         = SHELLMATTA_START_OF_HEADER;
-            crcdata[SHELLMATTA_POS_PROT_VER]    = protocolVersion;
-            crcdata[SHELLMATTA_POS_PACKET_TYPE] = packetType;
-            crcdata[SHELLMATTA_POS_PAYLOAD_LEN] = payloadLength;
-            crcdata[SHELLMATTA_POS_SRC]         = source;
-            crcdata[SHELLMATTA_POS_DST]         = destination;
-            crcdata[SHELLMATTA_POS_CNT_H2S]     = packetSequenceCounter_h2s;
-            crcdata[SHELLMATTA_POS_CNT_S2H]     = packetSequenceCounter_s2h;
-            strncat(&crcdata[SHELLMATTA_POS_PAYLOAD], payloadBuffer, payloadLength);
+            crcdata[SHELLMATTA_POS_PROT_VER]    = transportLayer->protocolVersion;
+            crcdata[SHELLMATTA_POS_PACKET_TYPE] = transportLayer->packetType;
+            crcdata[SHELLMATTA_POS_PAYLOAD_LEN] = transportLayer->payloadLength;
+            crcdata[SHELLMATTA_POS_SRC]         = transportLayer->source;
+            crcdata[SHELLMATTA_POS_DST]         = transportLayer->destination;
+            crcdata[SHELLMATTA_POS_CNT_H2S]     = transportLayer->packetSequenceCounter_h2s;
+            crcdata[SHELLMATTA_POS_CNT_S2H]     = transportLayer->packetSequenceCounter_s2h;
+            strncat(&crcdata[SHELLMATTA_POS_PAYLOAD], transportLayer->payloadBuffer, transportLayer->payloadLength);
 
             uint32_t refCrc;
 
-            refCrc = crc32Calc(crcdata, SHELLMATTA_HEADER_LENGTH + payloadLength);
+            refCrc = crc32Calc(crcdata, SHELLMATTA_HEADER_LENGTH + transportLayer->payloadLength);
 
             /* if crc is correct, further handling of data depends on type of packet */
-            if (crc32 == refCrc)
+            if (transportLayer->crc32 == refCrc)
             {
                 /* reset fsm by default */
-                transportLayerInst.state = STATE_GET_SOH;
+                transportLayer->state = STATE_GET_SOH;
 
                 /* crc is correct */
-                transportLayerInst.h2s_sequenceCnt++;
+                transportLayer->h2s_sequenceCnt++;
 
-                switch (packetType)
+                switch (transportLayer->packetType)
                 {
                 case PACKET_DATA:
-                    transportLayerInst.state = STATE_PROCESS_PAYLOAD;
+                    transportLayer->state = STATE_PROCESS_PAYLOAD;
                     break;
                 
                 case PACKET_SEQ_CNT_REQUEST:
                     /* change packet type to response */
-                    packetType = PACKET_SEQ_CNT_RESPOND;
+                    transportLayer->packetType = PACKET_SEQ_CNT_RESPOND;
                     /* send out packet with no payload */
                     shellmatta_write_transport("", 0u);
                     break;
@@ -228,36 +200,36 @@ shellmatta_retCode_t shellmatta_handle_transport_fsm(char *data)
                 /* wrong packet type */
                 default:
                     /* undo sequence counter increment */
-                    transportLayerInst.h2s_sequenceCnt--;
+                    transportLayer->h2s_sequenceCnt--;
                     break;
                 }
             }
             else
             {
-                transportLayerInst.state = STATE_GET_SOH;
+                transportLayer->state = STATE_GET_SOH;
                 /* crc is incorrect */
                 ret = SHELLMATTA_ERROR;
             }
 
             /* reset crc variables */
-            crcCounter = 0u;
-            crc32 = 0u;
+            transportLayer->crcCounter = 0u;
+            transportLayer->crc32 = 0u;
         }
         break;
 
     /* start to process payload as if it was entered manually */
     case STATE_PROCESS_PAYLOAD:
-        transportLayerInst.state = STATE_GET_SOH;
-        protocolVersion = 0u;
-        packetType      = PACKET_DATA;
-        payloadLength   = 0u;
-        source          = 0u;
-        destination     = 0u;
-        crc32           = 0u;
-        payloadCounter  = 0u;
-        crcCounter      = 0u;
-        transportLayerInst.active = false;
-        memset(payloadBuffer, 0u, SHELLMATTA_PAYLOAD_MAXLENGTH);
+        transportLayer->state = STATE_GET_SOH;
+        transportLayer->protocolVersion = 0u;
+        transportLayer->packetType      = PACKET_DATA;
+        transportLayer->payloadLength   = 0u;
+        transportLayer->source          = 0u;
+        transportLayer->destination     = 0u;
+        transportLayer->crc32           = 0u;
+        transportLayer->payloadCounter  = 0u;
+        transportLayer->crcCounter      = 0u;
+        transportLayer->active = false;
+        memset(transportLayer->payloadBuffer, 0u, SHELLMATTA_PAYLOAD_MAXLENGTH);
         break;
     
     default:
@@ -279,7 +251,8 @@ shellmatta_retCode_t shellmatta_handle_transport_fsm(char *data)
  * @param[in]   data    pointer to input data to process
  * @return      errorcode   #SHELLMATTA_OK
  */
-shellmatta_retCode_t shellmatta_write_transport(const char* data, uint32_t length)
+shellmatta_retCode_t shellmatta_write_transport(const char* data,
+                                                uint32_t length)
 {
     shellmatta_retCode_t ret = SHELLMATTA_OK;
     
@@ -313,17 +286,17 @@ shellmatta_retCode_t shellmatta_write_transport(const char* data, uint32_t lengt
         splitPayloadLength = splitLength - SHELLMATTA_HEADER_LENGTH - SHELLMATTA_LENGTH_CRC;
 
         /* fill buffer with header data */
-        outputBuffer[SHELLMATTA_POS_SOH] = SHELLMATTA_START_OF_HEADER;           /* start of header */
-        outputBuffer[SHELLMATTA_POS_PROT_VER] = PROTOCOL_VERSION;                     /* protocol version */
-        outputBuffer[SHELLMATTA_POS_PACKET_TYPE] = packetType;                           /* packet type */
-        outputBuffer[SHELLMATTA_POS_PAYLOAD_LEN] = splitPayloadLength;                   /* payload length */
-        outputBuffer[SHELLMATTA_POS_SRC] = 0x00u;                                /* source */
-        outputBuffer[SHELLMATTA_POS_DST] = 0x00u;                                /* destination */
-        outputBuffer[SHELLMATTA_POS_CNT_H2S] = transportLayerInst.h2s_sequenceCnt;   /* sequence counter host to shellmatta */
-        outputBuffer[SHELLMATTA_POS_CNT_S2H] = ++transportLayerInst.s2h_sequenceCnt; /* sequence counter shellmatta to host */
+        outputBuffer[SHELLMATTA_POS_SOH] = SHELLMATTA_START_OF_HEADER;                  /* start of header                      */
+        outputBuffer[SHELLMATTA_POS_PROT_VER] = PROTOCOL_VERSION;                       /* protocol version                     */
+        outputBuffer[SHELLMATTA_POS_PACKET_TYPE] = transportLayerInt->packetType;       /* packet type                          */
+        outputBuffer[SHELLMATTA_POS_PAYLOAD_LEN] = splitPayloadLength;                  /* payload length                       */
+        outputBuffer[SHELLMATTA_POS_SRC] = 0x00u;                                       /* source                               */
+        outputBuffer[SHELLMATTA_POS_DST] = 0x00u;                                       /* destination                          */
+        outputBuffer[SHELLMATTA_POS_CNT_H2S] = transportLayerInt->h2s_sequenceCnt;      /* sequence counter host to shellmatta  */
+        outputBuffer[SHELLMATTA_POS_CNT_S2H] = ++transportLayerInt->s2h_sequenceCnt;    /* sequence counter shellmatta to host  */
 
         /* skip copying of payload in case of sequence counter response */
-        if (packetType != PACKET_SEQ_CNT_RESPOND)
+        if (transportLayerInt->packetType != PACKET_SEQ_CNT_RESPOND)
         {
             memcpy(&outputBuffer[SHELLMATTA_POS_PAYLOAD], data + processedLength, splitPayloadLength);
         }
@@ -337,7 +310,7 @@ shellmatta_retCode_t shellmatta_write_transport(const char* data, uint32_t lengt
         outputBuffer[splitPayloadLength + SHELLMATTA_HEADER_LENGTH + SHELLMATTA_SHIFT_BY_3] = (uint8_t)(outCrc);
 
         /* use original write function to send full buffer */
-        ret = transportLayerInst.originalWrite((char*) outputBuffer, splitLength);
+        ret = transportLayerInt->originalWrite((char*) outputBuffer, splitLength);
         processedLength += splitPayloadLength;
     }
     while (processedLength < outPayloadLength);

src/shellmatta_transport.h

@@ -14,9 +14,6 @@
 /** @brief value of start-of-header character */
 #define SHELLMATTA_START_OF_HEADER          0x01u
 
-/* payload length defines */
-/** @brief max length of a plain data payload */
-#define SHELLMATTA_PAYLOAD_MAXLENGTH        ((uint8_t)(255))
 /** @brief max length of a request sequence counters payload */
 #define SHELLMATTA_PAYLOAD_LEN_SEQ_REQ      ((uint8_t)(0))
 /** @brief max length of a respond sequence counters payload */
@@ -66,72 +63,15 @@
 #define SHELLMATTA_SHIFT_BY_16              ((uint8_t)(16))
 #define SHELLMATTA_SHIFT_BY_24              ((uint8_t)(24))
 
-/**
- * @brief definition of shellmatta transport layer states
- */
-typedef enum
-{
-    STATE_GET_SOH                =0u,   /**< start of header state of transport layer */
-    STATE_MANUAL_INPUT              ,
-    STATE_GET_PROTOCOL_VERSION      ,   /**< protocol version state of transport layer */
-    STATE_GET_PACKET_TYPE           ,   /**< packet type state of transport layer */
-    STATE_GET_PAYLOAD_LENGTH        ,   /**< payload length state of transport layer */
-    STATE_GET_SOURCE                ,   /**< source state of transport layer */
-    STATE_GET_DESTINATION           ,   /**< destination state of transport layer */
-    STATE_GET_H2S_SEQUENCE_CNT      ,   /**< host to shellmatta sequence counter state of transport layer */
-    STATE_GET_S2H_SEQUENCE_CNT      ,   /**< shellmatta to host sequence counter state of transport layer */
-    STATE_GET_PAYLOAD               ,   /**< payload state of transport layer */
-    STATE_GET_CRC                   ,   /**< crc state of transport layer */
-    STATE_PROCESS_PAYLOAD
-} shellmatta_transport_state_t;
-
-/**
- * @brief definition of shellmatta transport layer packet types
- */
-typedef enum
-{
-    PACKET_DATA                     = 0x00u,    /**< packet type to send plain data */
-    PACKET_SEQ_CNT_REQUEST          = 0x01u,    /**< packet type to request sequence counters */
-    PACKET_SEQ_CNT_RESPOND          = 0x81u,    /**< packet type to respond with sequence counters */
-    PACKET_MAX_BUFFERSIZE_REQUEST   = 0x02u,    /**< packet type to set and request max buffersize */
-    PACKET_MAX_BUFFERSIZE_RESPOND   = 0x82u,    /**< packet type to respond with max buffersize */
-    PACKET_SEARCH_DEVICE_REQUEST    = 0x03u,    /**< UNUSED: packet type to request search for a device by unique id */
-    PACKET_SEARCH_DEVICE_RESPOND    = 0x83u,    /**< UNUSED: packet type to respond with search results */
-    PACKET_SET_ADDRESS_REQUEST      = 0x04u,    /**< UNUSED: packet type to set and request an address */
-    PACKET_SET_ADDRESS_RESPOND      = 0x84u     /**< UNUSED: packet type to respond with a set address */
-} shellmatta_transport_packet_t;
-
-typedef struct
-{
-    uint8_t h2s_sequenceCnt;                /**<  */
-    uint8_t s2h_sequenceCnt;                /**<  */
-    shellmatta_transport_state_t state;     /**<  */
-    bool mandatory;                         /**<  */
-    bool active;                            /**<  */
-    bool continueStep;                      /**<  */
-    shellmatta_write_t originalWrite;       /**<  */
-} shellmatta_transport_layer_t;
-
-extern uint8_t protocolVersion;
-extern shellmatta_transport_packet_t packetType;
-extern uint32_t payloadLength;
-extern uint8_t source;
-extern uint8_t destination;
-extern uint32_t crc32;
-extern uint8_t payloadCounter;
-extern uint8_t crcCounter;
-extern uint8_t packetSequenceCounter_h2s;
-extern uint8_t packetSequenceCounter_s2h;
-extern char payloadBuffer[SHELLMATTA_PAYLOAD_MAXLENGTH];
-
-extern shellmatta_transport_layer_t transportLayerInst;
 
-shellmatta_retCode_t shellmatta_reset_transport(void);
+shellmatta_retCode_t shellmatta_reset_transport(shellmatta_transport_layer_t *transportLayer);
 
-shellmatta_retCode_t shellmatta_init_transport_inst(void);
+shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t *transportLayer);
 
-shellmatta_retCode_t shellmatta_handle_transport_fsm(char *data);
+shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_t *transportLayer,
+                                                     char *data);
 
-shellmatta_retCode_t shellmatta_write_transport(const char* data, uint32_t length);
+shellmatta_retCode_t shellmatta_write_transport(const char* data,
+                                                uint32_t length);
 
 #endif /* _SHELLMATTA_TRANSPORT_H_ */

test/integrationtest/test_integration_transport.cpp

@@ -137,11 +137,11 @@ SCENARIO("Integration test of Transport layer", "[integration, transport]")
                 memset(write_data, 0, sizeof(write_data));
                 write_length = 0u;
                 shellmatta_processData(handle, (char*)"\x01\x01\x01\x00\x00\x00\x00\x00"
-                                                    "\xc4\xa3\x07\xe6", 12u);
+                                                      "\xc4\xa3\x07\xe6", 12u);
                 THEN("The next Sequence counter is returned")
                 {
                     char *dummyData =   (char*)"\x01\x01\x81\x00\x00\x00\x02\x02"
-                                            "\x06\x2b\x10\x90";
+                                               "\x06\x2b\x10\x90";
 
                     CHECK( write_length == 12);
                     REQUIRE( memcmp(write_data, dummyData, 12) == 0);