fixing global naming conventions, messing around wir docs etc.

api/shellmatta.h

@@ -119,28 +119,39 @@ typedef struct shellmatta_cmd
  */
 typedef enum
 {
-    SHELLMATTA_TRANSPORT_STATE_WAIT         =0u ,   /**< wait for start of header   */
-    SHELLMATTA_TRANSPORT_STATE_GET_HEADER       ,   /**< read in header             */
-    SHELLMATTA_TRANSPORT_STATE_GET_PAYLOAD      ,   /**< read in payload            */
-    SHELLMATTA_TRANSPORT_STATE_GET_CRC          ,   /**< read crc and process data  */
+    SHELLMATTA_TRANSPORT_STATE_WAIT = 0u    ,   /**< wait for start of header   */
+    SHELLMATTA_TRANSPORT_STATE_GET_HEADER   ,   /**< read in header             */
+    SHELLMATTA_TRANSPORT_STATE_GET_PAYLOAD  ,   /**< read in payload            */
+    SHELLMATTA_TRANSPORT_STATE_GET_CRC      ,   /**< read crc and process data  */
 } shellmatta_transport_state_t;
 
-/* payload length defines */
+
 /** @brief max length of a plain data payload */
 #define SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH           ((uint8_t)(255))
 
+/**
+ * @brief structure of one shellmatta transport header
+ */
+typedef struct __attribute__((__packed__))
+{
+    uint8_t startOfHeader;      /** start of header field               */
+    uint8_t protocolVersion;    /** protocol version of the packet      */
+    uint8_t packetType;         /** type of the packet                  */
+    uint8_t payloadLength;      /** length of the payload               */
+    uint8_t source;             /** source of the packet                */
+    uint8_t destination;        /** destination of the packet           */
+    uint8_t sequenceH2S;        /** sequence counter host to shellmatta */
+    uint8_t sequenceS2H;        /** sequence counter shellmatta to host */
+} shellmatta_transport_header_t;
+
+/**
+ * @brief structure of one shellmatta transport packet
+ */
 typedef struct __attribute__((__packed__))
 {
-    uint8_t startOfHeader;
-    uint8_t protocolVersion;
-    uint8_t packetType;
-    uint8_t payloadLength;
-    uint8_t source;
-    uint8_t destination;
-    uint8_t sequenceH2S;
-    uint8_t sequenceS2H;
-    char payload[SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH];
-    uint32_t checksum;
+    shellmatta_transport_header_t   header;                                         /**< header of the packet   */
+    char                            payload[SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH]; /**< payload of the packet  */
+    uint32_t                        crc;                                            /**< crc of the packet      */
 } shellmatta_transport_packet_t;
 
 /**
@@ -148,18 +159,17 @@ typedef struct __attribute__((__packed__))
  */
 typedef struct
 {
-    shellmatta_transport_state_t state;                 /**<  */
-    bool active;                                        /**<  */
-    bool mandatory;                                     /**<  */
-    bool continueStep;                                  /**<  */
-    uint8_t sequenceH2S;                                /**< TODO */
-    uint8_t sequenceS2H;                                /**<  */
-    shellmatta_write_t originalWrite;                   /**<  */
-    uint32_t headerIndex;                               /**<  */
-    uint32_t payloadIndex;                              /**<  */
-    uint32_t crcIndex;                                  /**<  */
-    shellmatta_transport_packet_t packetBuffer;         /**<  */
-    shellmatta_transport_packet_t outputPacketBuffer;   /**<  */
+    shellmatta_transport_state_t    state;          /**< current state of the transport layer reception */
+    bool                            active;         /**< is transport layer communication active        */
+    bool                            mandatory;      /**< is the transport layer enforced                */
+    uint8_t                         sequenceH2S;    /**< sequence counter host to shellmatta            */
+    uint8_t                         sequenceS2H;    /**< sequenc counter shellmatta to host             */
+    uint32_t                        headerIndex;    /**< read indey of the header                       */
+    uint32_t                        payloadIndex;   /**< read index of the payload                      */
+    uint32_t                        crcIndex;       /**< read index of the checmsum                     */
+    shellmatta_transport_packet_t   inPacket;       /**< buffer for the received packets                */
+    shellmatta_transport_packet_t   outPacket;      /**< buffer for the sent packets                    */
+    shellmatta_write_t              writeFct;       /**< shellmatta write function                      */
 } shellmatta_transport_layer_t;
 
 /**

src/shellmatta_transport.c

@@ -10,7 +10,6 @@
 #include <string.h>
 
 
-
 /**
  * @brief   create a secured packet and pass it to the shellmatta write function
  *
@@ -24,30 +23,32 @@
 static shellmatta_retCode_t shellmatta_transport_send(shellmatta_transport_layer_t *transportLayer,
                                                       shellmatta_transport_packet_t *packet)
 {
-    uint32_t checksum;
-    char *rawPacketBuffer = (char*)packet;
+    uint32_t crc;
+    char *rawPacket = (char*)packet;
+    shellmatta_transport_header_t *header = &packet->header;
 
     /** -# fill header */
-    packet->startOfHeader   = SHELLMATTA_START_OF_HEADER;
-    packet->protocolVersion = PROTOCOL_VERSION;
-    packet->source          = 0;
-    packet->destination     = 0;
-    packet->sequenceH2S     = transportLayer->sequenceH2S;
-    packet->sequenceS2H     = ++transportLayer->sequenceS2H;
+    header->startOfHeader   = SHELLMATTA_TRANSPORT_START_OF_HEADER;
+    header->protocolVersion = SHELLMATTA_TRANSPORT_PROTOCOL_VERSION;
+    header->source          = 0;
+    header->destination     = 0;
+    header->sequenceH2S     = transportLayer->sequenceH2S;
+    header->sequenceS2H     = ++transportLayer->sequenceS2H;
 
-    checksum = crc32Calc((char*) packet, SHELLMATTA_HEADER_LENGTH + packet->payloadLength);
+    crc = crc32Calc((char*) packet, SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength);
 
     /* append crc to end of payload */
-    rawPacketBuffer[SHELLMATTA_HEADER_LENGTH + packet->payloadLength] = (uint8_t)(checksum >> SHELLMATTA_SHIFT_BY_24);
-    rawPacketBuffer[SHELLMATTA_HEADER_LENGTH + packet->payloadLength + SHELLMATTA_SHIFT_BY_1] = (uint8_t)(checksum >> SHELLMATTA_SHIFT_BY_16);
-    rawPacketBuffer[SHELLMATTA_HEADER_LENGTH + packet->payloadLength + SHELLMATTA_SHIFT_BY_2] = (uint8_t)(checksum >> SHELLMATTA_SHIFT_BY_8);
-    rawPacketBuffer[SHELLMATTA_HEADER_LENGTH + packet->payloadLength + SHELLMATTA_SHIFT_BY_3] = (uint8_t)(checksum);
+    rawPacket[SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength] = (uint8_t)(crc >> 24u);
+    rawPacket[SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength + 1u] = (uint8_t)(crc >> 16u);
+    rawPacket[SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength + 2u] = (uint8_t)(crc >> 8u);
+    rawPacket[SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength + 3u] = (uint8_t)(crc);
 
     /* use original write function to send full buffer */
-    return transportLayer->originalWrite((char*) rawPacketBuffer, SHELLMATTA_HEADER_LENGTH + packet->payloadLength + SHELLMATTA_LENGTH_CRC);
+    return transportLayer->writeFct((char*) rawPacket,
+                                    SHELLMATTA_TRANSPORT_LENGTH_STATIC +
+                                    header->payloadLength);
 }
 
-
 /**
  * @brief           Initializes the transportLayerInst
  * @param[in, out]  transportLayer  transport layer instance to work on
@@ -58,7 +59,7 @@ shellmatta_retCode_t shellmatta_transport_init( shellmatta_transport_layer_t
                                                 shellmatta_write_t              writeFct)
 {
     memset(transportLayer, 0u, sizeof(shellmatta_transport_layer_t));
-    transportLayer->originalWrite = writeFct;
+    transportLayer->writeFct = writeFct;
 
     return SHELLMATTA_OK;
 }
@@ -96,29 +97,38 @@ shellmatta_retCode_t shellmatta_transport_process(shellmatta_transport_layer_t
                                                   uint32_t                       *length)
 {
     shellmatta_retCode_t ret = SHELLMATTA_BUSY;
-    char *rawPacketBuffer = (char*)&transportLayer->packetBuffer;
+    char *rawPacket = (char*)&transportLayer->inPacket;
+    shellmatta_transport_header_t *header = &transportLayer->inPacket.header;
     shellmatta_transport_packet_int_t intPacket;
     uint32_t refCrc;
 
     switch (transportLayer->state)
     {
-    /* look for start of header */
+    /** -# look for start of header */
     case SHELLMATTA_TRANSPORT_STATE_WAIT:
-        /* if start of header is found, continue transport layer fsm */
-        if (SHELLMATTA_START_OF_HEADER == byte)
+        /** -# if start of header is found, continue transport layer fsm */
+        if (SHELLMATTA_TRANSPORT_START_OF_HEADER == byte)
         {
-            memset(&transportLayer->packetBuffer, 0, sizeof(transportLayer->packetBuffer));
+            memset(&transportLayer->inPacket, 0, sizeof(transportLayer->inPacket));
             transportLayer->headerIndex = 1u;
             transportLayer->payloadIndex = 0u;
             transportLayer->crcIndex = 0u;
-            transportLayer->packetBuffer.startOfHeader = byte;
+            header->startOfHeader = byte;
             transportLayer->state = SHELLMATTA_TRANSPORT_STATE_GET_HEADER;
         }
+        else if((true == transportLayer->mandatory))
+        {
+            /** -# if transport layer is mandatory - throw away unrecognized bytes */
+            *data = transportLayer->inPacket.payload;
+            *length = 0;
+            transportLayer->active = true;
+            ret = SHELLMATTA_OK;
+        }
         else
         {
-            /* just pass the payload as is */
-            transportLayer->packetBuffer.payload[0] = byte;
-            *data = transportLayer->packetBuffer.payload;
+            /** -# otherwise just pass the payload as is */
+            transportLayer->inPacket.payload[0] = byte;
+            *data = transportLayer->inPacket.payload;
             *length = 1;
             transportLayer->active = false;
             ret = SHELLMATTA_OK;
@@ -127,13 +137,13 @@ shellmatta_retCode_t shellmatta_transport_process(shellmatta_transport_layer_t
 
     case SHELLMATTA_TRANSPORT_STATE_GET_HEADER:
 
-        rawPacketBuffer[transportLayer->headerIndex] = byte;
+        rawPacket[transportLayer->headerIndex] = byte;
         transportLayer->headerIndex ++;
 
-        if (transportLayer->headerIndex == SHELLMATTA_HEADER_LENGTH)
+        if (transportLayer->headerIndex == SHELLMATTA_TRANSPORT_LENGTH_HEADER)
         {
             //TODO check for errors in header data
-            if (0u != transportLayer->packetBuffer.payloadLength)
+            if (0u != header->payloadLength)
             {
                 transportLayer->state = SHELLMATTA_TRANSPORT_STATE_GET_PAYLOAD;
             }
@@ -148,10 +158,10 @@ shellmatta_retCode_t shellmatta_transport_process(shellmatta_transport_layer_t
     /* read payload for previously read length of payload */
     case SHELLMATTA_TRANSPORT_STATE_GET_PAYLOAD:
 
-        transportLayer->packetBuffer.payload[transportLayer->payloadIndex] = byte;
+        transportLayer->inPacket.payload[transportLayer->payloadIndex] = byte;
         transportLayer->payloadIndex ++;
 
-        if (transportLayer->payloadIndex >= transportLayer->packetBuffer.payloadLength)
+        if (transportLayer->payloadIndex >= header->payloadLength)
         {
             transportLayer->state = SHELLMATTA_TRANSPORT_STATE_GET_CRC;
         }
@@ -161,14 +171,14 @@ shellmatta_retCode_t shellmatta_transport_process(shellmatta_transport_layer_t
     case SHELLMATTA_TRANSPORT_STATE_GET_CRC:
 
         transportLayer->crcIndex ++;
-        transportLayer->packetBuffer.checksum |= ((uint8_t)byte << ((SHELLMATTA_LENGTH_CRC - transportLayer->crcIndex) * 8u));
+        transportLayer->inPacket.crc |= ((uint8_t)byte << ((SHELLMATTA_TRANSPORT_LENGTH_CRC - transportLayer->crcIndex) * 8u));
 
-        if (transportLayer->crcIndex >= SHELLMATTA_LENGTH_CRC)
+        if (transportLayer->crcIndex >= SHELLMATTA_TRANSPORT_LENGTH_CRC)
         {
-            refCrc = crc32Calc(rawPacketBuffer, SHELLMATTA_HEADER_LENGTH + transportLayer->packetBuffer.payloadLength);
+            refCrc = crc32Calc(rawPacket, SHELLMATTA_TRANSPORT_LENGTH_HEADER + header->payloadLength);
 
             /* if crc is correct, further handling of data depends on type of packet */
-            if (transportLayer->packetBuffer.checksum == refCrc)
+            if (transportLayer->inPacket.crc == refCrc)
             {
 
                 transportLayer->active = true;
@@ -176,19 +186,19 @@ shellmatta_retCode_t shellmatta_transport_process(shellmatta_transport_layer_t
                 /* crc is correct */
                 transportLayer->sequenceH2S++;
 
-                switch (transportLayer->packetBuffer.packetType)
+                switch (header->packetType)
                 {
                 case SHELLMATTA_TRANSPORT_PACKET_DATA:
                     /** return pointer to payload and length */
-                    *data = (char*)&transportLayer->packetBuffer.payload;
-                    *length = transportLayer->packetBuffer.payloadLength;
+                    *data = (char*)&transportLayer->inPacket.payload;
+                    *length = header->payloadLength;
                     ret = SHELLMATTA_OK;
                     break;
                 
                 case SHELLMATTA_TRANSPORT_PACKET_SEQ_CNT_REQUEST:
                     /* send out packet with no payload */
-                    intPacket.packetType = SHELLMATTA_TRANSPORT_PACKET_SEQ_CNT_RESPOND;
-                    intPacket.payloadLength = 0u;
+                    intPacket.header.packetType = SHELLMATTA_TRANSPORT_PACKET_SEQ_CNT_RESPOND;
+                    intPacket.header.payloadLength = 0u;
                     (void)shellmatta_transport_send(transportLayer, (shellmatta_transport_packet_t *)&intPacket);
                     break;
 
@@ -257,7 +267,8 @@ shellmatta_retCode_t shellmatta_transport_write(shellmatta_transport_layer_t *tr
 {
     shellmatta_retCode_t ret = SHELLMATTA_OK;
     uint32_t outPayloadLength = length;
-    shellmatta_transport_packet_t *packet = &transportLayer->outputPacketBuffer;
+    shellmatta_transport_packet_t *packet = &transportLayer->outPacket;
+    shellmatta_transport_header_t *header = &transportLayer->outPacket.header;
 
     /* handle data with length bigger than max length */
     uint32_t processedLength    = 0u;
@@ -269,7 +280,7 @@ shellmatta_retCode_t shellmatta_transport_write(shellmatta_transport_layer_t *tr
     /* foot-controlled loop to send packets without payload length */
     do
     {
-        piledUpPayload = transportLayer->outputPacketBuffer.payloadLength;
+        piledUpPayload = header->payloadLength;
 
         /* compute length of next payload split */
         restOfPayload = (outPayloadLength - processedLength);
@@ -279,20 +290,20 @@ shellmatta_retCode_t shellmatta_transport_write(shellmatta_transport_layer_t *tr
         }
         else
         {
-            splitLength = (restOfPayload + SHELLMATTA_HEADER_LENGTH + SHELLMATTA_LENGTH_CRC) % SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH;
+            splitLength = (restOfPayload + SHELLMATTA_TRANSPORT_LENGTH_STATIC) % SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH;
         }
-        splitPayloadLength = splitLength - SHELLMATTA_HEADER_LENGTH - SHELLMATTA_LENGTH_CRC;
+        splitPayloadLength = splitLength - SHELLMATTA_TRANSPORT_LENGTH_STATIC;
 
         (void)memcpy(&packet->payload[piledUpPayload], &data[processedLength], splitPayloadLength);
-        packet->payloadLength += splitPayloadLength;
+        header->payloadLength += splitPayloadLength;
         processedLength += splitPayloadLength;
 
-        if(packet->payloadLength >= SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH)
+        if(header->payloadLength >= SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH)
         {
             /** -# packet is full - send */
-            packet->packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
-            ret = shellmatta_transport_send(transportLayer, &transportLayer->outputPacketBuffer);
-            transportLayer->outputPacketBuffer.payloadLength = 0u;
+            header->packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
+            ret = shellmatta_transport_send(transportLayer, packet);
+            header->payloadLength = 0u;
         }
     }
     while (processedLength < outPayloadLength);
@@ -308,13 +319,13 @@ shellmatta_retCode_t shellmatta_transport_write(shellmatta_transport_layer_t *tr
 shellmatta_retCode_t shellmatta_transport_flush(shellmatta_transport_layer_t *transportLayer)
 {
     shellmatta_retCode_t ret = SHELLMATTA_OK;
-    shellmatta_transport_packet_t *packet = &transportLayer->outputPacketBuffer;
+    shellmatta_transport_packet_t *packet = &transportLayer->outPacket;
 
-    if(0 != transportLayer->outputPacketBuffer.payloadLength)
+    if(0 != packet->header.payloadLength)
     {
-        packet->packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
-        ret = shellmatta_transport_send(transportLayer, &transportLayer->outputPacketBuffer);
-        packet->payloadLength = 0u;
+        packet->header.packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
+        ret = shellmatta_transport_send(transportLayer, &transportLayer->outPacket);
+        packet->header.payloadLength = 0u;
     }
 
     return ret;

src/shellmatta_transport.h

@@ -12,71 +12,23 @@
 /** @brief packet definition with reduced payload (for internal packets) */
 typedef struct __attribute__((__packed__))
 {
-    uint8_t startOfHeader;
-    uint8_t protocolVersion;
-    uint8_t packetType;
-    uint8_t payloadLength;
-    uint8_t source;
-    uint8_t destination;
-    uint8_t sequenceH2S;
-    uint8_t sequenceS2H;
-    //char payload[SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH];
-    uint32_t checksum;
+    shellmatta_transport_header_t   header; /**< header of the packet   */
+    //char payload[SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH]; TODO - this has to be the maximum needed internal payload
+    uint32_t                        crc;    /**< checksum of the packet */
 } shellmatta_transport_packet_int_t;
 
-#define PROTOCOL_VERSION                    0x01u
-
 /** @brief value of start-of-header character */
-#define SHELLMATTA_START_OF_HEADER          0x01u
-
-/** @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 */
-#define SHELLMATTA_PAYLOAD_LEN_SEQ_RES      ((uint8_t)(0))
-/** @brief max length of a request buffersize payload */
-#define SHELLMATTA_PAYLOAD_LEN_BUFSIZE_REQ  ((uint8_t)(1))
-/** @brief max length of a respond buffersize payload */
-#define SHELLMATTA_PAYLOAD_LEN_BUFSIZE_RES  ((uint8_t)(1))
+#define SHELLMATTA_TRANSPORT_START_OF_HEADER    0x01u
+/** @brief currently supported protocol version */
+#define SHELLMATTA_TRANSPORT_PROTOCOL_VERSION   0x01u
 
 /* header field length defines */
-#define SHELLMATTA_HEADER_LENGTH            ((uint8_t)(8))
-/** @brief length of headerfield: start of header */
-#define SHELLMATTA_LENGTH_SOH               ((uint8_t)(1))
-/** @brief length of headerfield: protocol version */
-#define SHELLMATTA_LENGTH_PROT_VERSION      ((uint8_t)(1))
-/** @brief length of headerfield: packet type */
-#define SHELLMATTA_LENGTH_PACKET_TYPE       ((uint8_t)(1))
-/** @brief length of headerfield: payload length */
-#define SHELLMATTA_LENGTH_PAYLOAD_LENGTH    ((uint8_t)(1))
-/** @brief length of headerfield: source */
-#define SHELLMATTA_LENGTH_SOURCE            ((uint8_t)(1))
-/** @brief length of headerfield: destination */
-#define SHELLMATTA_LENGTH_DESTINATION       ((uint8_t)(1))
-/** @brief length of headerfield: host to shell sequence counter */
-#define SHELLMATTA_LENGTH_H2S_SEQUENCE_CNT  ((uint8_t)(1))
-/** @brief length of headerfield: shell to host sequence counter */
-#define SHELLMATTA_LENGTH_S2H_SEQUENCE_CNT  ((uint8_t)(1))
-/** @brief length of headerfield: crc32 of header + payload without crc32 */
-#define SHELLMATTA_LENGTH_CRC               ((uint8_t)(4))
-
-/* positional defines */
-#define SHELLMATTA_POS_SOH                  ((uint8_t)0)
-#define SHELLMATTA_POS_PROT_VER             ((uint8_t)1)
-#define SHELLMATTA_POS_PACKET_TYPE          ((uint8_t)2)
-#define SHELLMATTA_POS_PAYLOAD_LEN          ((uint8_t)3)
-#define SHELLMATTA_POS_SRC                  ((uint8_t)4)
-#define SHELLMATTA_POS_DST                  ((uint8_t)5)
-#define SHELLMATTA_POS_CNT_H2S              ((uint8_t)6)
-#define SHELLMATTA_POS_CNT_S2H              ((uint8_t)7)
-#define SHELLMATTA_POS_PAYLOAD              ((uint8_t)8)
-
-/* utility defines */
-#define SHELLMATTA_SHIFT_BY_1               ((uint8_t)(1))
-#define SHELLMATTA_SHIFT_BY_2               ((uint8_t)(2))
-#define SHELLMATTA_SHIFT_BY_3               ((uint8_t)(3))
-#define SHELLMATTA_SHIFT_BY_8               ((uint8_t)(8))
-#define SHELLMATTA_SHIFT_BY_16              ((uint8_t)(16))
-#define SHELLMATTA_SHIFT_BY_24              ((uint8_t)(24))
+/** @brief length of header */
+#define SHELLMATTA_TRANSPORT_LENGTH_HEADER  ((uint8_t)(8))
+/** @brief length of crc32 */
+#define SHELLMATTA_TRANSPORT_LENGTH_CRC     ((uint8_t)(4))
+/** @brief length of crc32 */
+#define SHELLMATTA_TRANSPORT_LENGTH_STATIC  (SHELLMATTA_TRANSPORT_LENGTH_HEADER + SHELLMATTA_TRANSPORT_LENGTH_CRC)
 
 /**
  * @brief definitions of shellmatta transport layer packet types