changes

cube/Core/Src/spi.c

@@ -80,8 +80,8 @@ void MX_SPI3_Init(void)
   hspi3.Init.Mode = SPI_MODE_MASTER;
   hspi3.Init.Direction = SPI_DIRECTION_2LINES;
   hspi3.Init.DataSize = SPI_DATASIZE_8BIT;
-  hspi3.Init.CLKPolarity = SPI_POLARITY_HIGH;
-  hspi3.Init.CLKPhase = SPI_PHASE_2EDGE;
+  hspi3.Init.CLKPolarity = SPI_POLARITY_LOW;
+  hspi3.Init.CLKPhase = SPI_PHASE_1EDGE;
   hspi3.Init.NSS = SPI_NSS_SOFT;
   hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
   hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;

cube/Core/Src/stm32f1xx_it.c

@@ -261,6 +261,9 @@ void UART4_IRQHandler(void)
   /* USER CODE END UART4_IRQn 1 */
 }
 
+
+void mbusCommISR();
+
 /**
   * @brief This function handles UART5 global interrupt.
   */
@@ -269,9 +272,11 @@ void UART5_IRQHandler(void)
   /* USER CODE BEGIN UART5_IRQn 0 */
 
   /* USER CODE END UART5_IRQn 0 */
-  HAL_UART_IRQHandler(&huart5);
+  // HAL_UART_IRQHandler(&huart5);
   /* USER CODE BEGIN UART5_IRQn 1 */
 
+  mbusCommISR();
+
   /* USER CODE END UART5_IRQn 1 */
 }
 

cube/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c

@@ -2014,6 +2014,10 @@ HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart)
   return HAL_OK;
 }
 
+inline void dts(uint8_t v) {
+      while (v--) HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_10);
+}
+
 /**
   * @brief  This function handles UART interrupt request.
   * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
@@ -2022,6 +2026,8 @@ HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart)
   */
 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
 {
+  HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_12);
+
   uint32_t isrflags   = READ_REG(huart->Instance->SR);
   uint32_t cr1its     = READ_REG(huart->Instance->CR1);
   uint32_t cr3its     = READ_REG(huart->Instance->CR3);
@@ -2035,6 +2041,7 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
      /* UART in mode Receiver -------------------------------------------------*/
     if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
     {
+dts(1);
       UART_Receive_IT(huart);
       return;
     }
@@ -2043,6 +2050,7 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
   /* If some errors occur */
   if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
   {
+dts(2);
     /* UART parity error interrupt occurred ----------------------------------*/
     if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
     {
@@ -2070,10 +2078,14 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
     /* Call UART Error Call back function if need be --------------------------*/
     if (huart->ErrorCode != HAL_UART_ERROR_NONE)
     {
+dts(3);
       /* UART in mode Receiver -----------------------------------------------*/
       if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
       {
+        dts(4);
         UART_Receive_IT(huart);
+      } else {
+        dts(5);
       }
 
       /* If Overrun error occurs, or if any error occurs in DMA mode reception,

cube/User/Inc/eeprom.h

@@ -18,5 +18,4 @@ void eepromRead(uint16_t addr, uint8_t *buf, uint8_t len);
 void eepromSpiTxCpltCallback(SPI_HandleTypeDef *hspi);
 t_deviceStats* getGlobalDeviceStats();
 
-
 #endif /* EEPROM_H_ */

cube/User/Inc/mbusComm.h

@@ -17,6 +17,7 @@ typedef struct {
   int32_t period;
   int32_t delay;
   bool waiting;
+  bool active;
 } t_mbusDevice;
 
 typedef enum {
@@ -26,15 +27,21 @@ typedef enum {
 } e_mbusCommRequestResult;
 
 typedef struct {
-  uint32_t requestCnt;
-  uint32_t errorCnt;
+  uint32_t mbusRequestCnt;
+  uint32_t mbusErrorCnt;
+  uint32_t uartOctetCnt;
+  uint32_t uartOverrunCnt;
+  uint32_t uartFramingErrCnt;
+  uint32_t uartParityErrCnt;
 } t_mbusCommStats;
 
 // e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice);
 void mbusCommInit();
+void mbusCommExec();
 void mbusCommEnable(bool enable);
 void mbusCommTxCpltCallback(UART_HandleTypeDef *huart);
 void mbusCommRxCpltCallback(UART_HandleTypeDef *huart);
+void mbusCommErrorCallback(UART_HandleTypeDef *huart);
 void mbusCommSetStats(t_mbusCommStats stats);
 t_mbusCommStats *mbusCommGetStats();
 

cube/User/Src/cmdHandler.c

@@ -44,7 +44,7 @@ typedef struct {
 
 // clear statistics
 bool clearCmd(uint8_t argc, char **args) {
-    t_mbusCommStats zeroedStats = { .requestCnt = 0, .errorCnt = 0 };
+    t_mbusCommStats zeroedStats = { .mbusRequestCnt = 0, .mbusErrorCnt = 0, .uartOctetCnt = 0, .uartOverrunCnt = 0, .uartFramingErrCnt = 0, .uartParityErrCnt = 0 };
     mbusCommSetStats(zeroedStats);
     coloredMsg(LOG_YELLOW, true, "ch cc global statistics cleared");
     return true;
@@ -55,9 +55,14 @@ bool globalStatsCmd(uint8_t argc, char **args) {
     char buf[256];
     sprintf(buf, \
       "Global statistics\n\r" \
-      "  Requests: %ld\n\r" \
-      "  Errors:   %ld\n\r",
-      stats->requestCnt, stats->errorCnt
+      "  Meterbus Requests: %ld\n\r" \
+      "  Meterbus Errors:   %ld\n\r" \
+      "  UART Octets:       %ld\n\r" \
+      "  UART Overruns:     %ld\n\r" \
+      "  UART Framing Errs: %ld\n\r" \
+      "  UART Parity Errs:  %ld\n\r",
+      stats->mbusRequestCnt, stats->mbusErrorCnt,
+      stats->uartOctetCnt, stats->uartOverrunCnt, stats->uartFramingErrCnt, stats->uartParityErrCnt
     );
     send(CMD_SOCK, (uint8_t*)buf, strlen(buf));
     return true;

cube/User/Src/eeprom.c

@@ -20,7 +20,7 @@ static const uint8_t EEPROM_WREN = 0x06;
 // static const uint8_t EEPROM_WRSR = 0x01;
 
 
-static const uint32_t EEPROM_MAGIC = 0xaffe0006;
+static const uint32_t EEPROM_MAGIC = 0xaffe0008;
 
 
 typedef union {
@@ -114,8 +114,8 @@ static void eepromHourlyUpdateDeviceStats(void *handle) {
 
   t_mbusCommStats *stats = mbusCommGetStats();
 
-  deviceStats.s.totalRequests = stats->requestCnt;
-  deviceStats.s.totalFailures = stats->errorCnt;
+  deviceStats.s.totalRequests += stats->mbusRequestCnt;
+  deviceStats.s.totalFailures += stats->mbusErrorCnt;
 
   logMsg("eeHUDS, about to write updated device stats");
   logMsg("eeHUDS, total powercycles so far: %d", deviceStats.s.totalPowercycles);
@@ -179,9 +179,6 @@ void eepromInit() {
   logMsg("eeI, total requests so far: %d", deviceStats.s.totalRequests);
   logMsg("eeI, total failures so far: %d", deviceStats.s.totalFailures);
 
-  t_mbusCommStats stats = { .requestCnt = deviceStats.s.totalRequests, .errorCnt = deviceStats.s.totalFailures};
-  mbusCommSetStats(stats);
-
   deviceStats.s.totalPowercycles += 1;
   logMsg("eeI, about to write device stats with updated power cycles counter");
   eepromWrite(DEVICE_STATS_ADDR, deviceStats.b, sizeof(deviceStats));

cube/User/Src/frontend.c

@@ -37,7 +37,7 @@ void frontendDisable() {
 void frontendAdcCallback(ADC_HandleTypeDef* hadc) {
     static int32_t holdValue = 0;
 
-    show(DEBUG_2, TOGGLE);
+    // show(DEBUG_2, TOGGLE);
 
     if (frontendEnabled) {
         int32_t currentValue = (int32_t) HAL_ADC_GetValue(hadc);

cube/User/Src/main2.c

@@ -64,13 +64,15 @@ void my_setup_2() {
 }
 
 void my_loop() {
-    show(DEBUG_1, TOGGLE);
+    // show(DEBUG_2, TOGGLE);
 
     schExec();
 
 #ifndef LOGGER_OUTPUT_BY_INTERRUPT
     logExec();
 #endif //LOGGER_OUTPUT_BY_INTERRUPT
+
+    mbusCommExec();
 }
 
 void SYSTICK_Callback() {
@@ -90,22 +92,13 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
 }
 
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
-    if (huart == &mbusUart) {
-        mbusCommTxCpltCallback(huart);
-    } 
 #ifdef LOGGER_OUTPUT_BY_INTERRUPT   
-    else if (huart == &debugUart) {
+    if (huart == &debugUart) {
         debugTxCpltCallback(huart);
     }
 #endif //LOGGER_OUTPUT_BY_INTERRUPT    
 }
 
-void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
-    if (huart == &mbusUart) {
-        mbusCommRxCpltCallback(huart);
-    }
-}
-
 void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
     if (hspi == &eepromSpi) {
         eepromSpiTxCpltCallback(hspi);

cube/User/Src/mbusComm.c

@@ -16,6 +16,7 @@
 #include <mbusParserExt.h>
 #include <mqttComm.h>
 #include <oled.h>
+#include <ringbuffer.h>
 
 #include <mbus/mbus-protocol.h>
 
@@ -44,6 +45,7 @@ typedef enum {
     MBCS_IDLE,
     MBCS_SEND,
     MBCS_SEND_CONTINUED,
+    MBCS_SENDING,
     MBCS_SENDING_DONE,
     MBCS_ENABLE_FRONTEND,
     MBCS_START1,
@@ -77,25 +79,33 @@ typedef struct {
   uint8_t stop;
 } t_longframe;
 
+typedef struct {
+    uint16_t size;
+    uint16_t readIdx;
+    uint16_t writeIdx;
+    uint8_t *buffer;
+} linearBuffer_t;
+
 typedef struct {
     uint32_t requestId;
     e_mbusCommState state;
     uint8_t retryCnt;
     uint8_t cmd;
     uint8_t addr;
-    uint8_t sendBuf[5];
+    linearBuffer_t sendBuffer;
+    linearBuffer_t receiveBuffer;
+    uint32_t startTime;
     uint8_t receiveCnt;
-    uint8_t receivedOctet;
-    bool receiving;
+    bool waitForOctet;
     e_mbusCommResult result;
     t_longframe frame;
     t_mbusDevice *device;
 } t_mbusCommHandle;
 
 
-static t_mbusCommHandle mbusCommHandle = { .requestId = 0, .state = MBCS_IDLE, .retryCnt = 0, .cmd = 0, .addr = 0, .receiveCnt = 0, .receivedOctet = 0, .receiving = false };
+static t_mbusCommHandle mbusCommHandle = { .requestId = 0, .state = MBCS_IDLE, .retryCnt = 0, .cmd = 0, .addr = 0, .startTime = 0, .receiveCnt = 0, .waitForOctet = false };
 
-static t_mbusCommStats mbusCommStats = { .requestCnt = 0, .errorCnt = 0 };
+static t_mbusCommStats mbusCommStats = { .mbusRequestCnt = 0, .mbusErrorCnt = 0, .uartOctetCnt = 0, .uartOverrunCnt = 0, .uartFramingErrCnt = 0, .uartParityErrCnt = 0 };
 
 static bool mbusCommEnabled = true;
 
@@ -108,21 +118,21 @@ t_mbusCommStats *mbusCommGetStats() {
 }
 
 
-static void printError(t_mbusCommHandle *localMbusCommHandle) {
-    float errorRatio = ((float) localMbusCommHandle->device->failures) / ((float) localMbusCommHandle->device->requests);
+static void printError() {
+    float errorRatio = ((float) mbusCommHandle.device->failures) / ((float) mbusCommHandle.device->requests);
     coloredMsg(LOG_YELLOW, true, "mbc pe [%d] Error ratio is %.2f", 
-               localMbusCommHandle->requestId,
+               mbusCommHandle.requestId,
                errorRatio);
     mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Error\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\"}", 
-                 localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
-                 localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio);
-    oledPrintf(OLED_SCREEN0, "Err:%d/%d", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests);
+                 mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
+                 mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio);
+    oledPrintf(OLED_SCREEN0, "Err:%d/%d %.2f", mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio);
 }
 
 
 
-static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
-    t_longframe *frame = &(localMbusCommHandle->frame);
+static void parseAndPrintFrame() {
+    t_longframe *frame = &(mbusCommHandle.frame);
 
     mbus_frame reply;
     memset(&reply, 0, sizeof(reply));
@@ -147,30 +157,32 @@ static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
     int r = mbus_frame_data_parse(&reply, &frame_data);
     if (r == 0) {
         mbus_data_variable *data_var = &(frame_data.data_var);
-        coloredMsg(LOG_YELLOW, false, "mbc papf [%d] sts: %02x", localMbusCommHandle->requestId, data_var->header.status);
+        if (data_var->header.status) {
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: %02x", mbusCommHandle.requestId, data_var->header.status);
+        }
         if ((data_var->header.status & 0x01)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Application Busy", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Application Busy", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x02)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Any Application Error", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Any Application Error", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x04)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Power Low", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Power Low", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x08)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Permanent Error", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Permanent Error", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x10)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Temporary Error", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Temporary Error", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x20)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 1", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 1", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x40)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 2", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 2", mbusCommHandle.requestId);
         }
         if ((data_var->header.status & 0x80)) {
-            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 3", localMbusCommHandle->requestId);
+            coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 3", mbusCommHandle.requestId);
         }
         mbus_data_record *record;
         int i;
@@ -181,24 +193,24 @@ static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
              record;
              record = record->next, i++) {
             for (uint8_t j = 0; j < MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS; j++) {
-                if (localMbusCommHandle->device->consideredField[j] == i) {
+                if (mbusCommHandle.device->consideredField[j] == i) {
                     parsedVIB_t parsedVIB = parseVIB(record->drh.vib);
-                    coloredMsg(LOG_YELLOW, false, "mbc papf [%d] parsed VIB N: %s, U: %s, E: %d",
-                               localMbusCommHandle->requestId,
-                               parsedVIB.name, parsedVIB.unit, parsedVIB.exponent);
+                    // coloredMsg(LOG_YELLOW, false, "mbc papf [%d] parsed VIB N: %s, U: %s, E: %d",
+                    //            mbusCommHandle.requestId,
+                    //            parsedVIB.name, parsedVIB.unit, parsedVIB.exponent);
                     if (parsedVIB.found) {
                         uint32_t value = strtol(mbus_data_record_value(record), NULL, 10);
                         float weightedValue = ((float) value) * powf(10.0, ((float) parsedVIB.exponent));
                         coloredMsg(LOG_YELLOW, true, "mbc papf [%d] %s is %.1f %s (%d * 10^%d)",
-                                   localMbusCommHandle->requestId, parsedVIB.name, weightedValue, parsedVIB.unit,
+                                   mbusCommHandle.requestId, parsedVIB.name, weightedValue, parsedVIB.unit,
                                    value, parsedVIB.exponent);
                         keys[numOfConsideredFields] = parsedVIB.name;
                         values[numOfConsideredFields] = weightedValue;
                         numOfConsideredFields++;
                     } else {
                         coloredMsg(LOG_YELLOW, true, "mbc papf [%d] L:%d, VIF: 0x%02x U:%s V:%s", 
-                                   localMbusCommHandle->requestId,
-                                   localMbusCommHandle->device->consideredField[j],
+                                   mbusCommHandle.requestId,
+                                   mbusCommHandle.device->consideredField[j],
                                    record->drh.vib.vif,
                                    mbus_data_record_unit(record),
                                    mbus_data_record_value(record));
@@ -207,296 +219,330 @@ static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
                 }
             }
         }
-        float errorRatio = ((float) localMbusCommHandle->device->failures) / ((float) localMbusCommHandle->device->requests);
+        float errorRatio = ((float) mbusCommHandle.device->failures) / ((float) mbusCommHandle.device->requests);
         coloredMsg(LOG_YELLOW, true, "mbc papf [%d] Error ratio is %.2f", 
-                                   localMbusCommHandle->requestId,
+                                   mbusCommHandle.requestId,
                                    errorRatio);
         if (numOfConsideredFields == 1) {
             mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
                                      "\"Values\":{\"%s\":\"%.1f\"}}", 
-                         localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
-                         localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio,
+                         mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
+                         mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
                          keys[0], values[0]);
         } else if (numOfConsideredFields == 2) {
             mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
                                      "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", 
-                         localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
-                         localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio,
+                         mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
+                         mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
                          keys[0], values[0], keys[1], values[1]);
         } else if (numOfConsideredFields == 3) {
             mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
                                      "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", 
-                         localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
-                         localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio,
+                         mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
+                         mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
                          keys[0], values[0], keys[1], values[1], keys[2], values[2]);
         } else if (numOfConsideredFields == 4) {
             mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
                                      "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", 
-                         localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
-                         localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio,
+                         mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
+                         mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
                          keys[0], values[0], keys[1], values[1], keys[2], values[2], keys[3], values[3]);
         }
-        oledPrintf(OLED_SCREEN0, "Ok:%d/%d", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests);
+        oledPrintf(OLED_SCREEN0, "Ok:%d/%d %.2f", mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio);
         mbus_data_record_free(data_var->record);
     } else {
-        coloredMsg(LOG_RED, true, "mbc papf [%d] err: unable to parse frame", localMbusCommHandle->requestId);
+        coloredMsg(LOG_RED, true, "mbc papf [%d] err: unable to parse frame", mbusCommHandle.requestId);
     }
 }
 
 
-static void handleRequestEngine(void *handle);
-static void timeoutHandler(void *handle) {
-    t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle;
-    // coloredMsg(LOG_RED, true, "mbc th [%d] timeout", localMbusCommHandle->requestId);
-    localMbusCommHandle->state = MBCS_TIMEOUT;
-    localMbusCommHandle->receiving = false;
-    handleRequestEngine(handle);
+
+void mbusCommISR() {
+    show(DEBUG_1, TOGGLE);
+
+    uint32_t isrflags   = READ_REG(mbusUart.Instance->SR);
+    uint32_t cr1its     = READ_REG(mbusUart.Instance->CR1);
+
+    // RXNEIE doesn't need to be considered since it is always on and more over the
+    // RXNE flag is cleared by reading the DR, which is done in any case
+    if (((isrflags & USART_SR_RXNE) != RESET) || ((isrflags & (USART_SR_ORE | USART_SR_FE | USART_SR_PE)) != RESET)) {
+        // Error flags are only valid together with the RX flag.
+        // They will be cleared by reading SR (already done above) followed by reading DR (below).
+        bool errorFound = false;
+        if ((isrflags & USART_SR_ORE) != RESET) {
+            show(DEBUG_2, TOGGLE); 
+            mbusCommStats.uartOverrunCnt += 1;
+            errorFound = true;
+        }
+        if ((isrflags & USART_SR_FE) != RESET) {
+            mbusCommStats.uartFramingErrCnt += 1;
+            errorFound = true;
+        }
+        if ((isrflags & USART_SR_PE) != RESET) {
+            mbusCommStats.uartParityErrCnt += 1;
+            errorFound = true;
+        }
+        mbusCommStats.uartOctetCnt += 1;
+        // it is required to read the DR in any case here, not only when the buffer has space
+        // otherwise the interrupt flag won't be disabled, particularly important in case of
+        // ORE
+        uint8_t data = (uint8_t)(mbusUart.Instance->DR & (uint8_t)0x00FF);
+        if ((! errorFound) &&
+            (mbusCommHandle.receiveBuffer.writeIdx < mbusCommHandle.receiveBuffer.size)) {
+            mbusCommHandle.receiveBuffer.buffer[mbusCommHandle.receiveBuffer.writeIdx] = data;
+            mbusCommHandle.receiveBuffer.writeIdx += 1;
+        }
     } 
     
-static void receiveNext(t_mbusCommHandle *localMbusCommHandle) {
-    localMbusCommHandle->receiving = true;
-    HAL_UART_Receive_IT(&mbusUart, &(localMbusCommHandle->receivedOctet), 1);
+    // TXEIE needs to be considered since TXE is cleared by writing the DR, which isn't done
+    // after the last octet sent
+    if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET)) {
+        if (mbusCommHandle.sendBuffer.readIdx < mbusCommHandle.sendBuffer.writeIdx) {
+            mbusUart.Instance->DR = mbusCommHandle.sendBuffer.buffer[mbusCommHandle.sendBuffer.readIdx];
+            mbusCommHandle.sendBuffer.readIdx += 1;
+            if (mbusCommHandle.sendBuffer.readIdx == mbusCommHandle.sendBuffer.writeIdx) {
+                __HAL_UART_DISABLE_IT(&mbusUart, UART_IT_TXE);
+                mbusCommHandle.state = MBCS_SENDING_DONE;
+            }
+        }
+    } 
 }
 
-static void handleRequestEngine(void *handle) {
-    t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle;
 
+void mbusCommExec() {
     static uint8_t userdataIdx = 0;
     static uint8_t calculatedChksum = 0;
+    uint8_t receivedOctet = 0;
 
-    switch (localMbusCommHandle->state) {
+    if ((mbusCommHandle.startTime != 0) && ((mbusCommHandle.startTime + 2500) < HAL_GetTick())) {
+        mbusCommHandle.state = MBCS_TIMEOUT;
+    } else if (mbusCommHandle.waitForOctet) {
+        if (mbusCommHandle.receiveBuffer.readIdx >= mbusCommHandle.receiveBuffer.writeIdx) {
+            return; // no data available, wait
+        }
+        receivedOctet = mbusCommHandle.receiveBuffer.buffer[mbusCommHandle.receiveBuffer.readIdx];
+        mbusCommHandle.receiveBuffer.readIdx += 1;
+        mbusCommHandle.waitForOctet = false;
+    }
+
+    switch (mbusCommHandle.state) {
         case MBCS_IDLE:
-        coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state IDLE", localMbusCommHandle->requestId);
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state IDLE", mbusCommHandle.requestId);
         break;
 
         case MBCS_SEND:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", localMbusCommHandle->requestId);
-        localMbusCommHandle->sendBuf[0] = 0x10;
-        localMbusCommHandle->sendBuf[1] = localMbusCommHandle->cmd;
-        localMbusCommHandle->sendBuf[2] = localMbusCommHandle->addr;
-        localMbusCommHandle->sendBuf[3] = localMbusCommHandle->cmd + localMbusCommHandle->addr; // checksum
-        localMbusCommHandle->sendBuf[4] = 0x16;
-        localMbusCommHandle->state = MBCS_SEND_CONTINUED;
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", mbusCommHandle.requestId);
+        mbusCommHandle.sendBuffer.buffer[0] = 0x10;
+        mbusCommHandle.sendBuffer.buffer[1] = mbusCommHandle.cmd;
+        mbusCommHandle.sendBuffer.buffer[2] = mbusCommHandle.addr;
+        mbusCommHandle.sendBuffer.buffer[3] = mbusCommHandle.cmd + mbusCommHandle.addr; // checksum
+        mbusCommHandle.sendBuffer.buffer[4] = 0x16;
+        mbusCommHandle.sendBuffer.readIdx = 0;
+        mbusCommHandle.sendBuffer.writeIdx = 5;
+        mbusCommHandle.state = MBCS_SEND_CONTINUED;
         // no break !!
 
         case MBCS_SEND_CONTINUED:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND_CONTINUED", localMbusCommHandle->requestId);
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND_CONTINUED", mbusCommHandle.requestId);
         show(LED_RED, OFF);
         if (! loopActive) {
-            coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", localMbusCommHandle->requestId, localMbusCommHandle->retryCnt);
-            localMbusCommHandle->retryCnt++;
+            coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", mbusCommHandle.requestId, mbusCommHandle.retryCnt);
+            mbusCommHandle.retryCnt++;
             loopEnable();
-            schAdd(handleRequestEngine, handle, 100, 0); // give 100ms to settled the loop
         } else {
-            localMbusCommHandle->retryCnt = 0;
-            HAL_UART_Transmit_IT(&mbusUart, localMbusCommHandle->sendBuf, 5);
-            // transition from here to SENDING_DONE is initiate by mbusCommTxCpltCallback
-            // interrupt callback
-            localMbusCommHandle->state = MBCS_SENDING_DONE;
+            mbusCommHandle.retryCnt = 0;
+            // enable transmitter interrupt
+            //coloredMsg(LOG_YELLOW, false, "mbc hre [%d] enable transmitter interrupt", mbusCommHandle.requestId);
+            __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_TXE);
+            mbusCommHandle.state = MBCS_SENDING;
         }
         break;
 
+        case MBCS_SENDING:
+        // transition from here to MBCS_SENDING_DONE is done by TX ISR
+        break;
+
         case MBCS_SENDING_DONE:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", localMbusCommHandle->requestId);
-        localMbusCommHandle->state = MBCS_ENABLE_FRONTEND;
-        schAdd(handleRequestEngine, handle, 3, 0);
+        //coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", mbusCommHandle.requestId);
+        mbusCommHandle.state = MBCS_ENABLE_FRONTEND;
         break;
 
         case MBCS_ENABLE_FRONTEND:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state ENABLE_FRONTEND", localMbusCommHandle->requestId);
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state ENABLE_FRONTEND", mbusCommHandle.requestId);
         frontendEnable();
-        schAdd(timeoutHandler, handle, 2500, 0);
         calculatedChksum = 0;
         userdataIdx = 0;
-        localMbusCommHandle->state = MBCS_START1;
-        receiveNext(localMbusCommHandle);
+        mbusCommHandle.receiveBuffer.readIdx = 0;
+        mbusCommHandle.receiveBuffer.writeIdx = 0;
+        mbusCommHandle.waitForOctet = true; // start receiver
+        mbusCommHandle.startTime = HAL_GetTick(); // start receiver timeout
+        mbusCommHandle.state = MBCS_START1;
         break;
 
         case MBCS_START1:
-        if (localMbusCommHandle->receivedOctet == 0x68) {
-            localMbusCommHandle->frame.start1 = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->state = MBCS_LENGTH1;
-            receiveNext(localMbusCommHandle);
+        if (receivedOctet == 0x68) {
+            mbusCommHandle.frame.start1 = receivedOctet;
+            mbusCommHandle.waitForOctet = true;
+            mbusCommHandle.state = MBCS_LENGTH1;
         } else {
-            coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start1 symbol %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START1;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+            coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start1 symbol %02x", mbusCommHandle.requestId, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__START1;
+            mbusCommHandle.state = MBCS_ERROR;
         }
         break;
 
         case MBCS_LENGTH1:
-        if (localMbusCommHandle->receivedOctet <= 3) {
-            coloredMsg(LOG_RED, true, "mbc hre [%d] err: length to small %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH1;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+        if (receivedOctet <= 3) {
+            coloredMsg(LOG_RED, true, "mbc hre [%d] err: length to small %02x", mbusCommHandle.requestId, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__LENGTH1;
+            mbusCommHandle.state = MBCS_ERROR;
         } else {
-            localMbusCommHandle->frame.length1 = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->frame.userdata = (uint8_t*) malloc(localMbusCommHandle->frame.length1 - 3);
-            if (! localMbusCommHandle->frame.userdata) {
-                coloredMsg(LOG_RED, true, "mbc hre [%d] err: unable to allocate memory for userdata", localMbusCommHandle->requestId);
-                localMbusCommHandle->result = MBCR_ERROR_OUT_OF_MEMORY__USERDATA;
-                localMbusCommHandle->state = MBCS_ERROR;
-                schAdd(handleRequestEngine, handle, 0, 0);
+            mbusCommHandle.frame.length1 = receivedOctet;
+            mbusCommHandle.frame.userdata = (uint8_t*) malloc(mbusCommHandle.frame.length1 - 3);
+            if (! mbusCommHandle.frame.userdata) {
+                coloredMsg(LOG_RED, true, "mbc hre [%d] err: unable to allocate memory for userdata", mbusCommHandle.requestId);
+                mbusCommHandle.result = MBCR_ERROR_OUT_OF_MEMORY__USERDATA;
+                mbusCommHandle.state = MBCS_ERROR;
             } else {
-                localMbusCommHandle->state = MBCS_LENGTH2;
-                receiveNext(localMbusCommHandle);
+                mbusCommHandle.waitForOctet = true;
+                mbusCommHandle.state = MBCS_LENGTH2;
             }
         }
         break;
 
         case MBCS_LENGTH2:
-        if (localMbusCommHandle->frame.length1 != localMbusCommHandle->receivedOctet) {
+        if (mbusCommHandle.frame.length1 != receivedOctet) {
             coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid length2 %02x vs. %02x", 
-                       localMbusCommHandle->requestId, localMbusCommHandle->frame.length1, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH2;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+                       mbusCommHandle.requestId, mbusCommHandle.frame.length1, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__LENGTH2;
+            mbusCommHandle.state = MBCS_ERROR;
         } else {
-            localMbusCommHandle->frame.length2 = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->state = MBCS_START2;
-            receiveNext(localMbusCommHandle);
+            mbusCommHandle.frame.length2 = receivedOctet;
+            mbusCommHandle.waitForOctet = true;
+            mbusCommHandle.state = MBCS_START2;
         }
         break;
 
         case MBCS_START2:
-        if (localMbusCommHandle->receivedOctet == 0x68) {
-            localMbusCommHandle->frame.start2 = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->state = MBCS_C_FIELD;
-            receiveNext(localMbusCommHandle);
+        if (receivedOctet == 0x68) {
+            mbusCommHandle.frame.start2 = receivedOctet;
+            mbusCommHandle.waitForOctet = true;
+            mbusCommHandle.state = MBCS_C_FIELD;
         } else {
             coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start2 symbol %02x", 
-                       localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START2;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+                       mbusCommHandle.requestId, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__START2;
+            mbusCommHandle.state = MBCS_ERROR;
         }
         break;
 
         case MBCS_C_FIELD:
-        localMbusCommHandle->frame.c = localMbusCommHandle->receivedOctet;
-        calculatedChksum += localMbusCommHandle->receivedOctet;
-        localMbusCommHandle->state = MBCS_A_FIELD;
-        receiveNext(localMbusCommHandle);
+        mbusCommHandle.frame.c = receivedOctet;
+        calculatedChksum += receivedOctet;
+        mbusCommHandle.waitForOctet = true;
+        mbusCommHandle.state = MBCS_A_FIELD;
         break;
 
         case MBCS_A_FIELD:
-        localMbusCommHandle->frame.a = localMbusCommHandle->receivedOctet;
-        calculatedChksum += localMbusCommHandle->receivedOctet;
-        localMbusCommHandle->state = MBCS_CI_FIELD;
-        receiveNext(localMbusCommHandle);
+        mbusCommHandle.frame.a = receivedOctet;
+        calculatedChksum += receivedOctet;
+        mbusCommHandle.waitForOctet = true;
+        mbusCommHandle.state = MBCS_CI_FIELD;
         break;
 
         case MBCS_CI_FIELD:
-        localMbusCommHandle->frame.ci = localMbusCommHandle->receivedOctet;
-        calculatedChksum += localMbusCommHandle->receivedOctet;
-        localMbusCommHandle->state = MBCS_USERDATA;
-        receiveNext(localMbusCommHandle);
+        mbusCommHandle.frame.ci = receivedOctet;
+        calculatedChksum += receivedOctet;
+        mbusCommHandle.waitForOctet = true;
+        mbusCommHandle.state = MBCS_USERDATA;
         break;
 
         case MBCS_USERDATA:
-        localMbusCommHandle->frame.userdata[userdataIdx] = localMbusCommHandle->receivedOctet;
-        calculatedChksum += localMbusCommHandle->receivedOctet;
+        mbusCommHandle.frame.userdata[userdataIdx] = receivedOctet;
+        calculatedChksum += receivedOctet;
         userdataIdx++;
-        if (userdataIdx == (localMbusCommHandle->frame.length1 - 3)) {
-            localMbusCommHandle->state = MBCS_CHKSUM;
+        mbusCommHandle.waitForOctet = true;
+        if (userdataIdx == (mbusCommHandle.frame.length1 - 3)) {
+            mbusCommHandle.state = MBCS_CHKSUM;
         }
-        receiveNext(localMbusCommHandle);
         break;
 
         case MBCS_CHKSUM:
-        if (localMbusCommHandle->receivedOctet != calculatedChksum) {
+        if (receivedOctet != calculatedChksum) {
             coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid checksum %02x vs %02x", 
-                       localMbusCommHandle->requestId, calculatedChksum, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+                       mbusCommHandle.requestId, calculatedChksum, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM;
+            mbusCommHandle.state = MBCS_ERROR;
         } else {
-            localMbusCommHandle->frame.chksum = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->state = MBCS_STOP;
-            receiveNext(localMbusCommHandle);
+            mbusCommHandle.frame.chksum = receivedOctet;
+            mbusCommHandle.waitForOctet = true;
+            mbusCommHandle.state = MBCS_STOP;
         }
         break;
 
         case MBCS_STOP:
-        if (localMbusCommHandle->receivedOctet == 0x16) {
-            localMbusCommHandle->frame.stop = localMbusCommHandle->receivedOctet;
-            localMbusCommHandle->state = MBCS_DONE;
-            schAdd(handleRequestEngine, handle, 0, 0);
+        if (receivedOctet == 0x16) {
+            mbusCommHandle.frame.stop = receivedOctet;
+            mbusCommHandle.state = MBCS_DONE;
         } else {
             coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid stop symbol %02x", 
-                       localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
-            localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__STOP;
-            localMbusCommHandle->state = MBCS_ERROR;
-            schAdd(handleRequestEngine, handle, 0, 0);
+                       mbusCommHandle.requestId, receivedOctet);
+            mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__STOP;
+            mbusCommHandle.state = MBCS_ERROR;
         }
         break;
 
         case MBCS_DONE:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DONE", localMbusCommHandle->requestId);
-        parseAndPrintFrame(localMbusCommHandle);
-        if (localMbusCommHandle->frame.userdata != NULL) {
-            free(localMbusCommHandle->frame.userdata);
-            localMbusCommHandle->frame.userdata = NULL;
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DONE", mbusCommHandle.requestId);
+        parseAndPrintFrame();
+        if (mbusCommHandle.frame.userdata != NULL) {
+            free(mbusCommHandle.frame.userdata);
+            mbusCommHandle.frame.userdata = NULL;
         }
-        localMbusCommHandle->result = MBCR_SUCCESS;
-        localMbusCommHandle->state = MBCS_DISABLE_FRONTEND;
-        schDel(timeoutHandler, handle);
-        schAdd(handleRequestEngine, handle, 0, 0);
+        mbusCommHandle.result = MBCR_SUCCESS;
+        mbusCommHandle.state = MBCS_DISABLE_FRONTEND;
         break;
 
         case MBCS_ERROR:
-        coloredMsg(LOG_RED, false, "mbc hre [%d] state ERROR", localMbusCommHandle->requestId);
+        // coloredMsg(LOG_RED, false, "mbc hre [%d] state ERROR", mbusCommHandle.requestId);
+        coloredMsg(LOG_RED, true, "mbc hre [%d] error", mbusCommHandle.requestId);
         show(LED_RED, ON);
-        localMbusCommHandle->state = MBCS_ERROR_CONTINUED;
+        mbusCommHandle.state = MBCS_ERROR_CONTINUED;
         // no break
 
         case MBCS_ERROR_CONTINUED:
-        receiveNext(localMbusCommHandle);
+        // every error will be collected by a timeout to receive all data still on the wire
+        // to avoid leaking old data in responses for new requests
         break;
 
         case MBCS_TIMEOUT:
-        coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", localMbusCommHandle->requestId);
-        mbusCommStats.errorCnt += 1;
-        localMbusCommHandle->device->failures += 1;
-        printError(localMbusCommHandle);
-        localMbusCommHandle->receiving = false;        
-        if (localMbusCommHandle->frame.userdata != NULL) {
-            free(localMbusCommHandle->frame.userdata);
-            localMbusCommHandle->frame.userdata = NULL;
+        // coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", mbusCommHandle.requestId);
+        coloredMsg(LOG_RED, true, "mbc hre [%d] timeout", mbusCommHandle.requestId);
+        mbusCommStats.mbusErrorCnt += 1;
+        mbusCommHandle.device->failures += 1;
+        mbusCommHandle.startTime = 0; // disable timeout
+        mbusCommHandle.waitForOctet = false; // disable receiver
+        printError();
+        if (mbusCommHandle.frame.userdata != NULL) {
+            free(mbusCommHandle.frame.userdata);
+            mbusCommHandle.frame.userdata = NULL;
         }
-        HAL_UART_AbortReceive(&mbusUart);
-        uint8_t kitchenSink[16];
-        memset(kitchenSink, 0, 16);
-        HAL_StatusTypeDef r = HAL_UART_Receive(&mbusUart, kitchenSink, 16, 100);
-        coloredMsg(LOG_RED, false, "mbc hre [%d] abort, last receive result: %02x", localMbusCommHandle->requestId, r);
         // no break
 
         case MBCS_DISABLE_FRONTEND:
-        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DISABLE_FRONTEND", localMbusCommHandle->requestId);
+        // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DISABLE_FRONTEND", mbusCommHandle.requestId);
         frontendDisable();
-        localMbusCommHandle->state = MBCS_IDLE;
+        mbusCommHandle.startTime = 0; // disable timeout
+        mbusCommHandle.state = MBCS_IDLE;
         break;
         
 
         default:
-        localMbusCommHandle->state = MBCS_IDLE;
+        mbusCommHandle.state = MBCS_IDLE;
         break;
     }
 }
 
-void mbusCommTxCpltCallback(UART_HandleTypeDef *huart) {
-    schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
-}
-
-void mbusCommRxCpltCallback(UART_HandleTypeDef *huart) {
-    if (mbusCommHandle.receiving) {
-        schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
-        mbusCommHandle.receiving = false;
-    }
-}
-
 void mbusCommEnable(bool enable) {
     mbusCommEnabled = enable;
 }
@@ -514,19 +560,14 @@ static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) {
             mbusCommHandle.device = mbusDevice;
             mbusDevice->requests += 1;
 
-            coloredMsg(LOG_YELLOW, true, "mbc mcr [%d] new request %s R:%d F:%d GRC:%d GEC:%d", 
+            coloredMsg(LOG_YELLOW, true, "mbc mcr [%d] new request %s", 
                     mbusCommHandle.requestId,
-                    mbusDevice->deviceName, 
-                    mbusDevice->requests, 
-                    mbusDevice->failures, 
-                    mbusCommStats.requestCnt,
-                    mbusCommStats.errorCnt);
+                    mbusDevice->deviceName);
 
             oledPrint(OLED_SCREEN0, mbusDevice->deviceName);
-            schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
             res = MBCRR_TRIGGERED;   
 
-            mbusCommStats.requestCnt += 1;
+            mbusCommStats.mbusRequestCnt += 1;
         }
     } else {
         res = MBCRR_DISABLED;
@@ -536,6 +577,8 @@ static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) {
 }
 
 
+#define PERIOD 10
+
 static uint8_t numOfDevices = 8;
 static t_mbusDevice devices[] = {
     {
@@ -544,9 +587,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 17, -1, -1 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "ComputerPower",
@@ -554,9 +598,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "DryerPower",
@@ -564,9 +609,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "LaundryPower",
@@ -574,9 +620,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "DishwasherPower",
@@ -584,9 +631,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "LightPower",
@@ -594,9 +642,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 15,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "FreezerPower",
@@ -604,9 +653,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     },
     {
         .deviceName = "FridgePower",
@@ -614,9 +664,10 @@ static t_mbusDevice devices[] = {
         .consideredField = { 0, 4, 2, 3 },
         .requests = 0,
         .failures = 0,
-        .period = 60,
+        .period = PERIOD,
         .delay = 0,
-        .waiting = false
+        .waiting = false,
+        .active = true
     }
 };
 
@@ -673,6 +724,7 @@ static void mbusCommScheduler(void *handle) {
                 state = 1;
             }
             for (uint8_t i = 0; i < numOfDevices; i++) {
+                if (devices[i].active) {
                     devices[i].delay -= 1;
                     if (devices[i].delay <= 0) {
                         devices[i].delay = devices[i].period;
@@ -680,11 +732,42 @@ static void mbusCommScheduler(void *handle) {
                         coloredMsg(LOG_YELLOW, false, "mbc mcs scheduled: %s", devices[i].deviceName);
                     }
                 }
+            }
+
+            // FIXME 
+            // state = 3;
+            break;
+        
+        case 3:
+            coloredMsg(LOG_YELLOW, false, "mbc mcs waiting for godot");
+            state = 4;
+            // no break
+
+        case 4:
             break;
     }
 }
 
 void mbusCommInit() {
     coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication");
+
+    // enable receive interrupts
+//    __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_PE);
+//    __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_ERR);
+    __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_RXNE);
+
+    // init buffers
+    mbusCommHandle.receiveBuffer.size = 256;
+    mbusCommHandle.receiveBuffer.buffer = (uint8_t*) malloc(mbusCommHandle.receiveBuffer.size);
+    mbusCommHandle.receiveBuffer.readIdx = 0;
+    mbusCommHandle.receiveBuffer.writeIdx = 0;
+
+    mbusCommHandle.sendBuffer.size = 8;
+    mbusCommHandle.sendBuffer.buffer = (uint8_t*) malloc(mbusCommHandle.sendBuffer.size);
+    mbusCommHandle.sendBuffer.readIdx = 0;
+    mbusCommHandle.sendBuffer.writeIdx = 0;
+
+
+    // FIXME
     schAdd(mbusCommScheduler, NULL, 0, 1000);
 }

cube/User/Src/mqttComm.c

@@ -56,10 +56,11 @@ static void mqttStatusPublisher(void *handle) {
     t_mbusCommStats *mbusCommStats = mbusCommGetStats();
     t_deviceStats* globalDeviceStats = getGlobalDeviceStats();
 
-    char buf[128];
+    char buf[256];
     uint32_t uptime = HAL_GetTick() / 1000;
-    snprintf(buf, sizeof(buf), "{\"uptime\":\"%ld\", \"runningHours\":\"%ld\", \"powerCycles\":\"%ld\", \"tasks\":\"%d\", \"requests\":\"%ld\", \"errors\":\"%ld\"}", 
-            uptime, globalDeviceStats->totalRunningHours, globalDeviceStats->totalPowercycles, schTaskCnt(), mbusCommStats->requestCnt, mbusCommStats->errorCnt);
+    snprintf(buf, sizeof(buf), "{\"uptime\":\"%ld\", \"runningHours\":\"%ld\", \"powerCycles\":\"%ld\", \"tasks\":\"%d\", \"requests\":\"%ld\", \"errors\":\"%ld\", \"octets\":\"%ld\", \"overrun\":\"%ld\", \"framing\":\"%ld\", \"parity\":\"%ld\"}", 
+            uptime, globalDeviceStats->totalRunningHours, globalDeviceStats->totalPowercycles, schTaskCnt(), mbusCommStats->mbusRequestCnt, mbusCommStats->mbusErrorCnt, 
+            mbusCommStats->uartOctetCnt, mbusCommStats->uartOverrunCnt, mbusCommStats->uartFramingErrCnt, mbusCommStats->uartParityErrCnt);
     bool res = publish(&mqttClient, StatusTopic, (const uint8_t*)buf, strlen(buf), false);
     coloredMsg(LOG_GREEN, false, "mqch, publish returned %d", res);
 
@@ -69,11 +70,10 @@ static void mqttStatusPublisher(void *handle) {
     oledPrintf(OLED_SCREEN1, "Addr:%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
     oledPrintf(OLED_SCREEN1, "Network available:%d", isNetworkAvailable());
     oledPrintf(OLED_SCREEN1, "Uptime:%ld", uptime);
-    oledPrintf(OLED_SCREEN1, "RunHours:%d", globalDeviceStats->totalRunningHours);
     oledPrintf(OLED_SCREEN1, "PowerCycl:%d", globalDeviceStats->totalPowercycles);
-    oledPrintf(OLED_SCREEN1, "Req:%ld", mbusCommStats->requestCnt);
-    oledPrintf(OLED_SCREEN1, "Err:%ld", mbusCommStats->errorCnt);
-
+    oledPrintf(OLED_SCREEN1, "Req:%ld", mbusCommStats->mbusRequestCnt);
+    oledPrintf(OLED_SCREEN1, "Err:%ld", mbusCommStats->mbusErrorCnt);
+    oledPrintf(OLED_SCREEN1, "Uart:%d", mbusCommStats->uartOverrunCnt + mbusCommStats->uartFramingErrCnt + mbusCommStats->uartParityErrCnt);
 }
 
 void mqttCommHandler(void *handle) {

cube/User/Src/ringbuffer.c

@@ -19,6 +19,7 @@ void ringbufferFree(ringbuffer_t *handle) {
     handle->bufferWriteIdx = 0;    
 }
 
+
 int ringbufferPut(ringbuffer_t *handle, uint8_t *data, uint32_t dataLen) {
     uint32_t freeSpace = 0;
     if (handle->bufferReadIdx == handle->bufferWriteIdx) {
@@ -61,7 +62,7 @@ uint8_t *ringbufferGet(ringbuffer_t *handle, uint32_t dataLen) {
 
 int ringbufferGetOne(ringbuffer_t *handle) {
     int res = -1;
-    if (! ringbufferEmpty(handle)) {
+    if (handle->bufferReadIdx != handle->bufferWriteIdx) {
         uint8_t r = *(handle->buffer + handle->bufferReadIdx);
         handle->bufferReadIdx += 1;
         if (handle->bufferReadIdx == handle->bufferSize) {

tests/Makefile

@@ -1,6 +1,6 @@
 CFLAGS=-I../cube/User/Inc -DTEST
 
-test:	ringbuffer.o logger.o test.o
+test:	ringbuffer.o  test.o
 	gcc -o $@ -lcunit $^
 
 ringbuffer.o: ../cube/User/Src/ringbuffer.c

tests/test.c

@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <ringbuffer.h>
-#include <logger.h>
+//#include <logger.h>
 
 
 // #define DEBUG
@@ -10,6 +10,7 @@
 ringbuffer_t rb;
 
 
+
 void printRingbuffer(ringbuffer_t *rb) {
     printf("Ringbuffer:\n");
     printf("  Size:     %u\n", rb->bufferSize);
@@ -817,8 +818,75 @@ void testRingbuffer99() {
 }
 
 
+void testRingbuffer100() {
+#ifdef DEBUG    
+    printf("Initialize ringbuffer\n");
+#endif
+    ringbufferInit(&rb, 16);
+#ifdef DEBUG
+    printRingbuffer(&rb);
+#endif
+
+    CU_ASSERT(rb.buffer != NULL);
+    CU_ASSERT(rb.bufferSize == 16);
+    CU_ASSERT(rb.bufferWriteIdx == 0);
+    CU_ASSERT(rb.bufferReadIdx == 0);
+
+    CU_ASSERT(rb.buffer[0] == 0);
+    CU_ASSERT(rb.buffer[1] == 0);
+    CU_ASSERT(rb.buffer[2] == 0);
+    CU_ASSERT(rb.buffer[3] == 0);
+    CU_ASSERT(rb.buffer[4] == 0);
+    CU_ASSERT(rb.buffer[5] == 0);
+    CU_ASSERT(rb.buffer[6] == 0);
+    CU_ASSERT(rb.buffer[7] == 0);
+    CU_ASSERT(rb.buffer[8] == 0);
+    CU_ASSERT(rb.buffer[9] == 0);
+    CU_ASSERT(rb.buffer[10] == 0);
+    CU_ASSERT(rb.buffer[11] == 0);
+    CU_ASSERT(rb.buffer[12] == 0);
+    CU_ASSERT(rb.buffer[13] == 0);
+    CU_ASSERT(rb.buffer[14] == 0);
+    CU_ASSERT(rb.buffer[15] == 0);
+}
 
 
+void testRingbuffer101() {
+#ifdef DEBUG
+    printf("\nPut 1 chars in buffer\n");
+#endif
+    int r = ringbufferPutOne(&rb, 'a');
+#ifdef DEBUG
+    printf("r = %d\n", r);
+    printRingbuffer(&rb);
+#endif
+
+    CU_ASSERT(r == 0);
+    CU_ASSERT(rb.buffer != NULL);
+    CU_ASSERT(rb.bufferSize == 16);
+    CU_ASSERT(rb.bufferWriteIdx == 1);
+    CU_ASSERT(rb.bufferReadIdx == 0);
+
+    CU_ASSERT(rb.buffer[0] == 'a');
+    CU_ASSERT(rb.buffer[1] == 0);
+    CU_ASSERT(rb.buffer[2] == 0);
+    CU_ASSERT(rb.buffer[3] == 0);
+    CU_ASSERT(rb.buffer[4] == 0);
+    CU_ASSERT(rb.buffer[5] == 0);
+    CU_ASSERT(rb.buffer[6] == 0);
+    CU_ASSERT(rb.buffer[7] == 0);
+    CU_ASSERT(rb.buffer[8] == 0);
+    CU_ASSERT(rb.buffer[9] == 0);
+    CU_ASSERT(rb.buffer[10] == 0);
+    CU_ASSERT(rb.buffer[11] == 0);
+    CU_ASSERT(rb.buffer[12] == 0);
+    CU_ASSERT(rb.buffer[13] == 0);
+    CU_ASSERT(rb.buffer[14] == 0);
+    CU_ASSERT(rb.buffer[15] == 0);
+}
+
+
+/*
 int init_suite_logger(void) {
     logInit();
     return 0;
@@ -949,7 +1017,7 @@ void testLogger2() {
     CU_ASSERT(strcmp(goldValueFullNotOk, buffer) != 0);
     CU_ASSERT(strcmp(goldValueFullOk, buffer) == 0);
 }
-
+*/
 
 
 int main() {
@@ -980,11 +1048,14 @@ int main() {
         (NULL == CU_add_test(ringbufferSuite, "test 14 of ringbuffer", testRingbuffer15)) ||
         (NULL == CU_add_test(ringbufferSuite, "test 14 of ringbuffer", testRingbuffer16)) ||
         (NULL == CU_add_test(ringbufferSuite, "test 99 of ringbuffer, free", testRingbuffer99)) ||
+        (NULL == CU_add_test(ringbufferSuite, "test 100 of ringbuffer, free", testRingbuffer100)) ||
+        (NULL == CU_add_test(ringbufferSuite, "test 101 of ringbuffer, free", testRingbuffer101)) ||
         0 ) {
         CU_cleanup_registry();
         return CU_get_error();
     }
 
+/*
     CU_pSuite loggerSuite = CU_add_suite("Suite_Logger", init_suite_logger, clean_suite_logger);
     if (NULL == loggerSuite) {
         CU_cleanup_registry();
@@ -999,7 +1070,7 @@ int main() {
         CU_cleanup_registry();
         return CU_get_error();
     }
-
+*/
 
     CU_basic_set_mode(CU_BRM_VERBOSE);
     CU_basic_run_tests();