added a helper macro for the write method to switch between transport layer and manual mode

api/shellmatta.h

@@ -119,17 +119,17 @@ typedef struct shellmatta_cmd
  */
 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_GET_SOH                =0u,   /**< start of header state of transport layer                       */
+    STATE_MANUAL_INPUT              ,   /**< state for manual input => transport layer disabled             */
+    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;
 
@@ -138,15 +138,15 @@ typedef enum
  */
 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_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 */
+    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 */
@@ -158,25 +158,24 @@ typedef enum
  */
 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];
+    uint8_t h2s_sequenceCnt;                            /**< TODO */
+    uint8_t s2h_sequenceCnt;                            /**<  */
+    shellmatta_transport_state_t state;                 /**<  */
+    bool mandatory;                                     /**<  */
+    bool active;                                        /**<  */
+    bool continueStep;                                  /**<  */
+    shellmatta_write_t originalWrite;                   /**<  */
+    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;
 
 /**
@@ -221,6 +220,12 @@ typedef struct
     shellmatta_transport_layer_t    transportLayer;     /**< transport layer instance               */
 } shellmatta_instance_t;
 
+/**
+ * @brief helper macro for the send function
+ */
+#define SHELLMATTA_WRITE(data, length)  inst->transportLayer.active == true ?                                                                   \
+                                        shellmatta_write_transport((shellmatta_transport_layer_t*)&inst->transportLayer, (data), (length)) :    \
+                                        inst->write((data), (length))
 
 shellmatta_retCode_t shellmatta_doInit( shellmatta_instance_t   *inst,
                                         shellmatta_handle_t     *handle,

src/shellmatta.c

@@ -116,12 +116,11 @@ shellmatta_retCode_t shellmatta_doInit(
         inst->magic = SHELLMATTA_MAGIC;
         *handle     = (shellmatta_handle_t)inst;
 
+        /* init transport layer */
+        shellmatta_init_transport_inst(&inst->transportLayer, inst->write);
+
         /** -# print the first prompt */
         utils_terminateInput(inst);
-
-        /* init transport layer */
-        shellmatta_init_transport_inst(&inst->transportLayer);
-        inst->transportLayer.originalWrite = inst->write;
     }
 
     return SHELLMATTA_OK;
@@ -465,17 +464,11 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
                 /* processes payload by forwarding it recursively without transport layer to processData() */
                 if (inst->transportLayer.state == STATE_PROCESS_PAYLOAD)
                 {
-                    /* replace inst->write function pointer with transport layer write function */
-                    inst->transportLayer.originalWrite = inst->write;
-                    inst->write = shellmatta_write_transport;
-                    
                     /* recursive call with complete payload */
                     shellmatta_processData(handle,
                                            inst->transportLayer.payloadBuffer,
                                            inst->transportLayer.payloadLength);
-                    
-                    /* set back inst->write function pointer to original */
-                    inst->write = inst->transportLayer.originalWrite;
+
                     shellmatta_handle_transport_fsm(&inst->transportLayer, data);
                     return SHELLMATTA_OK;
                 }
@@ -747,9 +740,9 @@ shellmatta_retCode_t shellmatta_processData(shellmatta_handle_t     handle,
 
                     if ((0u == cmdExecuted) && (inst->inputCount > 0))
                     {
-                        inst->write("\r\nCommand: ", 11u);
-                        inst->write(inst->buffer, inst->inputCount);
-                        inst->write(" not found", 10u);
+                        SHELLMATTA_WRITE("\r\nCommand: ", 11u);
+                        SHELLMATTA_WRITE(inst->buffer, inst->inputCount);
+                        SHELLMATTA_WRITE(" not found", 10u);
                     }
 
                     /** -# terminate this session if no continuous mode is requested */
@@ -844,7 +837,7 @@ shellmatta_retCode_t shellmatta_write(  shellmatta_handle_t handle,
         &&  (SHELLMATTA_MAGIC   == inst->magic))
     {
         /** -# pass the data to the write function of the instance  */
-        ret = inst->write(data, length);
+        ret = SHELLMATTA_WRITE(data, length);
     }
 
     return ret;
@@ -920,7 +913,7 @@ shellmatta_retCode_t shellmatta_printf( shellmatta_handle_t handle,
         }
         else
         {
-            inst->write(outputBuffer, length);
+            SHELLMATTA_WRITE(outputBuffer, length);
         }
     }
     else

src/shellmatta_autocomplete.c

@@ -57,11 +57,11 @@ void autocomplete_run(shellmatta_instance_t *inst)
                 /** -# add newline on first find */
                 if(0u == printedLen)
                 {
-                    inst->write("\r\n", 2u);
+                    SHELLMATTA_WRITE("\r\n", 2u);
                 }
-                inst->write(cmd->cmd, strlen(cmd->cmd));
+                SHELLMATTA_WRITE(cmd->cmd, strlen(cmd->cmd));
                 printedLen += strlen(cmd->cmd);
-                inst->write("    ", 4u);
+                SHELLMATTA_WRITE("    ", 4u);
                 printedLen += 4u;
             }
             /** -# check if command alias matches the input */
@@ -72,11 +72,11 @@ void autocomplete_run(shellmatta_instance_t *inst)
                 /** -# add newline on first find */
                 if(0u == printedLen)
                 {
-                    inst->write("\r\n", 2u);
+                    SHELLMATTA_WRITE("\r\n", 2u);
                 }
-                inst->write(cmd->cmdAlias, strlen(cmd->cmdAlias));
+                SHELLMATTA_WRITE(cmd->cmdAlias, strlen(cmd->cmdAlias));
                 printedLen += strlen(cmd->cmdAlias);
-                inst->write("    ", 4u);
+                SHELLMATTA_WRITE("    ", 4u);
                 printedLen += 4u;
             }
             cmd = cmd->next;

src/shellmatta_transport.c

@@ -5,27 +5,30 @@
  */
 
 #include "shellmatta_transport.h"
+#include "shellmatta.h"
 #include "shellmatta_crc.h"
 #include <string.h>
 
 
-static shellmatta_transport_layer_t *transportLayerInt;
-
 /**
- * @brief       Initializes the transportLayerInst
- * @return      errorcode   #SHELLMATTA_OK
+ * @brief           Initializes the transportLayerInst
+ * @param[in, out]  transportLayer  transport layer instance to work on
+ * @param[in]       writeFct        function pointer to output function
+ * @return          errorcode       #SHELLMATTA_OK
  */
-shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t *transportLayer)
+shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t    *transportLayer,
+                                                    shellmatta_write_t              writeFct)
 {
-    transportLayerInt = transportLayer;
     memset(transportLayer, 0u, sizeof(shellmatta_transport_layer_t));
+    transportLayer->originalWrite = writeFct;
 
     return SHELLMATTA_OK;
 }
 
 /**
- * @brief       Resets all values of tranportLayerInst except for sequence counters
- * @return      errorcode   #SHELLMATTA_OK
+ * @brief           Resets all values of tranportLayerInst except for sequence counters
+ * @param[in, out]  transportLayer  transport layer instance to work on
+ * @return          errorcode       #SHELLMATTA_OK
  */
 shellmatta_retCode_t shellmatta_reset_transport(shellmatta_transport_layer_t *transportLayer)
 {
@@ -40,10 +43,11 @@ shellmatta_retCode_t shellmatta_reset_transport(shellmatta_transport_layer_t *tr
 }
 
 /**
- * @brief       processes the passed amount of data
- * @param[in]   data    pointer to input data to process
- * @return      errorcode   #SHELLMATTA_OK\n
- *                          #SHELLMATTA_ERROR   in case of crc error
+ * @brief           processes the passed amount of data
+ * @param[in, out]  transportLayer  transport layer instance to work on
+ * @param[in]       data            pointer to input data to process
+ * @return          errorcode       #SHELLMATTA_OK\n
+ *                                  #SHELLMATTA_ERROR   in case of crc error
  */
 shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_t *transportLayer,
                                                      char *data)
@@ -173,7 +177,7 @@ shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_
                     /* change packet type to response */
                     transportLayer->packetType = PACKET_SEQ_CNT_RESPOND;
                     /* send out packet with no payload */
-                    shellmatta_write_transport("", 0u);
+                    shellmatta_write_transport(transportLayer, "", 0u);
                     break;
 
                 case PACKET_SEQ_CNT_RESPOND:
@@ -248,10 +252,12 @@ shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_
  * 
  * @note        If length of data exceeds #UINT8_MAX, data is sent in multiple packets.\n
  * 
- * @param[in]   data    pointer to input data to process
- * @return      errorcode   #SHELLMATTA_OK
+ * @param[in, out]  transportLayer  transport layer instance to work on
+ * @param[in]       data            pointer to input data to process
+ * @return          errorcode       #SHELLMATTA_OK
  */
-shellmatta_retCode_t shellmatta_write_transport(const char* data,
+shellmatta_retCode_t shellmatta_write_transport(shellmatta_transport_layer_t *transportLayer,
+                                                const char* data,
                                                 uint32_t length)
 {
     shellmatta_retCode_t ret = SHELLMATTA_OK;
@@ -288,15 +294,15 @@ shellmatta_retCode_t shellmatta_write_transport(const char* data,
         /* 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] = transportLayerInt->packetType;       /* packet type                          */
+        outputBuffer[SHELLMATTA_POS_PACKET_TYPE] = transportLayer->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  */
+        outputBuffer[SHELLMATTA_POS_CNT_H2S] = transportLayer->h2s_sequenceCnt;      /* sequence counter host to shellmatta  */
+        outputBuffer[SHELLMATTA_POS_CNT_S2H] = ++transportLayer->s2h_sequenceCnt;    /* sequence counter shellmatta to host  */
 
         /* skip copying of payload in case of sequence counter response */
-        if (transportLayerInt->packetType != PACKET_SEQ_CNT_RESPOND)
+        if (transportLayer->packetType != PACKET_SEQ_CNT_RESPOND)
         {
             memcpy(&outputBuffer[SHELLMATTA_POS_PAYLOAD], data + processedLength, splitPayloadLength);
         }
@@ -310,7 +316,7 @@ shellmatta_retCode_t shellmatta_write_transport(const char* data,
         outputBuffer[splitPayloadLength + SHELLMATTA_HEADER_LENGTH + SHELLMATTA_SHIFT_BY_3] = (uint8_t)(outCrc);
 
         /* use original write function to send full buffer */
-        ret = transportLayerInt->originalWrite((char*) outputBuffer, splitLength);
+        ret = transportLayer->originalWrite((char*) outputBuffer, splitLength);
         processedLength += splitPayloadLength;
     }
     while (processedLength < outPayloadLength);

src/shellmatta_transport.h

@@ -66,12 +66,14 @@
 
 shellmatta_retCode_t shellmatta_reset_transport(shellmatta_transport_layer_t *transportLayer);
 
-shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t *transportLayer);
+shellmatta_retCode_t shellmatta_init_transport_inst(shellmatta_transport_layer_t    *transportLayer,
+                                                    shellmatta_write_t              writeFct);
 
 shellmatta_retCode_t shellmatta_handle_transport_fsm(shellmatta_transport_layer_t *transportLayer,
                                                      char *data);
 
-shellmatta_retCode_t shellmatta_write_transport(const char* data,
+shellmatta_retCode_t shellmatta_write_transport(shellmatta_transport_layer_t *transportLayer,
+                                                const char* data,
                                                 uint32_t length);
 
 #endif /* _SHELLMATTA_TRANSPORT_H_ */

src/shellmatta_utils.c

@@ -34,7 +34,7 @@ void utils_writeEcho(   shellmatta_instance_t   *inst,
 {
     if(true == inst->echoEnabled)
     {
-        inst->write(data, length);
+        SHELLMATTA_WRITE(data, length);
     }
 }
 
@@ -284,27 +284,27 @@ static shellmatta_retCode_t printUsage(const shellmatta_instance_t *inst, const
     shellmatta_retCode_t ret = SHELLMATTA_OK;
 
     /** -# write the command and alias if configured */
-    SHELLMATTA_RET(ret, inst->write("Help for command: ", 18u));
-    SHELLMATTA_RET(ret, inst->write(cmd->cmd, strlen(cmd->cmd)));
+    SHELLMATTA_RET(ret, SHELLMATTA_WRITE("Help for command: ", 18u));
+    SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->cmd, strlen(cmd->cmd)));
     if((NULL != cmd->cmdAlias) && (0u != strlen(cmd->cmdAlias)))
     {
-        SHELLMATTA_RET(ret, inst->write(" (", 2u));
-        SHELLMATTA_RET(ret, inst->write(cmd->cmdAlias, strlen(cmd->cmdAlias)));
-        SHELLMATTA_RET(ret, inst->write(")", 1u));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE(" (", 2u));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->cmdAlias, strlen(cmd->cmdAlias)));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE(")", 1u));
     }
     /** -# write the help text if configured */
     if((NULL != cmd->helpText) && (0u != strlen(cmd->helpText)))
     {
-        SHELLMATTA_RET(ret, inst->write("\r\n\r\n", 4u));
-        SHELLMATTA_RET(ret, inst->write(cmd->helpText, strlen(cmd->helpText)));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE("\r\n\r\n", 4u));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->helpText, strlen(cmd->helpText)));
     }
     /** -# write the usage text if configured */
     if((NULL != cmd->usageText) && (0u != strlen(cmd->usageText)))
     {
-        SHELLMATTA_RET(ret, inst->write("\r\n\r\nUsage: \r\n", 13u));
-        SHELLMATTA_RET(ret, inst->write(cmd->usageText, strlen(cmd->usageText)));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE("\r\n\r\nUsage: \r\n", 13u));
+        SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->usageText, strlen(cmd->usageText)));
     }
-    SHELLMATTA_RET(ret, inst->write("\r\n", 2u));
+    SHELLMATTA_RET(ret, SHELLMATTA_WRITE("\r\n", 2u));
 
     return ret;
 }
@@ -401,29 +401,29 @@ static shellmatta_retCode_t helpCmdFct(const shellmatta_handle_t handle, const c
             cmdLen       = strlen(cmd->cmd);
             cmdAliasLen  = (NULL != cmd->cmdAlias) ? strlen(cmd->cmdAlias) : 0u;
 
-            SHELLMATTA_RET(ret, inst->write(cmd->cmd, strlen(cmd->cmd)));
+            SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->cmd, strlen(cmd->cmd)));
             tabCnt = (maxCmdLen - cmdLen) + 2u;
 
             /** -# add padding if there is anything to be printed afterwards */
             if(    ((NULL != cmd->cmdAlias) && (0u != strlen(cmd->cmdAlias)))
                 || ((NULL != cmd->helpText) && (0u != strlen(cmd->helpText))))
             {
-                SHELLMATTA_PRINT_BUFFER(tabBuffer, tabCnt, inst->write);
+                SHELLMATTA_PRINT_BUFFER(tabBuffer, tabCnt);
             }
 
             if((NULL != cmd->cmdAlias) && (0u != strlen(cmd->cmdAlias)))
             {
-                SHELLMATTA_RET(ret, inst->write(cmd->cmdAlias, cmdAliasLen));
+                SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->cmdAlias, cmdAliasLen));
             }
             tabCnt = (maxCmdAliasLen - cmdAliasLen) + 2u;
 
             if((NULL != cmd->helpText) && (0u != strlen(cmd->helpText)))
             {
-                SHELLMATTA_PRINT_BUFFER(tabBuffer, tabCnt, inst->write);
-                SHELLMATTA_RET(ret, inst->write(cmd->helpText, strlen(cmd->helpText)));
+                SHELLMATTA_PRINT_BUFFER(tabBuffer, tabCnt);
+                SHELLMATTA_RET(ret, SHELLMATTA_WRITE(cmd->helpText, strlen(cmd->helpText)));
             }
 
-            SHELLMATTA_RET(ret, inst->write("\r\n", 2u));
+            SHELLMATTA_RET(ret, SHELLMATTA_WRITE("\r\n", 2u));
 
             cmd = cmd->next;
         }
@@ -452,8 +452,8 @@ void utils_terminateInput(shellmatta_instance_t *inst)
     inst->stdinLength       = 0u;
     inst->continuousCmd     = NULL;
     inst->busyCmd           = NULL;
-    inst->write("\r\n", 2u);
-    inst->write(inst->prompt, strlen(inst->prompt));
+    SHELLMATTA_WRITE("\r\n", 2u);
+    SHELLMATTA_WRITE(inst->prompt, strlen(inst->prompt));
 }
 
 /**

src/shellmatta_utils.h

@@ -19,6 +19,7 @@
 #ifndef _SHELLMATTA_UTILS_H_
 #define _SHELLMATTA_UTILS_H_
 
+#include "shellmatta_transport.h"
 #include "shellmatta.h"
 #include <stdint.h>
 
@@ -49,15 +50,15 @@
  * @param[in]   cnt     count of bytes to send
  * @param[in]   fct     write function
  */
-#define SHELLMATTA_PRINT_BUFFER(buffer,cnt,fct) \
-    while((cnt) > sizeof((buffer)))             \
-    {                                           \
-        (cnt) -= sizeof((buffer));              \
-        (fct)((buffer), sizeof((buffer)));      \
-    }                                           \
-    if((cnt) != 0u)                             \
-    {                                           \
-        (fct)((buffer), (cnt));                 \
+#define SHELLMATTA_PRINT_BUFFER(buffer,cnt)             \
+    while((cnt) > sizeof((buffer)))                     \
+    {                                                   \
+        (cnt) -= sizeof((buffer));                      \
+        SHELLMATTA_WRITE((buffer), sizeof((buffer)));   \
+    }                                                   \
+    if((cnt) != 0u)                                     \
+    {                                                   \
+        SHELLMATTA_WRITE((buffer), (cnt));              \
     }
 
 /** @brief help command which prints all shellmatta commands as table */