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-11-23 19:30:57 +01:00
|
|
|
#include <ringbuffer.h>
|
|
|
|
|
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;
|
|
|
|
|
2020-11-26 09:42:51 +01:00
|
|
|
// Delay between end of last bit of sent request telegram
|
|
|
|
// and enabling the frontend for receiving the response.
|
|
|
|
// Standard says client must wait at least 11 bit times.
|
|
|
|
// 1 / 2400 * 11 = 4.5e-3ms
|
|
|
|
static const uint32_t DELAY_AFTER_SENDING = 4; // ms
|
|
|
|
|
2020-11-03 14:00:54 +01:00
|
|
|
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-25 11:24:25 +01:00
|
|
|
MBCS_SENDING,
|
2020-11-02 19:23:11 +01:00
|
|
|
MBCS_SENDING_DONE,
|
2020-11-26 09:42:51 +01:00
|
|
|
MBCS_WAIT_AFTER_SENDING,
|
2020-11-02 19:23:11 +01:00
|
|
|
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-11-24 19:36:47 +01:00
|
|
|
typedef struct {
|
|
|
|
uint16_t size;
|
|
|
|
uint16_t readIdx;
|
|
|
|
uint16_t writeIdx;
|
|
|
|
uint8_t *buffer;
|
|
|
|
} linearBuffer_t;
|
|
|
|
|
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;
|
2020-11-24 19:36:47 +01:00
|
|
|
linearBuffer_t sendBuffer;
|
|
|
|
linearBuffer_t receiveBuffer;
|
2020-11-24 22:43:02 +01:00
|
|
|
uint32_t startTime;
|
2020-11-02 17:06:12 +01:00
|
|
|
uint8_t receiveCnt;
|
2020-11-24 13:18:18 +01:00
|
|
|
bool waitForOctet;
|
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-25 10:08:20 +01:00
|
|
|
static t_mbusCommHandle mbusCommHandle = { .requestId = 0, .state = MBCS_IDLE, .retryCnt = 0, .cmd = 0, .addr = 0, .startTime = 0, .receiveCnt = 0, .waitForOctet = false };
|
2020-10-28 19:40:08 +01:00
|
|
|
|
2020-11-25 13:33:46 +01:00
|
|
|
static t_mbusCommStats mbusCommStats = { .mbusRequestCnt = 0, .mbusErrorCnt = 0, .uartOctetCnt = 0, .uartOverrunCnt = 0, .uartFramingErrCnt = 0, .uartParityErrCnt = 0, .uartNoiseErrCnt = 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
|
|
|
|
2020-11-24 13:18:18 +01:00
|
|
|
static void printError() {
|
|
|
|
float errorRatio = ((float) mbusCommHandle.device->failures) / ((float) mbusCommHandle.device->requests);
|
2020-11-18 13:23:17 +01:00
|
|
|
coloredMsg(LOG_YELLOW, true, "mbc pe [%d] Error ratio is %.2f",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId,
|
2020-11-18 13:23:17 +01:00
|
|
|
errorRatio);
|
2020-11-18 18:38:03 +01:00
|
|
|
mqttPublishf(MBUS_TOPIC, "{\"Status\":\"Error\", \"RequestId\":\"%d\", \"Device\":\"%s\", \"Errors\":\"%d\", \"Requests\":\"%d\", \"ErrorRatio\":\"%.2f\"}",
|
2020-11-24 13:18:18 +01:00
|
|
|
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);
|
2020-11-18 13:23:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-11-24 13:18:18 +01:00
|
|
|
static void parseAndPrintFrame() {
|
|
|
|
t_longframe *frame = &(mbusCommHandle.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-25 11:57:54 +01:00
|
|
|
if (data_var->header.status) {
|
2020-11-25 12:04:27 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: %02x", mbusCommHandle.requestId, data_var->header.status);
|
2020-11-25 11:57:54 +01:00
|
|
|
}
|
2020-11-03 14:55:06 +01:00
|
|
|
if ((data_var->header.status & 0x01)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Application Busy", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x02)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Any Application Error", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x04)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Power Low", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x08)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Permanent Error", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x10)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Temporary Error", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x20)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 1", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x40)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 2", mbusCommHandle.requestId);
|
2020-11-03 14:55:06 +01:00
|
|
|
}
|
|
|
|
if ((data_var->header.status & 0x80)) {
|
2020-11-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] sts: Specific to manufacturer Error 3", mbusCommHandle.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-24 13:18:18 +01:00
|
|
|
if (mbusCommHandle.device->consideredField[j] == i) {
|
2020-11-17 18:11:51 +01:00
|
|
|
parsedVIB_t parsedVIB = parseVIB(record->drh.vib);
|
2020-11-25 11:56:09 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc papf [%d] parsed VIB N: %s, U: %s, E: %d",
|
|
|
|
// mbusCommHandle.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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, parsedVIB.name, weightedValue, parsedVIB.unit,
|
2020-11-17 19:12:15 +01:00
|
|
|
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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId,
|
|
|
|
mbusCommHandle.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-24 13:18:18 +01:00
|
|
|
float errorRatio = ((float) mbusCommHandle.device->failures) / ((float) mbusCommHandle.device->requests);
|
2020-11-17 20:04:29 +01:00
|
|
|
coloredMsg(LOG_YELLOW, true, "mbc papf [%d] Error ratio is %.2f",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId,
|
2020-11-17 20:04:29 +01:00
|
|
|
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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
|
|
|
|
mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
|
2020-11-18 18:38:03 +01:00
|
|
|
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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
|
|
|
|
mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
|
2020-11-18 18:38:03 +01:00
|
|
|
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\"}}",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
|
|
|
|
mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
|
2020-11-18 18:38:03 +01:00
|
|
|
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\"}}",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, mbusCommHandle.device->deviceName,
|
|
|
|
mbusCommHandle.device->failures, mbusCommHandle.device->requests, errorRatio,
|
2020-11-18 18:38:03 +01:00
|
|
|
keys[0], values[0], keys[1], values[1], keys[2], values[2], keys[3], values[3]);
|
|
|
|
}
|
2020-11-24 13:18:18 +01:00
|
|
|
oledPrintf(OLED_SCREEN0, "Ok:%d/%d %.2f", mbusCommHandle.device->failures, mbusCommHandle.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-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc papf [%d] err: unable to parse frame", mbusCommHandle.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:41:07 +01:00
|
|
|
|
2020-11-24 13:18:18 +01:00
|
|
|
void mbusCommISR() {
|
2020-11-24 14:19:12 +01:00
|
|
|
uint32_t isrflags = READ_REG(mbusUart.Instance->SR);
|
2020-11-25 11:43:27 +01:00
|
|
|
uint32_t cr1its = READ_REG(mbusUart.Instance->CR1);
|
2020-11-24 14:31:37 +01:00
|
|
|
|
2020-11-25 11:51:55 +01:00
|
|
|
// RXNEIE doesn't need to be considered since it is always on and more over the
|
|
|
|
// RXNE flag is cleared by reading the DR, which is done in any case
|
2020-11-25 13:33:46 +01:00
|
|
|
if (((isrflags & USART_SR_RXNE) != RESET) || ((isrflags & (USART_SR_ORE | USART_SR_FE | USART_SR_PE | USART_SR_NE)) != RESET)) {
|
2020-11-25 13:20:37 +01:00
|
|
|
// Error flags are only valid together with the RX flag.
|
|
|
|
// They will be cleared by reading SR (already done above) followed by reading DR (below).
|
|
|
|
bool errorFound = false;
|
2020-11-25 10:02:38 +01:00
|
|
|
if ((isrflags & USART_SR_ORE) != RESET) {
|
2020-11-25 13:20:37 +01:00
|
|
|
show(DEBUG_2, TOGGLE);
|
2020-11-25 10:02:38 +01:00
|
|
|
mbusCommStats.uartOverrunCnt += 1;
|
2020-11-25 13:20:37 +01:00
|
|
|
errorFound = true;
|
2020-11-25 10:02:38 +01:00
|
|
|
}
|
2020-11-25 12:36:36 +01:00
|
|
|
if ((isrflags & USART_SR_FE) != RESET) {
|
|
|
|
mbusCommStats.uartFramingErrCnt += 1;
|
2020-11-25 13:20:37 +01:00
|
|
|
errorFound = true;
|
2020-11-25 12:36:36 +01:00
|
|
|
}
|
|
|
|
if ((isrflags & USART_SR_PE) != RESET) {
|
|
|
|
mbusCommStats.uartParityErrCnt += 1;
|
2020-11-25 13:20:37 +01:00
|
|
|
errorFound = true;
|
2020-11-25 12:36:36 +01:00
|
|
|
}
|
2020-11-25 13:33:46 +01:00
|
|
|
if ((isrflags & USART_SR_NE) != RESET) {
|
|
|
|
mbusCommStats.uartNoiseErrCnt += 1;
|
2020-11-25 15:15:27 +01:00
|
|
|
// do not consider noise as an error for the moment
|
2020-11-25 13:35:54 +01:00
|
|
|
// errorFound = true;
|
2020-11-25 13:33:46 +01:00
|
|
|
}
|
2020-11-25 12:42:33 +01:00
|
|
|
mbusCommStats.uartOctetCnt += 1;
|
2020-11-25 10:02:38 +01:00
|
|
|
// it is required to read the DR in any case here, not only when the buffer has space
|
2020-11-25 13:38:44 +01:00
|
|
|
// otherwise the interrupt flag won't be reset, particularly important in case of ORE
|
2020-11-24 14:19:12 +01:00
|
|
|
uint8_t data = (uint8_t)(mbusUart.Instance->DR & (uint8_t)0x00FF);
|
2020-11-25 13:20:37 +01:00
|
|
|
if ((! errorFound) &&
|
|
|
|
(mbusCommHandle.receiveBuffer.writeIdx < mbusCommHandle.receiveBuffer.size)) {
|
2020-11-24 19:36:47 +01:00
|
|
|
mbusCommHandle.receiveBuffer.buffer[mbusCommHandle.receiveBuffer.writeIdx] = data;
|
|
|
|
mbusCommHandle.receiveBuffer.writeIdx += 1;
|
|
|
|
}
|
2020-11-25 11:06:10 +01:00
|
|
|
}
|
|
|
|
|
2020-11-25 11:51:55 +01:00
|
|
|
// TXEIE needs to be considered since TXE is cleared by writing the DR, which isn't done
|
|
|
|
// after the last octet sent
|
2020-11-25 11:43:27 +01:00
|
|
|
if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET)) {
|
2020-11-25 11:04:36 +01:00
|
|
|
if (mbusCommHandle.sendBuffer.readIdx < mbusCommHandle.sendBuffer.writeIdx) {
|
|
|
|
mbusUart.Instance->DR = mbusCommHandle.sendBuffer.buffer[mbusCommHandle.sendBuffer.readIdx];
|
|
|
|
mbusCommHandle.sendBuffer.readIdx += 1;
|
|
|
|
if (mbusCommHandle.sendBuffer.readIdx == mbusCommHandle.sendBuffer.writeIdx) {
|
|
|
|
__HAL_UART_DISABLE_IT(&mbusUart, UART_IT_TXE);
|
2020-11-26 09:42:51 +01:00
|
|
|
__HAL_UART_ENABLE_IT(&mbusUart, UART_IT_TC);
|
2020-11-25 11:04:36 +01:00
|
|
|
}
|
|
|
|
}
|
2020-11-25 11:06:10 +01:00
|
|
|
}
|
2020-11-26 09:42:51 +01:00
|
|
|
|
|
|
|
// advance the state for the engine only when the last octet is shifted out completely
|
|
|
|
if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET)) {
|
|
|
|
__HAL_UART_DISABLE_IT(&mbusUart, UART_IT_TC);
|
|
|
|
mbusCommHandle.state = MBCS_SENDING_DONE;
|
|
|
|
}
|
2020-11-02 17:14:11 +01:00
|
|
|
}
|
|
|
|
|
2020-11-24 14:21:05 +01:00
|
|
|
|
2020-11-23 19:30:57 +01:00
|
|
|
void mbusCommExec() {
|
2020-11-02 19:23:11 +01:00
|
|
|
static uint8_t userdataIdx = 0;
|
|
|
|
static uint8_t calculatedChksum = 0;
|
2020-11-24 13:18:18 +01:00
|
|
|
uint8_t receivedOctet = 0;
|
2020-11-26 09:42:51 +01:00
|
|
|
static uint32_t delayAfterSendStartTime = 0;
|
2020-11-24 22:43:02 +01:00
|
|
|
|
2020-11-24 22:57:33 +01:00
|
|
|
if ((mbusCommHandle.startTime != 0) && ((mbusCommHandle.startTime + 2500) < HAL_GetTick())) {
|
|
|
|
mbusCommHandle.state = MBCS_TIMEOUT;
|
2020-11-24 22:43:02 +01:00
|
|
|
} else if (mbusCommHandle.waitForOctet) {
|
2020-11-24 19:36:47 +01:00
|
|
|
if (mbusCommHandle.receiveBuffer.readIdx >= mbusCommHandle.receiveBuffer.writeIdx) {
|
2020-11-25 12:00:01 +01:00
|
|
|
return; // no data available, wait
|
2020-11-24 14:47:21 +01:00
|
|
|
}
|
2020-11-24 19:36:47 +01:00
|
|
|
receivedOctet = mbusCommHandle.receiveBuffer.buffer[mbusCommHandle.receiveBuffer.readIdx];
|
|
|
|
mbusCommHandle.receiveBuffer.readIdx += 1;
|
2020-11-24 15:03:09 +01:00
|
|
|
mbusCommHandle.waitForOctet = false;
|
2020-11-24 13:18:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (mbusCommHandle.state) {
|
2020-11-02 19:23:11 +01:00
|
|
|
case MBCS_IDLE:
|
2020-11-24 13:18:18 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state IDLE", mbusCommHandle.requestId);
|
2020-10-28 19:40:08 +01:00
|
|
|
break;
|
|
|
|
|
2020-11-02 19:23:11 +01:00
|
|
|
case MBCS_SEND:
|
2020-11-25 11:56:09 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND", mbusCommHandle.requestId);
|
2020-11-24 19:36:47 +01:00
|
|
|
mbusCommHandle.sendBuffer.buffer[0] = 0x10;
|
|
|
|
mbusCommHandle.sendBuffer.buffer[1] = mbusCommHandle.cmd;
|
|
|
|
mbusCommHandle.sendBuffer.buffer[2] = mbusCommHandle.addr;
|
|
|
|
mbusCommHandle.sendBuffer.buffer[3] = mbusCommHandle.cmd + mbusCommHandle.addr; // checksum
|
|
|
|
mbusCommHandle.sendBuffer.buffer[4] = 0x16;
|
|
|
|
mbusCommHandle.sendBuffer.readIdx = 0;
|
|
|
|
mbusCommHandle.sendBuffer.writeIdx = 5;
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.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-25 11:56:09 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SEND_CONTINUED", mbusCommHandle.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-24 13:18:18 +01:00
|
|
|
coloredMsg(LOG_YELLOW, true, "mbc hre [%d] enabling loop, try %d", mbusCommHandle.requestId, mbusCommHandle.retryCnt);
|
|
|
|
mbusCommHandle.retryCnt++;
|
2020-10-28 19:40:08 +01:00
|
|
|
loopEnable();
|
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.retryCnt = 0;
|
2020-11-25 11:04:36 +01:00
|
|
|
// enable transmitter interrupt
|
2020-11-25 11:56:09 +01:00
|
|
|
//coloredMsg(LOG_YELLOW, false, "mbc hre [%d] enable transmitter interrupt", mbusCommHandle.requestId);
|
2020-11-25 11:04:36 +01:00
|
|
|
__HAL_UART_ENABLE_IT(&mbusUart, UART_IT_TXE);
|
2020-11-25 11:24:25 +01:00
|
|
|
mbusCommHandle.state = MBCS_SENDING;
|
2020-10-29 15:57:59 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2020-11-25 11:24:25 +01:00
|
|
|
case MBCS_SENDING:
|
2020-11-25 11:56:09 +01:00
|
|
|
// transition from here to MBCS_SENDING_DONE is done by TX ISR
|
2020-11-25 11:24:25 +01:00
|
|
|
break;
|
|
|
|
|
2020-11-02 19:23:11 +01:00
|
|
|
case MBCS_SENDING_DONE:
|
2020-11-25 11:56:09 +01:00
|
|
|
//coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state SENDING_DONE", mbusCommHandle.requestId);
|
2020-11-26 09:42:51 +01:00
|
|
|
delayAfterSendStartTime = HAL_GetTick();
|
|
|
|
mbusCommHandle.state = MBCS_WAIT_AFTER_SENDING;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_WAIT_AFTER_SENDING:
|
|
|
|
// Avoids switching on the frontend while there is still noise from sending on the loop
|
|
|
|
// Make sure to wait not too long otherwise the beginning of the response is missed
|
|
|
|
if ((delayAfterSendStartTime + DELAY_AFTER_SENDING) < HAL_GetTick()) {
|
|
|
|
mbusCommHandle.state = MBCS_ENABLE_FRONTEND;
|
|
|
|
}
|
2020-10-28 19:40:08 +01:00
|
|
|
break;
|
|
|
|
|
2020-11-02 19:23:11 +01:00
|
|
|
case MBCS_ENABLE_FRONTEND:
|
2020-11-25 11:56:09 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state ENABLE_FRONTEND", mbusCommHandle.requestId);
|
2020-11-01 18:48:39 +01:00
|
|
|
frontendEnable();
|
2020-11-02 19:23:11 +01:00
|
|
|
calculatedChksum = 0;
|
|
|
|
userdataIdx = 0;
|
2020-11-24 19:36:47 +01:00
|
|
|
mbusCommHandle.receiveBuffer.readIdx = 0;
|
|
|
|
mbusCommHandle.receiveBuffer.writeIdx = 0;
|
2020-11-25 09:16:00 +01:00
|
|
|
mbusCommHandle.waitForOctet = true; // start receiver
|
|
|
|
mbusCommHandle.startTime = HAL_GetTick(); // start receiver timeout
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.state = MBCS_START1;
|
2020-11-02 17:14:11 +01:00
|
|
|
break;
|
2020-11-02 15:41:07 +01:00
|
|
|
|
2020-11-02 19:23:11 +01:00
|
|
|
case MBCS_START1:
|
2020-11-24 13:18:18 +01:00
|
|
|
if (receivedOctet == 0x68) {
|
|
|
|
mbusCommHandle.frame.start1 = receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_LENGTH1;
|
2020-11-02 19:23:11 +01:00
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
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;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_LENGTH1:
|
2020-11-24 13:18:18 +01:00
|
|
|
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;
|
2020-11-02 19:23:11 +01:00
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
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;
|
2020-11-02 19:23:11 +01:00
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_LENGTH2;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_LENGTH2:
|
2020-11-24 13:18:18 +01:00
|
|
|
if (mbusCommHandle.frame.length1 != receivedOctet) {
|
2020-11-17 12:40:24 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc hre [%d] err: invalid length2 %02x vs. %02x",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, mbusCommHandle.frame.length1, receivedOctet);
|
|
|
|
mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__LENGTH2;
|
|
|
|
mbusCommHandle.state = MBCS_ERROR;
|
2020-11-02 19:23:11 +01:00
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.length2 = receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_START2;
|
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:
|
2020-11-24 13:18:18 +01:00
|
|
|
if (receivedOctet == 0x68) {
|
|
|
|
mbusCommHandle.frame.start2 = receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_C_FIELD;
|
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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, receivedOctet);
|
|
|
|
mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__START2;
|
|
|
|
mbusCommHandle.state = MBCS_ERROR;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_C_FIELD:
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.c = receivedOctet;
|
|
|
|
calculatedChksum += receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_A_FIELD;
|
2020-11-02 19:23:11 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_A_FIELD:
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.a = receivedOctet;
|
|
|
|
calculatedChksum += receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_CI_FIELD;
|
2020-11-02 19:23:11 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_CI_FIELD:
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.ci = receivedOctet;
|
|
|
|
calculatedChksum += receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_USERDATA;
|
2020-11-02 19:23:11 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_USERDATA:
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.userdata[userdataIdx] = receivedOctet;
|
|
|
|
calculatedChksum += receivedOctet;
|
2020-11-02 19:23:11 +01:00
|
|
|
userdataIdx++;
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
if (userdataIdx == (mbusCommHandle.frame.length1 - 3)) {
|
|
|
|
mbusCommHandle.state = MBCS_CHKSUM;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_CHKSUM:
|
2020-11-24 13:18:18 +01:00
|
|
|
if (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-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, calculatedChksum, receivedOctet);
|
|
|
|
mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__INVALID_CHKSUM;
|
|
|
|
mbusCommHandle.state = MBCS_ERROR;
|
2020-11-02 19:23:11 +01:00
|
|
|
} else {
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.frame.chksum = receivedOctet;
|
|
|
|
mbusCommHandle.waitForOctet = true;
|
|
|
|
mbusCommHandle.state = MBCS_STOP;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_STOP:
|
2020-11-24 13:18:18 +01:00
|
|
|
if (receivedOctet == 0x16) {
|
|
|
|
mbusCommHandle.frame.stop = receivedOctet;
|
|
|
|
mbusCommHandle.state = MBCS_DONE;
|
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 stop symbol %02x",
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.requestId, receivedOctet);
|
|
|
|
mbusCommHandle.result = MBCR_ERROR_STATE_ENGINE__STOP;
|
|
|
|
mbusCommHandle.state = MBCS_ERROR;
|
2020-11-02 19:23:11 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_DONE:
|
2020-11-24 13:18:18 +01:00
|
|
|
// 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;
|
2020-11-02 20:59:52 +01:00
|
|
|
}
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.result = MBCR_SUCCESS;
|
|
|
|
mbusCommHandle.state = MBCS_DISABLE_FRONTEND;
|
2020-11-02 19:23:11 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MBCS_ERROR:
|
2020-11-25 12:04:27 +01:00
|
|
|
// coloredMsg(LOG_RED, false, "mbc hre [%d] state ERROR", mbusCommHandle.requestId);
|
2020-11-25 12:08:13 +01:00
|
|
|
coloredMsg(LOG_RED, true, "mbc hre [%d] error", mbusCommHandle.requestId);
|
2020-11-03 10:05:45 +01:00
|
|
|
show(LED_RED, ON);
|
2020-11-26 09:42:51 +01:00
|
|
|
// disable frontend immediately in case of error since no more data in relevant
|
|
|
|
// this avoids strange noise on RX line/led
|
|
|
|
frontendDisable();
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.state = MBCS_ERROR_CONTINUED;
|
2020-11-18 13:23:17 +01:00
|
|
|
// no break
|
|
|
|
|
2020-11-18 13:23:36 +01:00
|
|
|
case MBCS_ERROR_CONTINUED:
|
2020-11-25 12:08:13 +01:00
|
|
|
// every error will be collected by a timeout to receive all data still on the wire
|
|
|
|
// to avoid leaking old data in responses for new requests
|
2020-11-02 19:23:11 +01:00
|
|
|
break;
|
|
|
|
|
2020-11-02 19:43:37 +01:00
|
|
|
case MBCS_TIMEOUT:
|
2020-11-25 12:04:27 +01:00
|
|
|
// coloredMsg(LOG_RED, false, "mbc hre [%d] state TIMEOUT", mbusCommHandle.requestId);
|
|
|
|
coloredMsg(LOG_RED, true, "mbc hre [%d] timeout", mbusCommHandle.requestId);
|
2020-11-25 10:02:38 +01:00
|
|
|
mbusCommStats.mbusErrorCnt += 1;
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.device->failures += 1;
|
2020-11-25 09:16:00 +01:00
|
|
|
mbusCommHandle.startTime = 0; // disable timeout
|
|
|
|
mbusCommHandle.waitForOctet = false; // disable receiver
|
2020-11-24 13:18:18 +01:00
|
|
|
printError();
|
|
|
|
if (mbusCommHandle.frame.userdata != NULL) {
|
|
|
|
free(mbusCommHandle.frame.userdata);
|
|
|
|
mbusCommHandle.frame.userdata = NULL;
|
2020-11-02 20:59:52 +01:00
|
|
|
}
|
2020-11-02 19:43:37 +01:00
|
|
|
// no break
|
|
|
|
|
|
|
|
case MBCS_DISABLE_FRONTEND:
|
2020-11-24 13:18:18 +01:00
|
|
|
// coloredMsg(LOG_YELLOW, false, "mbc hre [%d] state DISABLE_FRONTEND", mbusCommHandle.requestId);
|
2020-11-01 18:48:39 +01:00
|
|
|
frontendDisable();
|
2020-11-25 09:16:00 +01:00
|
|
|
mbusCommHandle.startTime = 0; // disable timeout
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.state = MBCS_IDLE;
|
2020-11-01 18:48:39 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
2020-10-28 19:40:08 +01:00
|
|
|
default:
|
2020-11-24 13:18:18 +01:00
|
|
|
mbusCommHandle.state = MBCS_IDLE;
|
2020-10-28 19:40:08 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-25 10:02:38 +01:00
|
|
|
coloredMsg(LOG_YELLOW, true, "mbc mcr [%d] new request %s",
|
2020-11-17 12:28:03 +01:00
|
|
|
mbusCommHandle.requestId,
|
2020-11-25 10:02:38 +01:00
|
|
|
mbusDevice->deviceName);
|
2020-11-17 12:28:03 +01:00
|
|
|
|
2020-11-20 12:20:30 +01:00
|
|
|
oledPrint(OLED_SCREEN0, mbusDevice->deviceName);
|
2020-11-16 17:53:18 +01:00
|
|
|
res = MBCRR_TRIGGERED;
|
|
|
|
|
2020-11-25 10:02:38 +01:00
|
|
|
mbusCommStats.mbusRequestCnt += 1;
|
2020-11-16 17:53:18 +01:00
|
|
|
}
|
|
|
|
} 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-23 18:50:03 +01:00
|
|
|
#define PERIOD 10
|
2020-11-22 21:23:52 +01:00
|
|
|
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
},
|
|
|
|
{
|
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,
|
2020-11-25 12:55:10 +01:00
|
|
|
.waiting = false,
|
2020-11-25 13:15:02 +01:00
|
|
|
.active = true
|
2020-11-17 15:38:11 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
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++) {
|
2020-11-25 12:56:24 +01:00
|
|
|
if (devices[i].active) {
|
|
|
|
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);
|
|
|
|
}
|
2020-11-17 15:38:11 +01:00
|
|
|
}
|
|
|
|
}
|
2020-11-24 13:46:51 +01:00
|
|
|
|
|
|
|
// FIXME
|
2020-11-24 19:38:52 +01:00
|
|
|
// state = 3;
|
2020-11-24 13:46:51 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
coloredMsg(LOG_YELLOW, false, "mbc mcs waiting for godot");
|
|
|
|
state = 4;
|
|
|
|
// no break
|
|
|
|
|
|
|
|
case 4:
|
2020-11-17 15:38:11 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void mbusCommInit() {
|
|
|
|
coloredMsg(LOG_GREEN, true, "mbc mci initializing Meterbus communication");
|
2020-11-23 19:30:57 +01:00
|
|
|
|
2020-11-24 13:50:06 +01:00
|
|
|
// enable receive interrupts
|
2020-11-25 13:25:33 +01:00
|
|
|
// __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_PE);
|
|
|
|
// __HAL_UART_ENABLE_IT(&mbusUart, UART_IT_ERR);
|
2020-11-24 13:50:06 +01:00
|
|
|
__HAL_UART_ENABLE_IT(&mbusUart, UART_IT_RXNE);
|
|
|
|
|
2020-11-25 11:04:36 +01:00
|
|
|
// init buffers
|
2020-11-24 19:36:47 +01:00
|
|
|
mbusCommHandle.receiveBuffer.size = 256;
|
|
|
|
mbusCommHandle.receiveBuffer.buffer = (uint8_t*) malloc(mbusCommHandle.receiveBuffer.size);
|
|
|
|
mbusCommHandle.receiveBuffer.readIdx = 0;
|
|
|
|
mbusCommHandle.receiveBuffer.writeIdx = 0;
|
|
|
|
|
|
|
|
mbusCommHandle.sendBuffer.size = 8;
|
|
|
|
mbusCommHandle.sendBuffer.buffer = (uint8_t*) malloc(mbusCommHandle.sendBuffer.size);
|
|
|
|
mbusCommHandle.sendBuffer.readIdx = 0;
|
|
|
|
mbusCommHandle.sendBuffer.writeIdx = 0;
|
|
|
|
|
2020-11-24 14:47:21 +01:00
|
|
|
|
2020-11-24 13:42:26 +01:00
|
|
|
// FIXME
|
2020-11-24 13:46:51 +01:00
|
|
|
schAdd(mbusCommScheduler, NULL, 0, 1000);
|
2020-11-17 15:38:11 +01:00
|
|
|
}
|