diff --git a/cube/Core/Src/stm32f1xx_it.c b/cube/Core/Src/stm32f1xx_it.c
index 6e032cf..1595211 100644
--- a/cube/Core/Src/stm32f1xx_it.c
+++ b/cube/Core/Src/stm32f1xx_it.c
@@ -1,4 +1,4 @@
-// Processed by ../tools/insertMyCode.sh
+// Processed by ../tools/insertMyCode.sh
 /* USER CODE BEGIN Header */
 /**
   ******************************************************************************
@@ -23,8 +23,8 @@
 #include "main.h"
 #include "stm32f1xx_it.h"
 /* Private includes ----------------------------------------------------------*/
-/* USER CODE BEGIN Includes */
-#include "main2.h"
+/* USER CODE BEGIN Includes */
+#include "main2.h"
 
 /* USER CODE END Includes */
 
@@ -191,8 +191,8 @@ void SysTick_Handler(void)
 
   /* USER CODE END SysTick_IRQn 0 */
   HAL_IncTick();
-  /* USER CODE BEGIN SysTick_IRQn 1 */
-  SYSTICK_Callback();
+  /* USER CODE BEGIN SysTick_IRQn 1 */
+  SYSTICK_Callback();
 
 
   /* USER CODE END SysTick_IRQn 1 */
@@ -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 */
 }
 
diff --git a/cube/User/Src/main2.c b/cube/User/Src/main2.c
index cd2a13c..0a4194c 100644
--- a/cube/User/Src/main2.c
+++ b/cube/User/Src/main2.c
@@ -92,30 +92,15 @@ 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);
     }
 }
-
-void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
-    if (huart == &mbusUart) {
-        mbusCommErrorCallback(huart);
-    }
-}
\ No newline at end of file
diff --git a/cube/User/Src/mbusComm.c b/cube/User/Src/mbusComm.c
index 527a24e..34f458f 100644
--- a/cube/User/Src/mbusComm.c
+++ b/cube/User/Src/mbusComm.c
@@ -87,7 +87,7 @@ typedef struct {
     uint8_t addr;
     uint8_t sendBuf[5];
     uint8_t receiveCnt;
-    uint8_t receivedOctet;
+    bool waitForOctet;
     bool receiving;
     ringbuffer_t *receiveBuffer;    
     e_mbusCommResult result;
@@ -96,7 +96,7 @@ typedef struct {
 } 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, .receiveCnt = 0, .waitForOctet = false, .receiving = false };
 
 static t_mbusCommStats mbusCommStats = { .requestCnt = 0, .errorCnt = 0, .overrunCnt = 0 };
 
@@ -111,21 +111,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 %.2f", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio);
+                 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));
@@ -150,30 +150,30 @@ 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);
+        coloredMsg(LOG_YELLOW, false, "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;
@@ -184,24 +184,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,
+                               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));
@@ -210,312 +210,271 @@ 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 %.2f", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio);
+        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;
-}
 
-static void receiveNext(t_mbusCommHandle *localMbusCommHandle) {
-    localMbusCommHandle->receiving = true;
-    // coloredMsg(LOG_RED, false, "RN1: %d", localMbusCommHandle->state);
-    __attribute__((unused)) HAL_StatusTypeDef res = HAL_UART_Receive_IT(&mbusUart, &(localMbusCommHandle->receivedOctet), 1);
-    // coloredMsg(LOG_RED, false, "RN2: 0x%02x", res);
-}
+void mbusCommISR() {
 
-void mbusCommRxCpltCallback(UART_HandleTypeDef *huart) {
-    if (mbusCommHandle.receiving) {
-        // coloredMsg(LOG_RED, false, "RO1: 0x%02x", mbusCommHandle.receivedOctet);
-        // schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
-        ringbufferPut(&(mbusCommHandle.receiveBuffer), &(mbusCommHandle.receivedOctet), 1);
-        __attribute__((unused)) HAL_StatusTypeDef res = HAL_UART_Receive_IT(&mbusUart, &(mbusCommHandle.receivedOctet), 1);
-        // coloredMsg(LOG_RED, false, "RO2: 0x%02x", res);
-        mbusCommHandle.receiving = false;
-    }
-}
-
-void mbusCommErrorCallback(UART_HandleTypeDef *huart) {
-    coloredMsg(LOG_RED, false, "mbc errcb 0x%02x", huart->ErrorCode);
-    if (huart->ErrorCode == HAL_UART_ERROR_ORE) {
-        coloredMsg(LOG_RED, false, "mbc errcb overrun error, restart receiving");
-        mbusCommStats.overrunCnt += 1;
-        HAL_StatusTypeDef res = HAL_UART_Receive_IT(&mbusUart, &(mbusCommHandle.receivedOctet), 1);
-        coloredMsg(LOG_RED, false, "mbc errcb, recv: 0x%02x", res);
-    }
 }
 
 void mbusCommExec() {
-    t_mbusCommHandle *localMbusCommHandle = &mbusCommHandle;
-
     static uint8_t userdataIdx = 0;
     static uint8_t calculatedChksum = 0;
 
-    switch (localMbusCommHandle->state) {
+    uint8_t receivedOctet = 0;
+    if (mbusCommHandle.waitForOctet) {
+        // when data available, take from buffer and put into receivedOctet
+        // otherwise return
+        return;
+    }
+
+    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.sendBuf[0] = 0x10;
+        mbusCommHandle.sendBuf[1] = mbusCommHandle.cmd;
+        mbusCommHandle.sendBuf[2] = mbusCommHandle.addr;
+        mbusCommHandle.sendBuf[3] = mbusCommHandle.cmd + mbusCommHandle.addr; // checksum
+        mbusCommHandle.sendBuf[4] = 0x16;
+        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
+            // FIXME somehow manage to delay for about 100ms
         } else {
-            localMbusCommHandle->retryCnt = 0;
-            HAL_UART_Transmit_IT(&mbusUart, localMbusCommHandle->sendBuf, 5);
+            mbusCommHandle.retryCnt = 0;
+            // FIXME sending possibly needs to be done in a different way
+            HAL_UART_Transmit(&mbusUart, mbusCommHandle.sendBuf, 5, HAL_MAX_DELAY);
             // transition from here to SENDING_DONE is initiate by mbusCommTxCpltCallback
             // interrupt callback
-            localMbusCommHandle->state = MBCS_SENDING_DONE;
+            mbusCommHandle.state = MBCS_SENDING_DONE;
         }
         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;
+        // FIXME somehow manage to delay for about 3ms
         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.waitForOctet = true;
+        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);
         show(LED_RED, ON);
-        localMbusCommHandle->state = MBCS_ERROR_CONTINUED;
+        mbusCommHandle.state = MBCS_ERROR_CONTINUED;
         // no break
 
         case MBCS_ERROR_CONTINUED:
-        receiveNext(localMbusCommHandle);
         break;
 
         case MBCS_TIMEOUT:
-        coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", localMbusCommHandle->requestId);
+        coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", mbusCommHandle.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;
+        mbusCommHandle.device->failures += 1;
+        printError();
+        mbusCommHandle.receiving = false;        
+        if (mbusCommHandle.frame.userdata != NULL) {
+            free(mbusCommHandle.frame.userdata);
+            mbusCommHandle.frame.userdata = NULL;
         }
+        // FIXME check whether abort of receiving is necessary at all
         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);
+        coloredMsg(LOG_RED, false, "mbc hre [%d] abort, last receive result: %02x", mbusCommHandle.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.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 mbusCommEnable(bool enable) {
     mbusCommEnabled = enable;
 }
@@ -542,7 +501,6 @@ static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) {
                     mbusCommStats.errorCnt);
 
             oledPrint(OLED_SCREEN0, mbusDevice->deviceName);
-            schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
             res = MBCRR_TRIGGERED;   
 
             mbusCommStats.requestCnt += 1;
@@ -707,10 +665,6 @@ static void mbusCommScheduler(void *handle) {
 
 void mbusCommInit() {
     coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication");
-    ringbufferInit(&(mbusCommHandle.receiveBuffer), 256);
-    coloredMsg(LOG_GREEN, true, "mbc mci ringbuffer created");
-    HAL_StatusTypeDef recvRet = HAL_UART_Receive_IT(&mbusUart, &(mbusCommHandle.receivedOctet), 1);
-    coloredMsg(LOG_GREEN, true, "mbc mci enable receiver, retCode: 0x%02x", recvRet);
 
     schAdd(mbusCommScheduler, NULL, 0, 1000);
 }