wn/mbusgateway3variant
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactoring meterbus

Browse Source
This commit is contained in:
Wolfgang Hottgenroth 2020-11-24 13:18:18 +01:00
parent c1949f4cd3
commit 5cae5a1de3
Signed by: wn
GPG Key ID: 6C1E5E531E0D5D7F
3 changed files with 163 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
cube/Core/Src/stm32f1xx_it.c
View File

@ -1,4 +1,4 @@
// Processed by ../tools/insertMyCode.sh // Processed by ../tools/insertMyCode.sh
/* USER CODE BEGIN Header */ /* USER CODE BEGIN Header */
/** /**
****************************************************************************** ******************************************************************************
@ -23,8 +23,8 @@
#include "main.h" #include "main.h"
#include "stm32f1xx_it.h" #include "stm32f1xx_it.h"
/* Private includes ----------------------------------------------------------*/ /* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */ /* USER CODE BEGIN Includes */
#include "main2.h" #include "main2.h"
/* USER CODE END Includes */ /* USER CODE END Includes */
@ -191,8 +191,8 @@ void SysTick_Handler(void)
/* USER CODE END SysTick_IRQn 0 */ /* USER CODE END SysTick_IRQn 0 */
HAL_IncTick(); HAL_IncTick();
/* USER CODE BEGIN SysTick_IRQn 1 */ /* USER CODE BEGIN SysTick_IRQn 1 */
SYSTICK_Callback(); SYSTICK_Callback();
/* USER CODE END SysTick_IRQn 1 */ /* USER CODE END SysTick_IRQn 1 */
@ -261,6 +261,9 @@ void UART4_IRQHandler(void)
/* USER CODE END UART4_IRQn 1 */ /* USER CODE END UART4_IRQn 1 */
} }
void mbusCommISR();
/** /**
* @brief This function handles UART5 global interrupt. * @brief This function handles UART5 global interrupt.
*/ */
@ -269,9 +272,11 @@ void UART5_IRQHandler(void)
/* USER CODE BEGIN UART5_IRQn 0 */ /* USER CODE BEGIN UART5_IRQn 0 */
/* USER CODE END UART5_IRQn 0 */ /* USER CODE END UART5_IRQn 0 */
HAL_UART_IRQHandler(&huart5); // HAL_UART_IRQHandler(&huart5);
/* USER CODE BEGIN UART5_IRQn 1 */ /* USER CODE BEGIN UART5_IRQn 1 */
mbusCommISR();
/* USER CODE END UART5_IRQn 1 */ /* USER CODE END UART5_IRQn 1 */
} }

17
cube/User/Src/main2.c
View File

@ -92,30 +92,15 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
} }
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) { void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
if (huart == &mbusUart) {
mbusCommTxCpltCallback(huart);
}
#ifdef LOGGER_OUTPUT_BY_INTERRUPT #ifdef LOGGER_OUTPUT_BY_INTERRUPT
else if (huart == &debugUart) { if (huart == &debugUart) {
debugTxCpltCallback(huart); debugTxCpltCallback(huart);
} }
#endif //LOGGER_OUTPUT_BY_INTERRUPT #endif //LOGGER_OUTPUT_BY_INTERRUPT
} }
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
if (huart == &mbusUart) {
mbusCommRxCpltCallback(huart);
}
}
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
if (hspi == &eepromSpi) { if (hspi == &eepromSpi) {
eepromSpiTxCpltCallback(hspi); eepromSpiTxCpltCallback(hspi);
} }
} }
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
if (huart == &mbusUart) {
mbusCommErrorCallback(huart);
}
}

348
cube/User/Src/mbusComm.c
View File

@ -87,7 +87,7 @@ typedef struct {
uint8_t addr; uint8_t addr;
uint8_t sendBuf[5]; uint8_t sendBuf[5];
uint8_t receiveCnt; uint8_t receiveCnt;
uint8_t receivedOctet; bool waitForOctet;
bool receiving; bool receiving;
ringbuffer_t *receiveBuffer; ringbuffer_t *receiveBuffer;
e_mbusCommResult result; e_mbusCommResult result;
@ -96,7 +96,7 @@ typedef struct {
} t_mbusCommHandle; } 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 }; static t_mbusCommStats mbusCommStats = { .requestCnt = 0, .errorCnt = 0, .overrunCnt = 0 };
@ -111,21 +111,21 @@ t_mbusCommStats *mbusCommGetStats() {
} }
static void printError(t_mbusCommHandle *localMbusCommHandle) { static void printError() {
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 pe [%d] Error ratio is %.2f", coloredMsg(LOG_YELLOW, true, "mbc pe [%d] Error ratio is %.2f",
localMbusCommHandle->requestId, mbusCommHandle.requestId,
errorRatio); errorRatio);
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Error\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\"}", mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Error\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\"}",
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName, mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio); mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio);
oledPrintf(OLED_SCREEN0, "Err:%d/%d %.2f", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio); oledPrintf(OLED_SCREEN0, "Err:%d/%d %.2f", mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio);
} }
static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) { static void parseAndPrintFrame() {
t_longframe *frame = &(localMbusCommHandle->frame); t_longframe *frame = &(mbusCommHandle.frame);
mbus_frame reply; mbus_frame reply;
memset(&reply, 0, sizeof(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); int r = mbus_frame_data_parse(&reply, &frame_data);
if (r == 0) { if (r == 0) {
mbus_data_variable *data_var = &(frame_data.data_var); 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)) { 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)) { 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)) { 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)) { 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)) { 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)) { 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)) { 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)) { 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; mbus_data_record *record;
int i; int i;
@ -184,24 +184,24 @@ static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
record; record;
record = record->next, i++) { record = record->next, i++) {
for (uint8_t j = 0; j < MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS; j++) { 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); parsedVIB_t parsedVIB = parseVIB(record->drh.vib);
coloredMsg(LOG_YELLOW, false, "mbc papf [%d] parsed VIB N: %s, U: %s, E: %d", 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); parsedVIB.name, parsedVIB.unit, parsedVIB.exponent);
if (parsedVIB.found) { if (parsedVIB.found) {
uint32_t value = strtol(mbus_data_record_value(record), NULL, 10); uint32_t value = strtol(mbus_data_record_value(record), NULL, 10);
float weightedValue = ((float) value) * powf(10.0, ((float) parsedVIB.exponent)); float weightedValue = ((float) value) * powf(10.0, ((float) parsedVIB.exponent));
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] %s is %.1f %s (%d * 10^%d)", 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); value, parsedVIB.exponent);
keys[numOfConsideredFields] = parsedVIB.name; keys[numOfConsideredFields] = parsedVIB.name;
values[numOfConsideredFields] = weightedValue; values[numOfConsideredFields] = weightedValue;
numOfConsideredFields++; numOfConsideredFields++;
} else { } else {
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] L:%d, VIF: 0x%02x U:%s V:%s", coloredMsg(LOG_YELLOW, true, "mbc papf [%d] L:%d, VIF: 0x%02x U:%s V:%s",
localMbusCommHandle->requestId, mbusCommHandle.requestId,
localMbusCommHandle->device->consideredField[j], mbusCommHandle.device->consideredField[j],
record->drh.vib.vif, record->drh.vib.vif,
mbus_data_record_unit(record), mbus_data_record_unit(record),
mbus_data_record_value(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", coloredMsg(LOG_YELLOW, true, "mbc papf [%d] Error ratio is %.2f",
localMbusCommHandle->requestId, mbusCommHandle.requestId,
errorRatio); errorRatio);
if (numOfConsideredFields == 1) { if (numOfConsideredFields == 1) {
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \ mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
"\"Values\":{\"%s\":\"%.1f\"}}", "\"Values\":{\"%s\":\"%.1f\"}}",
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName, mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio, mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
keys[0], values[0]); keys[0], values[0]);
} else if (numOfConsideredFields == 2) { } else if (numOfConsideredFields == 2) {
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \ mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
"\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\"}}",
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName, mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio, mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
keys[0], values[0], keys[1], values[1]); keys[0], values[0], keys[1], values[1]);
} else if (numOfConsideredFields == 3) { } else if (numOfConsideredFields == 3) {
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \ mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
"\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}",
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName, mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio, mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
keys[0], values[0], keys[1], values[1], keys[2], values[2]); keys[0], values[0], keys[1], values[1], keys[2], values[2]);
} else if (numOfConsideredFields == 4) { } else if (numOfConsideredFields == 4) {
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \ mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
"\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}", "\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\", \"%s\":\"%.1f\"}}",
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName, mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio, mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
keys[0], values[0], keys[1], values[1], keys[2], values[2], keys[3], values[3]); 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); mbus_data_record_free(data_var->record);
} else { } 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) { void mbusCommISR() {
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 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() { void mbusCommExec() {
t_mbusCommHandle *localMbusCommHandle = &mbusCommHandle;
static uint8_t userdataIdx = 0; static uint8_t userdataIdx = 0;
static uint8_t calculatedChksum = 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: 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; break;
case MBCS_SEND: case MBCS_SEND:
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", localMbusCommHandle->requestId); coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", mbusCommHandle.requestId);
localMbusCommHandle->sendBuf[0] = 0x10; mbusCommHandle.sendBuf[0] = 0x10;
localMbusCommHandle->sendBuf[1] = localMbusCommHandle->cmd; mbusCommHandle.sendBuf[1] = mbusCommHandle.cmd;
localMbusCommHandle->sendBuf[2] = localMbusCommHandle->addr; mbusCommHandle.sendBuf[2] = mbusCommHandle.addr;
localMbusCommHandle->sendBuf[3] = localMbusCommHandle->cmd + localMbusCommHandle->addr; // checksum mbusCommHandle.sendBuf[3] = mbusCommHandle.cmd + mbusCommHandle.addr; // checksum
localMbusCommHandle->sendBuf[4] = 0x16; mbusCommHandle.sendBuf[4] = 0x16;
localMbusCommHandle->state = MBCS_SEND_CONTINUED; mbusCommHandle.state = MBCS_SEND_CONTINUED;
// no break !! // no break !!
case MBCS_SEND_CONTINUED: 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); show(LED_RED, OFF);
if (! loopActive) { if (! loopActive) {
coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", localMbusCommHandle->requestId, localMbusCommHandle->retryCnt); coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", mbusCommHandle.requestId, mbusCommHandle.retryCnt);
localMbusCommHandle->retryCnt++; mbusCommHandle.retryCnt++;
loopEnable(); loopEnable();
schAdd(handleRequestEngine, handle, 100, 0); // give 100ms to settled the loop // FIXME somehow manage to delay for about 100ms
} else { } else {
localMbusCommHandle->retryCnt = 0; mbusCommHandle.retryCnt = 0;
HAL_UART_Transmit_IT(&mbusUart, localMbusCommHandle->sendBuf, 5); // 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 // transition from here to SENDING_DONE is initiate by mbusCommTxCpltCallback
// interrupt callback // interrupt callback
localMbusCommHandle->state = MBCS_SENDING_DONE; mbusCommHandle.state = MBCS_SENDING_DONE;
} }
break; break;
case MBCS_SENDING_DONE: case MBCS_SENDING_DONE:
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", localMbusCommHandle->requestId); coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", mbusCommHandle.requestId);
localMbusCommHandle->state = MBCS_ENABLE_FRONTEND; mbusCommHandle.state = MBCS_ENABLE_FRONTEND;
schAdd(handleRequestEngine, handle, 3, 0); // FIXME somehow manage to delay for about 3ms
break; break;
case MBCS_ENABLE_FRONTEND: 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(); frontendEnable();
schAdd(timeoutHandler, handle, 2500, 0);
calculatedChksum = 0; calculatedChksum = 0;
userdataIdx = 0; userdataIdx = 0;
localMbusCommHandle->state = MBCS_START1; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_START1;
break; break;
case MBCS_START1: case MBCS_START1:
if (localMbusCommHandle->receivedOctet == 0x68) { if (receivedOctet == 0x68) {
localMbusCommHandle->frame.start1 = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.start1 = receivedOctet;
localMbusCommHandle->state = MBCS_LENGTH1; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_LENGTH1;
} else { } else {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start1 symbol %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet); coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start1 symbol %02x", mbusCommHandle.requestId, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START1; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__START1;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} }
break; break;
case MBCS_LENGTH1: case MBCS_LENGTH1:
if (localMbusCommHandle->receivedOctet <= 3) { if (receivedOctet <= 3) {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: length to small %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet); coloredMsg(LOG_RED, true, "mbc hre [%d] err: length to small %02x", mbusCommHandle.requestId, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH1; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__LENGTH1;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} else { } else {
localMbusCommHandle->frame.length1 = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.length1 = receivedOctet;
localMbusCommHandle->frame.userdata = (uint8_t*) malloc(localMbusCommHandle->frame.length1 - 3); mbusCommHandle.frame.userdata = (uint8_t*) malloc(mbusCommHandle.frame.length1 - 3);
if (! localMbusCommHandle->frame.userdata) { if (! mbusCommHandle.frame.userdata) {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: unable to allocate memory for userdata", localMbusCommHandle->requestId); coloredMsg(LOG_RED, true, "mbc hre [%d] err: unable to allocate memory for userdata", mbusCommHandle.requestId);
localMbusCommHandle->result = MBCR_ERROR_OUT_OF_MEMORY__USERDATA; mbusCommHandle.result = MBCR_ERROR_OUT_OF_MEMORY__USERDATA;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} else { } else {
localMbusCommHandle->state = MBCS_LENGTH2; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_LENGTH2;
} }
} }
break; break;
case MBCS_LENGTH2: 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", coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid length2 %02x vs. %02x",
localMbusCommHandle->requestId, localMbusCommHandle->frame.length1, localMbusCommHandle->receivedOctet); mbusCommHandle.requestId, mbusCommHandle.frame.length1, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH2; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__LENGTH2;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} else { } else {
localMbusCommHandle->frame.length2 = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.length2 = receivedOctet;
localMbusCommHandle->state = MBCS_START2; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_START2;
} }
break; break;
case MBCS_START2: case MBCS_START2:
if (localMbusCommHandle->receivedOctet == 0x68) { if (receivedOctet == 0x68) {
localMbusCommHandle->frame.start2 = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.start2 = receivedOctet;
localMbusCommHandle->state = MBCS_C_FIELD; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_C_FIELD;
} else { } else {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start2 symbol %02x", coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start2 symbol %02x",
localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet); mbusCommHandle.requestId, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START2; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__START2;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} }
break; break;
case MBCS_C_FIELD: case MBCS_C_FIELD:
localMbusCommHandle->frame.c = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.c = receivedOctet;
calculatedChksum += localMbusCommHandle->receivedOctet; calculatedChksum += receivedOctet;
localMbusCommHandle->state = MBCS_A_FIELD; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_A_FIELD;
break; break;
case MBCS_A_FIELD: case MBCS_A_FIELD:
localMbusCommHandle->frame.a = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.a = receivedOctet;
calculatedChksum += localMbusCommHandle->receivedOctet; calculatedChksum += receivedOctet;
localMbusCommHandle->state = MBCS_CI_FIELD; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_CI_FIELD;
break; break;
case MBCS_CI_FIELD: case MBCS_CI_FIELD:
localMbusCommHandle->frame.ci = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.ci = receivedOctet;
calculatedChksum += localMbusCommHandle->receivedOctet; calculatedChksum += receivedOctet;
localMbusCommHandle->state = MBCS_USERDATA; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_USERDATA;
break; break;
case MBCS_USERDATA: case MBCS_USERDATA:
localMbusCommHandle->frame.userdata[userdataIdx] = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.userdata[userdataIdx] = receivedOctet;
calculatedChksum += localMbusCommHandle->receivedOctet; calculatedChksum += receivedOctet;
userdataIdx++; userdataIdx++;
if (userdataIdx == (localMbusCommHandle->frame.length1 - 3)) { mbusCommHandle.waitForOctet = true;
localMbusCommHandle->state = MBCS_CHKSUM; if (userdataIdx == (mbusCommHandle.frame.length1 - 3)) {
mbusCommHandle.state = MBCS_CHKSUM;
} }
receiveNext(localMbusCommHandle);
break; break;
case MBCS_CHKSUM: case MBCS_CHKSUM:
if (localMbusCommHandle->receivedOctet != calculatedChksum) { if (receivedOctet != calculatedChksum) {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid checksum %02x vs %02x", coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid checksum %02x vs %02x",
localMbusCommHandle->requestId, calculatedChksum, localMbusCommHandle->receivedOctet); mbusCommHandle.requestId, calculatedChksum, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} else { } else {
localMbusCommHandle->frame.chksum = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.chksum = receivedOctet;
localMbusCommHandle->state = MBCS_STOP; mbusCommHandle.waitForOctet = true;
receiveNext(localMbusCommHandle); mbusCommHandle.state = MBCS_STOP;
} }
break; break;
case MBCS_STOP: case MBCS_STOP:
if (localMbusCommHandle->receivedOctet == 0x16) { if (receivedOctet == 0x16) {
localMbusCommHandle->frame.stop = localMbusCommHandle->receivedOctet; mbusCommHandle.frame.stop = receivedOctet;
localMbusCommHandle->state = MBCS_DONE; mbusCommHandle.state = MBCS_DONE;
schAdd(handleRequestEngine, handle, 0, 0);
} else { } else {
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid stop symbol %02x", coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid stop symbol %02x",
localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet); mbusCommHandle.requestId, receivedOctet);
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__STOP; mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__STOP;
localMbusCommHandle->state = MBCS_ERROR; mbusCommHandle.state = MBCS_ERROR;
schAdd(handleRequestEngine, handle, 0, 0);
} }
break; break;
case MBCS_DONE: case MBCS_DONE:
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DONE", localMbusCommHandle->requestId); // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DONE", mbusCommHandle.requestId);
parseAndPrintFrame(localMbusCommHandle); parseAndPrintFrame();
if (localMbusCommHandle->frame.userdata != NULL) { if (mbusCommHandle.frame.userdata != NULL) {
free(localMbusCommHandle->frame.userdata); free(mbusCommHandle.frame.userdata);
localMbusCommHandle->frame.userdata = NULL; mbusCommHandle.frame.userdata = NULL;
} }
localMbusCommHandle->result = MBCR_SUCCESS; mbusCommHandle.result = MBCR_SUCCESS;
localMbusCommHandle->state = MBCS_DISABLE_FRONTEND; mbusCommHandle.state = MBCS_DISABLE_FRONTEND;
schDel(timeoutHandler, handle);
schAdd(handleRequestEngine, handle, 0, 0);
break; break;
case MBCS_ERROR: 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); show(LED_RED, ON);
localMbusCommHandle->state = MBCS_ERROR_CONTINUED; mbusCommHandle.state = MBCS_ERROR_CONTINUED;
// no break // no break
case MBCS_ERROR_CONTINUED: case MBCS_ERROR_CONTINUED:
receiveNext(localMbusCommHandle);
break; break;
case MBCS_TIMEOUT: 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; mbusCommStats.errorCnt += 1;
localMbusCommHandle->device->failures += 1; mbusCommHandle.device->failures += 1;
printError(localMbusCommHandle); printError();
localMbusCommHandle->receiving = false; mbusCommHandle.receiving = false;
if (localMbusCommHandle->frame.userdata != NULL) { if (mbusCommHandle.frame.userdata != NULL) {
free(localMbusCommHandle->frame.userdata); free(mbusCommHandle.frame.userdata);
localMbusCommHandle->frame.userdata = NULL; mbusCommHandle.frame.userdata = NULL;
} }
// FIXME check whether abort of receiving is necessary at all
HAL_UART_AbortReceive(&mbusUart); HAL_UART_AbortReceive(&mbusUart);
uint8_t kitchenSink[16]; uint8_t kitchenSink[16];
memset(kitchenSink, 0, 16); memset(kitchenSink, 0, 16);
HAL_StatusTypeDef r = HAL_UART_Receive(&mbusUart, kitchenSink, 16, 100); 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 // no break
case MBCS_DISABLE_FRONTEND: 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(); frontendDisable();
localMbusCommHandle->state = MBCS_IDLE; mbusCommHandle.state = MBCS_IDLE;
break; break;
default: default:
localMbusCommHandle->state = MBCS_IDLE; mbusCommHandle.state = MBCS_IDLE;
break; break;
} }
} }
void mbusCommTxCpltCallback(UART_HandleTypeDef *huart) {
schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
}
void mbusCommEnable(bool enable) { void mbusCommEnable(bool enable) {
mbusCommEnabled = enable; mbusCommEnabled = enable;
} }
@ -542,7 +501,6 @@ static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) {
mbusCommStats.errorCnt); mbusCommStats.errorCnt);
oledPrint(OLED_SCREEN0, mbusDevice->deviceName); oledPrint(OLED_SCREEN0, mbusDevice->deviceName);
schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
res = MBCRR_TRIGGERED; res = MBCRR_TRIGGERED;
mbusCommStats.requestCnt += 1; mbusCommStats.requestCnt += 1;
@ -707,10 +665,6 @@ static void mbusCommScheduler(void *handle) {
void mbusCommInit() { void mbusCommInit() {
coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication"); 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); schAdd(mbusCommScheduler, NULL, 0, 1000);
} }