707 lines
28 KiB
C
Raw Normal View History

2020-11-02 18:22:08 +01:00
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
2020-11-17 18:44:57 +01:00
#include <math.h>
2020-11-02 18:22:08 +01:00
2020-10-28 19:40:08 +01:00
#include <main.h>
#include <usart.h>
#include <PontCoopScheduler.h>
#include <mbusComm.h>
#include <loopCtrl.h>
2020-11-03 10:05:45 +01:00
#include <show.h>
2020-10-29 21:02:04 +01:00
#include <logger.h>
2020-11-01 18:48:39 +01:00
#include <frontend.h>
2020-11-17 15:38:11 +01:00
#include <wizHelper.h>
2020-11-17 18:11:51 +01:00
#include <mbusParserExt.h>
2020-11-18 14:01:23 +01:00
#include <mqttComm.h>
2020-11-19 20:03:37 +01:00
#include <oled.h>
2020-10-28 19:40:08 +01:00
2020-11-03 10:24:03 +01:00
#include <mbus/mbus-protocol.h>
2020-10-28 19:40:08 +01:00
2020-11-18 14:01:23 +01:00
static const char MBUS_TOPIC[] = "IoT/MBGW3/Measurement";
2020-11-03 14:00:54 +01:00
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
2020-11-03 14:31:59 +01:00
} e_mbusCommResult;
2020-11-03 14:00:54 +01:00
2020-10-28 19:40:08 +01:00
typedef enum {
2020-11-02 19:23:11 +01:00
MBCS_IDLE,
MBCS_SEND,
2020-11-06 21:16:17 +01:00
MBCS_SEND_CONTINUED,
2020-11-02 19:23:11 +01:00
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,
2020-11-02 19:43:37 +01:00
MBCS_TIMEOUT,
2020-11-02 19:23:11 +01:00
MBCS_DISABLE_FRONTEND,
2020-11-18 13:23:17 +01:00
MBCS_ERROR,
MBCS_ERROR_CONTINUED
2020-10-28 19:40:08 +01:00
} e_mbusCommState;
2020-11-03 14:00:54 +01:00
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;
2020-10-28 19:40:08 +01:00
typedef struct {
2020-11-17 12:28:03 +01:00
uint32_t requestId;
2020-10-28 19:40:08 +01:00
e_mbusCommState state;
uint8_t retryCnt;
uint8_t cmd;
uint8_t addr;
uint8_t sendBuf[5];
2020-11-02 17:06:12 +01:00
uint8_t receiveCnt;
2020-11-02 15:41:07 +01:00
uint8_t receivedOctet;
bool receiving;
2020-11-03 14:31:59 +01:00
e_mbusCommResult result;
2020-11-02 19:23:11 +01:00
t_longframe frame;
2020-11-03 14:00:54 +01:00
t_mbusDevice *device;
2020-10-28 19:40:08 +01:00
} t_mbusCommHandle;
2020-11-03 14:00:54 +01:00
2020-11-17 12:28:03 +01:00
static t_mbusCommHandle mbusCommHandle = { .requestId = 0, .state = MBCS_IDLE, .retryCnt = 0, .cmd = 0, .addr = 0, .receiveCnt = 0, .receivedOctet = 0, .receiving = false };
2020-10-28 19:40:08 +01:00
2020-11-22 21:23:52 +01:00
static t_mbusCommStats mbusCommStats = { .requestCnt = 0, .errorCnt = 0, .overrunCnt = 0 };
2020-10-28 19:40:08 +01:00
2020-11-16 17:53:18 +01:00
static bool mbusCommEnabled = true;
2020-11-02 19:37:02 +01:00
2020-11-06 21:16:17 +01:00
void mbusCommSetStats(t_mbusCommStats stats) {
mbusCommStats = stats;
}
t_mbusCommStats *mbusCommGetStats() {
return &mbusCommStats;
}
2020-11-18 13:23:17 +01:00
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);
2020-11-18 18:38:03 +01:00
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);
2020-11-20 22:05:46 +01:00
oledPrintf(OLED_SCREEN0, "Err:%d/%d %.2f", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio);
2020-11-18 13:23:17 +01:00
}
2020-11-17 12:28:03 +01:00
static void parseAndPrintFrame(t_mbusCommHandle *localMbusCommHandle) {
t_longframe *frame = &(localMbusCommHandle->frame);
2020-11-03 14:10:09 +01:00
2020-11-03 10:24:03 +01:00
mbus_frame reply;
memset(&reply, 0, sizeof(reply));
2020-11-03 10:30:53 +01:00
2020-11-03 10:24:03 +01:00
//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;
2020-11-03 10:30:53 +01:00
mbus_frame_data frame_data;
memset(&frame_data, 0, sizeof(frame_data));
2020-11-03 10:24:03 +01:00
2020-11-03 12:42:55 +01:00
int r = mbus_frame_data_parse(&reply, &frame_data);
if (r == 0) {
2020-11-03 12:56:50 +01:00
mbus_data_variable *data_var = &(frame_data.data_var);
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_YELLOW, false, "mbc papf [%d] sts: %02x", localMbusCommHandle->requestId, data_var->header.status);
2020-11-03 14:55:06 +01:00
if ((data_var->header.status & 0x01)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Application Busy", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x02)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Any Application Error", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x04)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Power Low", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x08)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Permanent Error", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x10)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Temporary Error", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x20)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 1", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x40)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 2", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
if ((data_var->header.status & 0x80)) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 3", localMbusCommHandle->requestId);
2020-11-03 14:55:06 +01:00
}
2020-11-03 12:42:55 +01:00
mbus_data_record *record;
int i;
2020-11-20 11:23:44 +01:00
const char *keys[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS];
2020-11-18 18:38:03 +01:00
float values[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS];
uint8_t numOfConsideredFields = 0;
2020-11-03 12:56:50 +01:00
for (record = data_var->record, i = 0;
2020-11-03 12:42:55 +01:00
record;
record = record->next, i++) {
2020-11-03 14:10:09 +01:00
for (uint8_t j = 0; j < MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS; j++) {
2020-11-18 13:42:55 +01:00
if (localMbusCommHandle->device->consideredField[j] == i) {
2020-11-17 18:11:51 +01:00
parsedVIB_t parsedVIB = parseVIB(record->drh.vib);
2020-11-17 19:18:33 +01:00
coloredMsg(LOG_YELLOW, false, "mbc papf [%d] parsed VIB N: %s, U: %s, E: %d",
2020-11-17 18:11:51 +01:00
localMbusCommHandle->requestId,
parsedVIB.name, parsedVIB.unit, parsedVIB.exponent);
2020-11-17 18:44:57 +01:00
if (parsedVIB.found) {
2020-11-17 19:12:15 +01:00
uint32_t value = strtol(mbus_data_record_value(record), NULL, 10);
2020-11-17 18:44:57 +01:00
float weightedValue = ((float) value) * powf(10.0, ((float) parsedVIB.exponent));
2020-11-17 19:18:33 +01:00
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] %s is %.1f %s (%d * 10^%d)",
2020-11-17 19:12:15 +01:00
localMbusCommHandle->requestId, parsedVIB.name, weightedValue, parsedVIB.unit,
value, parsedVIB.exponent);
2020-11-18 18:38:03 +01:00
keys[numOfConsideredFields] = parsedVIB.name;
values[numOfConsideredFields] = weightedValue;
numOfConsideredFields++;
2020-11-17 19:18:33 +01:00
} else {
2020-11-18 13:42:55 +01:00
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] L:%d, VIF: 0x%02x U:%s V:%s",
2020-11-17 19:18:33 +01:00
localMbusCommHandle->requestId,
2020-11-18 13:42:55 +01:00
localMbusCommHandle->device->consideredField[j],
2020-11-17 19:18:33 +01:00
record->drh.vib.vif,
mbus_data_record_unit(record),
mbus_data_record_value(record));
2020-11-17 18:44:57 +01:00
}
2020-11-17 19:03:48 +01:00
2020-11-03 14:10:09 +01:00
}
}
2020-11-03 12:42:55 +01:00
}
2020-11-17 20:04:29 +01:00
float errorRatio = ((float) localMbusCommHandle->device->failures) / ((float) localMbusCommHandle->device->requests);
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] Error ratio is %.2f",
localMbusCommHandle->requestId,
errorRatio);
2020-11-18 18:38:03 +01:00
if (numOfConsideredFields == 1) {
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Ok\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\", " \
2020-11-18 18:51:08 +01:00
"\"Values\":{\"%s\":\"%.1f\"}}",
2020-11-18 18:38:03 +01:00
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->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\", " \
2020-11-18 18:51:08 +01:00
"\"Values\":{\"%s\":\"%.1f\", \"%s\":\"%.1f\"}}",
2020-11-18 18:38:03 +01:00
localMbusCommHandle->requestId, localMbusCommHandle->device->deviceName,
localMbusCommHandle->device->failures, localMbusCommHandle->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,
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,
keys[0], values[0], keys[1], values[1], keys[2], values[2], keys[3], values[3]);
}
2020-11-20 22:05:46 +01:00
oledPrintf(OLED_SCREEN0, "Ok:%d/%d %.2f", localMbusCommHandle->device->failures, localMbusCommHandle->device->requests, errorRatio);
2020-11-18 18:38:03 +01:00
mbus_data_record_free(data_var->record);
2020-11-03 12:42:55 +01:00
} else {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc papf [%d] err: unable to parse frame", localMbusCommHandle->requestId);
2020-11-03 10:58:41 +01:00
}
2020-11-03 10:24:03 +01:00
}
2020-11-02 19:37:02 +01:00
2020-11-02 15:56:54 +01:00
static void handleRequestEngine(void *handle);
2020-11-02 15:41:07 +01:00
static void timeoutHandler(void *handle) {
t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle;
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_RED, true, "mbc th [%d] timeout", localMbusCommHandle->requestId);
2020-11-02 19:43:37 +01:00
localMbusCommHandle->state = MBCS_TIMEOUT;
2020-11-02 15:41:07 +01:00
localMbusCommHandle->receiving = false;
handleRequestEngine(handle);
}
2020-11-02 17:14:11 +01:00
static void receiveNext(t_mbusCommHandle *localMbusCommHandle) {
localMbusCommHandle->receiving = true;
2020-11-22 21:23:52 +01:00
// 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, "RO: 0x%02x", mbusCommHandle.receivedOctet);
schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
mbusCommHandle.receiving = false;
}
}
void mbusCommErrorCallback(UART_HandleTypeDef *huart) {
2020-11-22 22:59:41 +01:00
coloredMsg(LOG_RED, false, "mbc errcb 0x%02x", huart->ErrorCode);
2020-11-22 21:23:52 +01:00
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);
}
2020-11-02 17:14:11 +01:00
}
2020-10-28 19:40:08 +01:00
static void handleRequestEngine(void *handle) {
2020-10-29 15:57:59 +01:00
t_mbusCommHandle *localMbusCommHandle = (t_mbusCommHandle*) handle;
2020-10-28 19:40:08 +01:00
2020-11-02 19:23:11 +01:00
static uint8_t userdataIdx = 0;
static uint8_t calculatedChksum = 0;
2020-10-29 15:57:59 +01:00
switch (localMbusCommHandle->state) {
2020-11-02 19:23:11 +01:00
case MBCS_IDLE:
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state IDLE", localMbusCommHandle->requestId);
2020-10-28 19:40:08 +01:00
break;
2020-11-02 19:23:11 +01:00
case MBCS_SEND:
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", localMbusCommHandle->requestId);
2020-10-29 15:57:59 +01:00
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;
2020-11-06 21:16:17 +01:00
localMbusCommHandle->state = MBCS_SEND_CONTINUED;
2020-10-28 19:40:08 +01:00
// no break !!
2020-11-06 21:16:17 +01:00
case MBCS_SEND_CONTINUED:
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND_CONTINUED", localMbusCommHandle->requestId);
2020-11-03 10:05:45 +01:00
show(LED_RED, OFF);
2020-10-28 19:40:08 +01:00
if (! loopActive) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", localMbusCommHandle->requestId, localMbusCommHandle->retryCnt);
2020-10-29 15:57:59 +01:00
localMbusCommHandle->retryCnt++;
2020-10-28 19:40:08 +01:00
loopEnable();
2020-11-17 12:01:15 +01:00
schAdd(handleRequestEngine, handle, 100, 0); // give 100ms to settled the loop
2020-10-28 19:40:08 +01:00
} else {
localMbusCommHandle->retryCnt = 0;
2020-10-29 15:57:59 +01:00
HAL_UART_Transmit_IT(&mbusUart, localMbusCommHandle->sendBuf, 5);
2020-11-02 15:26:13 +01:00
// transition from here to SENDING_DONE is initiate by mbusCommTxCpltCallback
// interrupt callback
2020-11-02 19:23:11 +01:00
localMbusCommHandle->state = MBCS_SENDING_DONE;
2020-10-29 15:57:59 +01:00
}
break;
2020-11-02 19:23:11 +01:00
case MBCS_SENDING_DONE:
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", localMbusCommHandle->requestId);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->state = MBCS_ENABLE_FRONTEND;
2020-11-02 15:02:39 +01:00
schAdd(handleRequestEngine, handle, 3, 0);
2020-10-28 19:40:08 +01:00
break;
2020-11-02 19:23:11 +01:00
case MBCS_ENABLE_FRONTEND:
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state ENABLE_FRONTEND", localMbusCommHandle->requestId);
2020-11-01 18:48:39 +01:00
frontendEnable();
2020-11-02 18:31:59 +01:00
schAdd(timeoutHandler, handle, 2500, 0);
2020-11-02 19:23:11 +01:00
calculatedChksum = 0;
userdataIdx = 0;
localMbusCommHandle->state = MBCS_START1;
2020-11-02 17:14:11 +01:00
receiveNext(localMbusCommHandle);
break;
2020-11-02 15:41:07 +01:00
2020-11-02 19:23:11 +01:00
case MBCS_START1:
if (localMbusCommHandle->receivedOctet == 0x68) {
localMbusCommHandle->frame.start1 = localMbusCommHandle->receivedOctet;
localMbusCommHandle->state = MBCS_LENGTH1;
2020-11-18 13:15:55 +01:00
receiveNext(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
} else {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start1 symbol %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START1;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
}
break;
case MBCS_LENGTH1:
if (localMbusCommHandle->receivedOctet <= 3) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: length to small %02x", localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH1;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
} else {
localMbusCommHandle->frame.length1 = localMbusCommHandle->receivedOctet;
localMbusCommHandle->frame.userdata = (uint8_t*) malloc(localMbusCommHandle->frame.length1 - 3);
if (! localMbusCommHandle->frame.userdata) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: unable to allocate memory for userdata", localMbusCommHandle->requestId);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_OUT_OF_MEMORY__USERDATA;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
} else {
localMbusCommHandle->state = MBCS_LENGTH2;
2020-11-18 13:15:55 +01:00
receiveNext(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
}
}
break;
case MBCS_LENGTH2:
if (localMbusCommHandle->frame.length1 != localMbusCommHandle->receivedOctet) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid length2 %02x vs. %02x",
2020-11-17 12:28:03 +01:00
localMbusCommHandle->requestId, localMbusCommHandle->frame.length1, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__LENGTH2;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
} else {
localMbusCommHandle->frame.length2 = localMbusCommHandle->receivedOctet;
localMbusCommHandle->state = MBCS_START2;
2020-11-18 13:15:55 +01:00
receiveNext(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
}
2020-11-01 18:48:39 +01:00
break;
2020-11-02 19:23:11 +01:00
case MBCS_START2:
if (localMbusCommHandle->receivedOctet == 0x68) {
localMbusCommHandle->frame.start2 = localMbusCommHandle->receivedOctet;
localMbusCommHandle->state = MBCS_C_FIELD;
2020-11-18 13:15:55 +01:00
receiveNext(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
} else {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid start2 symbol %02x",
2020-11-17 12:28:03 +01:00
localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__START2;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
}
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) {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid checksum %02x vs %02x",
2020-11-17 12:28:03 +01:00
localMbusCommHandle->requestId, calculatedChksum, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
} else {
localMbusCommHandle->frame.chksum = localMbusCommHandle->receivedOctet;
localMbusCommHandle->state = MBCS_STOP;
2020-11-18 13:15:55 +01:00
receiveNext(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
}
break;
case MBCS_STOP:
if (localMbusCommHandle->receivedOctet == 0x16) {
localMbusCommHandle->frame.stop = localMbusCommHandle->receivedOctet;
localMbusCommHandle->state = MBCS_DONE;
schAdd(handleRequestEngine, handle, 0, 0);
} else {
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid stop symbol %02x",
2020-11-17 12:28:03 +01:00
localMbusCommHandle->requestId, localMbusCommHandle->receivedOctet);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_ERROR_STATE_ENGINE__STOP;
localMbusCommHandle->state = MBCS_ERROR;
2020-11-18 13:15:55 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
2020-11-02 19:23:11 +01:00
}
break;
case MBCS_DONE:
2020-11-18 13:33:40 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DONE", localMbusCommHandle->requestId);
2020-11-03 14:10:09 +01:00
parseAndPrintFrame(localMbusCommHandle);
2020-11-02 20:59:52 +01:00
if (localMbusCommHandle->frame.userdata != NULL) {
free(localMbusCommHandle->frame.userdata);
localMbusCommHandle->frame.userdata = NULL;
}
2020-11-02 19:23:11 +01:00
localMbusCommHandle->result = MBCR_SUCCESS;
localMbusCommHandle->state = MBCS_DISABLE_FRONTEND;
2020-11-02 19:43:37 +01:00
schDel(timeoutHandler, handle);
2020-11-02 19:23:11 +01:00
schAdd(handleRequestEngine, handle, 0, 0);
break;
case MBCS_ERROR:
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_RED, false, "mbc hre [%d] state ERROR", localMbusCommHandle->requestId);
2020-11-03 10:05:45 +01:00
show(LED_RED, ON);
2020-11-18 13:23:17 +01:00
localMbusCommHandle->state = MBCS_ERROR_CONTINUED;
// no break
2020-11-18 13:23:36 +01:00
case MBCS_ERROR_CONTINUED:
2020-11-02 19:23:11 +01:00
receiveNext(localMbusCommHandle);
break;
2020-11-02 19:43:37 +01:00
case MBCS_TIMEOUT:
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", localMbusCommHandle->requestId);
2020-11-19 23:07:49 +01:00
mbusCommStats.errorCnt += 1;
localMbusCommHandle->device->failures += 1;
printError(localMbusCommHandle);
2020-11-02 19:23:11 +01:00
localMbusCommHandle->receiving = false;
2020-11-02 20:59:52 +01:00
if (localMbusCommHandle->frame.userdata != NULL) {
free(localMbusCommHandle->frame.userdata);
localMbusCommHandle->frame.userdata = NULL;
}
2020-11-02 17:23:28 +01:00
HAL_UART_AbortReceive(&mbusUart);
2020-11-02 17:57:32 +01:00
uint8_t kitchenSink[16];
2020-11-02 18:19:57 +01:00
memset(kitchenSink, 0, 16);
2020-11-02 19:43:37 +01:00
HAL_StatusTypeDef r = HAL_UART_Receive(&mbusUart, kitchenSink, 16, 100);
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_RED, false, "mbc hre [%d] abort, last receive result: %02x", localMbusCommHandle->requestId, r);
2020-11-02 19:43:37 +01:00
// no break
case MBCS_DISABLE_FRONTEND:
2020-11-18 13:34:45 +01:00
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DISABLE_FRONTEND", localMbusCommHandle->requestId);
2020-11-01 18:48:39 +01:00
frontendDisable();
2020-11-02 19:23:11 +01:00
localMbusCommHandle->state = MBCS_IDLE;
2020-11-01 18:48:39 +01:00
break;
2020-10-28 19:40:08 +01:00
default:
2020-11-02 19:23:11 +01:00
localMbusCommHandle->state = MBCS_IDLE;
2020-10-28 19:40:08 +01:00
break;
}
}
2020-11-02 15:02:39 +01:00
void mbusCommTxCpltCallback(UART_HandleTypeDef *huart) {
2020-11-02 15:26:13 +01:00
schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
2020-11-02 15:02:39 +01:00
}
2020-10-28 19:40:08 +01:00
2020-11-02 15:41:07 +01:00
2020-11-16 17:53:18 +01:00
void mbusCommEnable(bool enable) {
mbusCommEnabled = enable;
}
2020-11-17 15:38:11 +01:00
static e_mbusCommRequestResult mbusCommRequest(t_mbusDevice *mbusDevice) {
2020-11-03 14:31:59 +01:00
e_mbusCommRequestResult res = MBCRR_BUSY;
2020-11-16 17:53:18 +01:00
if (mbusCommEnabled) {
if (mbusCommHandle.state == MBCS_IDLE) {
2020-11-17 12:28:03 +01:00
mbusCommHandle.requestId += 1;
2020-11-16 17:53:18 +01:00
mbusCommHandle.state = MBCS_SEND;
mbusCommHandle.retryCnt = 0;
mbusCommHandle.cmd = MBUS_QUERY_CMD;
mbusCommHandle.addr = mbusDevice->address;
mbusCommHandle.device = mbusDevice;
mbusDevice->requests += 1;
2020-11-17 12:28:03 +01:00
2020-11-17 12:40:24 +01:00
coloredMsg(LOG_YELLOW, true, "mbc mcr [%d] new request %s R:%d F:%d GRC:%d GEC:%d",
2020-11-17 12:28:03 +01:00
mbusCommHandle.requestId,
mbusDevice->deviceName,
mbusDevice->requests,
mbusDevice->failures,
mbusCommStats.requestCnt,
mbusCommStats.errorCnt);
2020-11-20 12:20:30 +01:00
oledPrint(OLED_SCREEN0, mbusDevice->deviceName);
2020-11-16 17:53:18 +01:00
schAdd(handleRequestEngine, (void*) &mbusCommHandle, 0, 0);
res = MBCRR_TRIGGERED;
mbusCommStats.requestCnt += 1;
}
} else {
res = MBCRR_DISABLED;
2020-10-28 19:40:08 +01:00
}
2020-11-17 12:01:15 +01:00
2020-11-03 14:31:59 +01:00
return res;
2020-10-28 19:40:08 +01:00
}
2020-11-17 15:38:11 +01:00
2020-11-22 21:23:52 +01:00
#define PERIOD 60
2020-11-17 15:38:11 +01:00
static uint8_t numOfDevices = 8;
static t_mbusDevice devices[] = {
{
2020-11-18 14:01:23 +01:00
.deviceName = "TotalPower",
2020-11-17 15:38:11 +01:00
.address = 80,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 17, -1, -1 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "ComputerPower",
2020-11-17 15:38:11 +01:00
.address = 85,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "DryerPower",
2020-11-17 15:38:11 +01:00
.address = 81,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "LaundryPower",
2020-11-17 15:38:11 +01:00
.address = 82,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "DishwasherPower",
2020-11-17 15:38:11 +01:00
.address = 83,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "LightPower",
2020-11-17 15:38:11 +01:00
.address = 84,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "FreezerPower",
2020-11-17 15:38:11 +01:00
.address = 86,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.delay = 0,
.waiting = false
},
{
2020-11-18 14:01:23 +01:00
.deviceName = "FridgePower",
2020-11-17 15:38:11 +01:00
.address = 87,
2020-11-18 13:42:55 +01:00
.consideredField = { 0, 4, 2, 3 },
2020-11-17 15:38:11 +01:00
.requests = 0,
.failures = 0,
2020-11-22 21:23:52 +01:00
.period = PERIOD,
2020-11-17 15:38:11 +01:00
.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()) {
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_YELLOW, true, "mbc mcs activate scheduler by network");
2020-11-17 15:38:11 +01:00
schAdd(triggerMBusRequest, NULL, 0, 100);
2020-11-17 15:57:31 +01:00
state = 2;
2020-11-17 15:38:11 +01:00
}
break;
case 1:
2020-11-17 15:57:31 +01:00
if (mbusCommEnabled) {
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_YELLOW, true, "mbc mcs activate scheduler by request");
2020-11-17 15:57:31 +01:00
schAdd(triggerMBusRequest, NULL, 0, 100);
state = 2;
}
break;
case 2:
2020-11-17 15:38:11 +01:00
if (! isNetworkAvailable()) {
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_YELLOW, true, "mbc mcs deactivate scheduler by network");
2020-11-17 15:38:11 +01:00
schDel(triggerMBusRequest, NULL);
2020-11-17 15:42:41 +01:00
loopDisable();
2020-11-17 15:38:11 +01:00
state = 0;
}
if (! mbusCommEnabled) {
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_YELLOW, true, "mbc mcs deactivate scheduler by request");
2020-11-17 15:38:11 +01:00
schDel(triggerMBusRequest, NULL);
2020-11-17 15:42:41 +01:00
loopDisable();
2020-11-17 15:57:31 +01:00
state = 1;
2020-11-17 15:38:11 +01:00
}
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;
2020-11-18 13:30:20 +01:00
coloredMsg(LOG_YELLOW, false, "mbc mcs scheduled: %s", devices[i].deviceName);
2020-11-17 15:38:11 +01:00
}
}
break;
}
}
void mbusCommInit() {
coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication");
schAdd(mbusCommScheduler, NULL, 0, 1000);
}