#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const uint8_t MBUS_QUERY_CMD = 0x5b; typedef enum { MBCR_SUCCESS = 0, MBCR_ERROR_TIMEOUT, MBCR_ERROR_LOOP_FAILURE, MBCR_ERROR_TX_REG_UNACCESSIBLE, MBCR_ERROR_OUT_OF_MEMORY__FRAME, MBCR_ERROR_OUT_OF_MEMORY__USERDATA, MBCR_ERROR_STATE_ENGINE__START1, MBCR_ERROR_STATE_ENGINE__LENGTH1, MBCR_ERROR_STATE_ENGINE__LENGTH2, MBCR_ERROR_STATE_ENGINE__START2, MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM, MBCR_ERROR_STATE_ENGINE__STOP, MBCR_ERROR_STATE_ENGINE__ILLEGAL_STATE, MBCR_ERROR_STATE_ENGINE__UNKNOWN } e_mbusCommResult; typedef enum { MBCS_IDLE, MBCS_SEND, MBCS_SEND_CONTINUED, MBCS_SENDING_DONE, MBCS_ENABLE_FRONTEND, MBCS_START1, MBCS_LENGTH1, MBCS_LENGTH2, MBCS_START2, MBCS_C_FIELD, MBCS_A_FIELD, MBCS_CI_FIELD, MBCS_USERDATA, MBCS_CHKSUM, MBCS_STOP, MBCS_DONE, MBCS_TIMEOUT, MBCS_DISABLE_FRONTEND, MBCS_ERROR, MBCS_ERROR_CONTINUED } e_mbusCommState; typedef struct { uint8_t start1; uint8_t length1; uint8_t length2; uint8_t start2; uint8_t l; uint8_t c; uint8_t a; uint8_t ci; uint8_t *userdata; uint8_t chksum; uint8_t stop; } t_longframe; typedef struct { uint32_t requestId; e_mbusCommState state; uint8_t retryCnt; uint8_t cmd; uint8_t addr; uint8_t sendBuf[5]; uint8_t receiveCnt; uint8_t receivedOctet; bool receiving; 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_mbusCommStats mbusCommStats = { .requestCnt = 0, .errorCnt = 0 }; static bool mbusCommEnabled = true; void mbusCommSetStats(t_mbusCommStats stats) { mbusCommStats = stats; } t_mbusCommStats *mbusCommGetStats() { return &mbusCommStats; } static void printError(t_mbusCommHandle *localMbusCommHandle) { float errorRatio = ((float) localMbusCommHandle->device->failures) / ((float) localMbusCommHandle->device->requests); coloredMsg(LOG_YELLOW, true, "mbc pe [%d] Error ratio is %.2f", localMbusCommHandle->requestId, errorRatio); } static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) { t_longframe *frame = &(localMbusCommHandle->frame); mbus_frame reply; memset(&reply, 0, sizeof(reply)); //mbus_parse(&reply, buf, len); reply.start1 = frame->start1; reply.length1 = frame->length1; reply.length2 = frame->length2; reply.start2 = frame->start2; reply.control = frame->c; reply.address = frame->a; reply.control_information = frame->ci; memcpy(reply.data, frame->userdata, frame->length1 - 3); reply.checksum = frame->chksum; reply.stop = frame->stop; reply.type = MBUS_FRAME_TYPE_LONG; reply.data_size = frame->length1 - 3; mbus_frame_data frame_data; memset(&frame_data, 0, sizeof(frame_data)); 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 & 0x01)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Application Busy", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x02)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Any Application Error", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x04)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Power Low", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x08)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Permanent Error", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x10)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Temporary Error", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x20)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 1", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x40)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 2", localMbusCommHandle->requestId); } if ((data_var->header.status & 0x80)) { coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 3", localMbusCommHandle->requestId); } mbus_data_record *record; int i; for (record = data_var->record, i = 0; record; record = record->next, i++) { for (uint8_t j = 0; j < MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS; j++) { if (localMbusCommHandle->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); 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, value, parsedVIB.exponent); } else { coloredMsg(LOG_YELLOW, true, "mbc papf [%d] L:%d, VIF: 0x%02x U:%s V:%s", localMbusCommHandle->requestId, localMbusCommHandle->device->consideredField[j], record->drh.vib.vif, mbus_data_record_unit(record), mbus_data_record_value(record)); } } } } mbus_data_record_free(data_var->record); float errorRatio = ((float) localMbusCommHandle->device->failures) / ((float) localMbusCommHandle->device->requests); coloredMsg(LOG_YELLOW, true, "mbc papf [%d] Error ratio is %.2f", localMbusCommHandle->requestId, errorRatio); } else { coloredMsg(LOG_RED, true, "mbc papf [%d] err: unable to parse frame", localMbusCommHandle->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); } static void receiveNext(t_mbusCommHandle *localMbusCommHandle) { localMbusCommHandle->receiving = true; HAL_UART_Receive_IT(&mbusUart, &(localMbusCommHandle->receivedOctet), 1); } static void handleRequestEngine(void *handle) { t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle; static uint8_t userdataIdx = 0; static uint8_t calculatedChksum = 0; switch (localMbusCommHandle->state) { case MBCS_IDLE: coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state IDLE", localMbusCommHandle->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; // no break !! case MBCS_SEND_CONTINUED: // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND_CONTINUED", localMbusCommHandle->requestId); show(LED_RED, OFF); if (! loopActive) { coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", localMbusCommHandle->requestId, localMbusCommHandle->retryCnt); localMbusCommHandle->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; } 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); break; case MBCS_ENABLE_FRONTEND: // coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state ENABLE_FRONTEND", localMbusCommHandle->requestId); frontendEnable(); schAdd(timeoutHandler, handle, 2500, 0); calculatedChksum = 0; userdataIdx = 0; localMbusCommHandle->state = MBCS_START1; receiveNext(localMbusCommHandle); break; case MBCS_START1: if (localMbusCommHandle->receivedOctet == 0x68) { localMbusCommHandle->frame.start1 = localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_LENGTH1; receiveNext(localMbusCommHandle); } 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); } 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); } 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); } else { localMbusCommHandle->state = MBCS_LENGTH2; receiveNext(localMbusCommHandle); } } break; case MBCS_LENGTH2: if (localMbusCommHandle->frame.length1 != localMbusCommHandle->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); } else { localMbusCommHandle->frame.length2 = localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_START2; receiveNext(localMbusCommHandle); } break; case MBCS_START2: if (localMbusCommHandle->receivedOctet == 0x68) { localMbusCommHandle->frame.start2 = localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_C_FIELD; receiveNext(localMbusCommHandle); } 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); } break; case MBCS_C_FIELD: localMbusCommHandle->frame.c = localMbusCommHandle->receivedOctet; calculatedChksum += localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_A_FIELD; receiveNext(localMbusCommHandle); break; case MBCS_A_FIELD: localMbusCommHandle->frame.a = localMbusCommHandle->receivedOctet; calculatedChksum += localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_CI_FIELD; receiveNext(localMbusCommHandle); break; case MBCS_CI_FIELD: localMbusCommHandle->frame.ci = localMbusCommHandle->receivedOctet; calculatedChksum += localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_USERDATA; receiveNext(localMbusCommHandle); break; case MBCS_USERDATA: localMbusCommHandle->frame.userdata[userdataIdx] = localMbusCommHandle->receivedOctet; calculatedChksum += localMbusCommHandle->receivedOctet; userdataIdx++; if (userdataIdx == (localMbusCommHandle->frame.length1 - 3)) { localMbusCommHandle->state = MBCS_CHKSUM; } receiveNext(localMbusCommHandle); break; case MBCS_CHKSUM: if (localMbusCommHandle->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); } else { localMbusCommHandle->frame.chksum = localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_STOP; receiveNext(localMbusCommHandle); } break; case MBCS_STOP: if (localMbusCommHandle->receivedOctet == 0x16) { localMbusCommHandle->frame.stop = localMbusCommHandle->receivedOctet; localMbusCommHandle->state = MBCS_DONE; schAdd(handleRequestEngine, handle, 0, 0); } 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); } 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; } localMbusCommHandle->result = MBCR_SUCCESS; localMbusCommHandle->state = MBCS_DISABLE_FRONTEND; schDel(timeoutHandler, handle); schAdd(handleRequestEngine, handle, 0, 0); break; case MBCS_ERROR: coloredMsg(LOG_RED, false, "mbc hre [%d] state ERROR", localMbusCommHandle->requestId); show(LED_RED, ON); mbusCommStats.errorCnt += 1; localMbusCommHandle->device->failures += 1; printError(localMbusCommHandle); localMbusCommHandle->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); localMbusCommHandle->receiving = false; if (localMbusCommHandle->frame.userdata != NULL) { free(localMbusCommHandle->frame.userdata); localMbusCommHandle->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); frontendDisable(); localMbusCommHandle->state = MBCS_IDLE; break; default: localMbusCommHandle->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; } static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) { e_mbusCommRequestResult res = MBCRR_BUSY; if (mbusCommEnabled) { if (mbusCommHandle.state == MBCS_IDLE) { mbusCommHandle.requestId += 1; mbusCommHandle.state = MBCS_SEND; mbusCommHandle.retryCnt = 0; mbusCommHandle.cmd = MBUS_QUERY_CMD; mbusCommHandle.addr = mbusDevice->address; mbusCommHandle.device = mbusDevice; mbusDevice->requests += 1; coloredMsg(LOG_YELLOW, true, "mbc mcr [%d] new request %s R:%d F:%d GRC:%d GEC:%d", mbusCommHandle.requestId, mbusDevice->deviceName, mbusDevice->requests, mbusDevice->failures, mbusCommStats.requestCnt, mbusCommStats.errorCnt); schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0); res = MBCRR_TRIGGERED; mbusCommStats.requestCnt += 1; } } else { res = MBCRR_DISABLED; } return res; } static uint8_t numOfDevices = 8; static t_mbusDevice devices[] = { { .deviceName = "Total Power", .address = 80, .consideredField = { 0, 17, -1, -1 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Computer Power", .address = 85, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Dryer Power", .address = 81, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Laundry Power", .address = 82, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Dishwasher Power", .address = 83, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Light Power", .address = 84, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 15, .delay = 0, .waiting = false }, { .deviceName = "Freezer Power", .address = 86, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false }, { .deviceName = "Fridge Power", .address = 87, .consideredField = { 0, 4, 2, 3 }, .requests = 0, .failures = 0, .period = 60, .delay = 0, .waiting = false } }; static void triggerMBusRequest(void *handle) { static uint8_t deviceIndex = 0; if (devices[deviceIndex].waiting) { e_mbusCommRequestResult r = mbusCommRequest(&(devices[deviceIndex])); if (r == MBCRR_TRIGGERED) { devices[deviceIndex].waiting = false; deviceIndex++; } } else { deviceIndex++; } if (deviceIndex >= numOfDevices) { deviceIndex = 0; } } static void mbusCommScheduler(void *handle) { static uint8_t state = 0; switch (state) { case 0: if (isNetworkAvailable()) { coloredMsg(LOG_YELLOW, true, "mbc mcs activate scheduler by network"); schAdd(triggerMBusRequest, NULL, 0, 100); state = 2; } break; case 1: if (mbusCommEnabled) { coloredMsg(LOG_YELLOW, true, "mbc mcs activate scheduler by request"); schAdd(triggerMBusRequest, NULL, 0, 100); state = 2; } break; case 2: if (! isNetworkAvailable()) { coloredMsg(LOG_YELLOW, true, "mbc mcs deactivate scheduler by network"); schDel(triggerMBusRequest, NULL); loopDisable(); state = 0; } if (! mbusCommEnabled) { coloredMsg(LOG_YELLOW, true, "mbc mcs deactivate scheduler by request"); schDel(triggerMBusRequest, NULL); loopDisable(); state = 1; } for (uint8_t i = 0; i < numOfDevices; i++) { devices[i].delay -= 1; if (devices[i].delay <= 0) { devices[i].delay = devices[i].period; devices[i].waiting = true; coloredMsg(LOG_YELLOW, false, "mbc mcs scheduled: %s", devices[i].deviceName); } } break; } } void mbusCommInit() { coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication"); schAdd(mbusCommScheduler, NULL, 0, 1000); }