added shellmatta transport layer flush method to prevent too much overhead

api/shellmatta.h

@@ -261,6 +261,8 @@ shellmatta_retCode_t shellmatta_opt_long(   shellmatta_handle_t         handle,
                                             char                        **argument,
                                             uint32_t                    *argLen);
 
+shellmatta_retCode_t shellmatta_transport_flush(shellmatta_transport_layer_t *transportLayer);
+
 #ifndef SHELLMATTA_STRIP_PRINTF
 shellmatta_retCode_t shellmatta_printf(     shellmatta_handle_t handle,
                                             const char          *fmt,

src/shellmatta.c

@@ -766,6 +766,8 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
         {
             ret = shellmatta_processDataInt(handle, tmpData, 0);
         }
+
+        (void)shellmatta_transport_flush(&inst->transportLayer);
     }
     else
     {

src/shellmatta_transport.c

@@ -257,16 +257,20 @@ 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;
 
     /* handle data with length bigger than max length */
-    uint16_t processedLength = 0u;
-    uint16_t splitLength = 0u;
-    uint16_t splitPayloadLength = 0u;
-    uint16_t restOfPayload = 0u;
+    uint32_t piledUpPayload;
+    uint32_t processedLength    = 0u;
+    uint32_t splitLength        = 0u;
+    uint32_t splitPayloadLength = 0u;
+    uint32_t restOfPayload      = 0u;
 
     /* foot-controlled loop to send packets without payload length */
     do
     {
+        piledUpPayload = transportLayer->outputPacketBuffer.payloadLength;
+
         /* compute length of next payload split */
         restOfPayload = (outPayloadLength - processedLength);
         if (restOfPayload > SHELLMATTA_TRANPORT_PAYLOAD_MAXLENGTH)
@@ -279,14 +283,39 @@ shellmatta_retCode_t shellmatta_transport_write(shellmatta_transport_layer_t *tr
         }
         splitPayloadLength = splitLength - SHELLMATTA_HEADER_LENGTH - SHELLMATTA_LENGTH_CRC;
 
-        transportLayer->outputPacketBuffer.packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
-        transportLayer->outputPacketBuffer.payloadLength = splitPayloadLength;
-        (void)memcpy(transportLayer->outputPacketBuffer.payload, &data[processedLength], splitPayloadLength);
-
-        ret = shellmatta_transport_send(transportLayer, &transportLayer->outputPacketBuffer);
-
+        (void)memcpy(&packet->payload[piledUpPayload], &data[processedLength], splitPayloadLength);
+        packet->payloadLength += splitPayloadLength;
         processedLength += splitPayloadLength;
+
+        if(packet->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;
+        }
     }
     while (processedLength < outPayloadLength);
     return ret;
 }
+
+/**
+ * @brief           Send out piled up payload
+ * 
+ * @param[in, out]  transportLayer  transport layer instance to work on
+ * @return          errorcode       #SHELLMATTA_OK
+ */
+shellmatta_retCode_t shellmatta_transport_flush(shellmatta_transport_layer_t *transportLayer)
+{
+    shellmatta_retCode_t ret = SHELLMATTA_OK;
+    shellmatta_transport_packet_t *packet = &transportLayer->outputPacketBuffer;
+
+    if(0 != transportLayer->outputPacketBuffer.payloadLength)
+    {
+        packet->packetType = SHELLMATTA_TRANSPORT_PACKET_DATA;
+        ret = shellmatta_transport_send(transportLayer, &transportLayer->outputPacketBuffer);
+        packet->payloadLength = 0u;
+    }
+
+    return ret;
+}

test/integrationtest/test_integration_transport.cpp

@@ -109,23 +109,17 @@ SCENARIO("Integration test of Transport layer", "[integration, transport]")
                                                 "\x7b\x49\xfa\x72", 34u);
             THEN("The shellmatta responds to the command")
             {
-                char *dummyData =   (char*)"\x01\x01\x00\x21\x00\x00\x01\x01"
+                char *dummyData =   (char*)"\x01\x01\x00\x2f\x00\x00\x01\x01"
                                            "doSomething argument - length: 20"
-                                            "\xac\xf5\xe9\x4f"
-                                            "\x01\x01\x00\x02\x00\x00\x01\x02"
-                                            "\r\n"
-                                            "\x62\xef\x22\x7a"
-                                            "\x01\x01\x00\x0C\x00\x00\x01\x03"
-                                            "shellmatta->"
-                                            "\xd2\x0b\x8f\x3e";
-
-                CHECK( write_length == 83);
-                REQUIRE( memcmp(write_data, dummyData, 83) == 0);
+                                           "\r\n"
+                                           "shellmatta->"
+                                           "\xc8\xae\xc0\x56";
 
+                CHECK( write_length == 59);
+                REQUIRE( memcmp(write_data, dummyData, 59) == 0);
             }
         }
 
-
         WHEN("manual mode is used after transport layer mode")
         {
             /* check with valid payload - disable echo to reduce cluttering */
@@ -136,20 +130,16 @@ SCENARIO("Integration test of Transport layer", "[integration, transport]")
             shellmatta_processData(handle, (char*)"doSomething argument\r\n", 22u);
             THEN("The shellmatta responds to the command")
             {
-                char *dummyData =   (char*)"\x01\x01\x00\x21\x00\x00\x01\x01"
+                char *dummyData =   (char*)"\x01\x01\x00\x2f\x00\x00\x01\x01"
                                            "doSomething argument - length: 20"
-                                            "\xac\xf5\xe9\x4f"
-                                            "\x01\x01\x00\x02\x00\x00\x01\x02"
-                                            "\r\n"
-                                            "\x62\xef\x22\x7a"
-                                            "\x01\x01\x00\x0C\x00\x00\x01\x03"
-                                            "shellmatta->"
-                                            "\xd2\x0b\x8f\x3e"
-                                            "doSomething argument - length: 20\r\n"
-                                            "shellmatta->";
-
-                CHECK( write_length == 130);
-                REQUIRE( memcmp(write_data, dummyData, 130) == 0);
+                                           "\r\n"
+                                           "shellmatta->"
+                                           "\xc8\xae\xc0\x56"
+                                           "doSomething argument - length: 20\r\n"
+                                           "shellmatta->";
+
+                CHECK( write_length == 106);
+                REQUIRE( memcmp(write_data, dummyData, 106) == 0);
 
             }
         }