From 938f490a322df924eb7d04b7dc0fa91d66eb742c Mon Sep 17 00:00:00 2001 From: acidburns Date: Wed, 4 Feb 2026 15:22:24 +0100 Subject: [PATCH] Add multi-meter energy sender schema with UART0/1/2 mode split --- include/config.h | 7 +- include/data_model.h | 3 + include/meter_driver.h | 7 +- src/display_ui.cpp | 13 +- src/json_codec.cpp | 24 ++-- src/main.cpp | 174 +++++++++++-------------- src/meter_driver.cpp | 288 ++++++++++++++++------------------------- src/payload_codec.cpp | 54 +++++++- src/payload_codec.h | 5 + src/web_server.cpp | 24 +++- 10 files changed, 307 insertions(+), 292 deletions(-) diff --git a/include/config.h b/include/config.h index 3fff7ab..b230494 100644 --- a/include/config.h +++ b/include/config.h @@ -32,7 +32,9 @@ constexpr uint8_t PIN_BAT_ADC = 35; constexpr uint8_t PIN_ROLE = 14; constexpr uint8_t PIN_OLED_CTRL = 13; -constexpr uint8_t PIN_METER_RX = 34; +constexpr uint8_t PIN_METER1_RX = 34; // UART2 RX +constexpr uint8_t PIN_METER2_RX = 25; // UART1 RX +constexpr uint8_t PIN_METER3_RX = 3; // UART0 RX (prod only, when serial debug is off) // LoRa settings #ifndef LORA_FREQUENCY_HZ @@ -68,6 +70,9 @@ constexpr bool ENABLE_HA_DISCOVERY = true; #define SERIAL_DEBUG_MODE_FLAG 0 #endif constexpr bool SERIAL_DEBUG_MODE = SERIAL_DEBUG_MODE_FLAG != 0; +constexpr uint8_t METER_COUNT_DEBUG = 2; +constexpr uint8_t METER_COUNT_PROD = 3; +constexpr uint8_t METER_COUNT = SERIAL_DEBUG_MODE ? METER_COUNT_DEBUG : METER_COUNT_PROD; constexpr bool SERIAL_DEBUG_DUMP_JSON = false; constexpr bool LORA_SEND_BYPASS = false; constexpr bool ENABLE_SD_LOGGING = true; diff --git a/include/data_model.h b/include/data_model.h index 670b799..a2eac9e 100644 --- a/include/data_model.h +++ b/include/data_model.h @@ -28,6 +28,9 @@ struct MeterData { uint32_t ts_utc; uint16_t short_id; char device_id[16]; + bool energy_multi; + uint8_t energy_meter_count; + uint32_t energy_kwh_int[3]; float energy_total_kwh; float phase_power_w[3]; float total_power_w; diff --git a/include/meter_driver.h b/include/meter_driver.h index a38cf73..15efb7f 100644 --- a/include/meter_driver.h +++ b/include/meter_driver.h @@ -1,9 +1,8 @@ #pragma once #include -#include "data_model.h" void meter_init(); -bool meter_read(MeterData &data); -bool meter_poll_frame(const char *&frame, size_t &len); -bool meter_parse_frame(const char *frame, size_t len, MeterData &data); +void meter_poll(); +uint8_t meter_count(); +bool meter_get_last_energy_kwh(uint8_t meter_idx, uint32_t &out_energy_kwh); diff --git a/src/display_ui.cpp b/src/display_ui.cpp index 1f0196a..c46f022 100644 --- a/src/display_ui.cpp +++ b/src/display_ui.cpp @@ -350,9 +350,18 @@ static void render_receiver_sender(uint8_t index) { #endif display.setCursor(0, 12); - display.printf("E %.2f kWh", status.last_data.energy_total_kwh); + if (status.last_data.energy_multi) { + display.printf("E1 %lu E2 %lu", static_cast(status.last_data.energy_kwh_int[0]), + static_cast(status.last_data.energy_kwh_int[1])); + } else { + display.printf("E %.2f kWh", status.last_data.energy_total_kwh); + } display.setCursor(0, 22); - display.printf("L1 %dW", static_cast(round_power_w(status.last_data.phase_power_w[0]))); + if (status.last_data.energy_multi && status.last_data.energy_meter_count >= 3) { + display.printf("E3 %lu", static_cast(status.last_data.energy_kwh_int[2])); + } else { + display.printf("L1 %dW", static_cast(round_power_w(status.last_data.phase_power_w[0]))); + } display.setCursor(0, 32); display.printf("L2 %dW", static_cast(round_power_w(status.last_data.phase_power_w[1]))); display.setCursor(0, 42); diff --git a/src/json_codec.cpp b/src/json_codec.cpp index e188653..72c5105 100644 --- a/src/json_codec.cpp +++ b/src/json_codec.cpp @@ -58,16 +58,24 @@ static void set_int_or_null(JsonDocument &doc, const char *key, float value) { } bool meterDataToJson(const MeterData &data, String &out_json) { - StaticJsonDocument<256> doc; + StaticJsonDocument<320> doc; doc["id"] = short_id_from_device_id(data.device_id); doc["ts"] = data.ts_utc; char buf[16]; - format_float_2(buf, sizeof(buf), data.energy_total_kwh); - doc["e_kwh"] = serialized(buf); - set_int_or_null(doc, "p_w", data.total_power_w); - set_int_or_null(doc, "p1_w", data.phase_power_w[0]); - set_int_or_null(doc, "p2_w", data.phase_power_w[1]); - set_int_or_null(doc, "p3_w", data.phase_power_w[2]); + if (data.energy_multi) { + doc["energy1_kwh"] = data.energy_kwh_int[0]; + doc["energy2_kwh"] = data.energy_kwh_int[1]; + if (data.energy_meter_count >= 3) { + doc["energy3_kwh"] = data.energy_kwh_int[2]; + } + } else { + format_float_2(buf, sizeof(buf), data.energy_total_kwh); + doc["e_kwh"] = serialized(buf); + set_int_or_null(doc, "p_w", data.total_power_w); + set_int_or_null(doc, "p1_w", data.phase_power_w[0]); + set_int_or_null(doc, "p2_w", data.phase_power_w[1]); + set_int_or_null(doc, "p3_w", data.phase_power_w[2]); + } format_float_2(buf, sizeof(buf), data.battery_voltage_v); doc["bat_v"] = serialized(buf); doc["bat_pct"] = data.battery_percent; @@ -90,5 +98,5 @@ bool meterDataToJson(const MeterData &data, String &out_json) { out_json = ""; size_t len = serializeJson(doc, out_json); - return len > 0 && len < 256; + return len > 0 && len < 320; } diff --git a/src/main.cpp b/src/main.cpp index b65dd26..f808459 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -55,7 +55,10 @@ struct BatchBuffer { uint16_t batch_id; bool batch_id_valid; uint8_t count; - MeterData samples[METER_BATCH_MAX_SAMPLES]; + struct EnergySample { + uint32_t ts_utc; + uint32_t energy_kwh[3]; + } samples[METER_BATCH_MAX_SAMPLES]; }; static BatchBuffer g_batch_queue[BATCH_QUEUE_DEPTH]; @@ -63,7 +66,7 @@ static uint8_t g_batch_head = 0; static uint8_t g_batch_tail = 0; static uint8_t g_batch_count = 0; -static MeterData g_build_samples[METER_BATCH_MAX_SAMPLES]; +static BatchBuffer::EnergySample g_build_samples[METER_BATCH_MAX_SAMPLES]; static uint8_t g_build_count = 0; static uint32_t g_last_sample_ms = 0; @@ -79,7 +82,7 @@ static uint16_t g_last_acked_batch_id = 0; static uint8_t g_batch_retry_count = 0; static bool g_batch_ack_pending = false; static uint32_t g_batch_ack_timeout_ms = BATCH_ACK_TIMEOUT_MS; -static MeterData g_inflight_samples[METER_BATCH_MAX_SAMPLES]; +static BatchBuffer::EnergySample g_inflight_samples[METER_BATCH_MAX_SAMPLES]; static uint8_t g_inflight_count = 0; static uint16_t g_inflight_batch_id = 0; static bool g_inflight_active = false; @@ -90,10 +93,8 @@ static uint32_t g_sender_sleep_ms = 0; static uint32_t g_sender_power_log_ms = 0; static RxRejectReason g_sender_rx_reject_reason = RxRejectReason::None; static uint32_t g_sender_rx_reject_log_ms = 0; -static MeterData g_last_meter_data = {}; -static bool g_last_meter_valid = false; -static uint32_t g_last_meter_rx_ms = 0; -static uint32_t g_meter_stale_seconds = 0; +static uint32_t g_last_energy_kwh[3] = {}; +static bool g_last_energy_valid[3] = {}; static bool g_time_acquired = false; static uint32_t g_last_sync_request_ms = 0; @@ -194,7 +195,7 @@ static BatchBuffer *batch_queue_peek() { return &g_batch_queue[g_batch_tail]; } -static void batch_queue_enqueue(const MeterData *samples, uint8_t count) { +static void batch_queue_enqueue(const BatchBuffer::EnergySample *samples, uint8_t count) { if (!samples || count == 0) { return; } @@ -329,33 +330,6 @@ static uint16_t short_id_from_sender_id(uint16_t sender_id) { return EXPECTED_SENDER_IDS[sender_id - 1]; } -static uint32_t kwh_to_wh_from_float(float value) { - if (isnan(value)) { - return 0; - } - double wh = static_cast(value) * 1000.0; - if (wh < 0.0) { - wh = 0.0; - } - if (wh > static_cast(UINT32_MAX)) { - wh = static_cast(UINT32_MAX); - } - return static_cast(llround(wh)); -} - -static bool float_to_i16_w(float value, int16_t &out) { - if (isnan(value)) { - out = 0; - return true; - } - long rounded = lroundf(value); - if (rounded < INT16_MIN || rounded > INT16_MAX) { - return false; - } - out = static_cast(rounded); - return true; -} - static uint16_t battery_mv_from_voltage(float value) { if (isnan(value) || value <= 0.0f) { return 0; @@ -496,6 +470,7 @@ static bool send_inflight_batch(uint32_t ts_for_display) { return false; } BatchInput input = {}; + input.schema_id = 1; input.sender_id = sender_id_from_short_id(g_short_id); input.batch_id = g_inflight_batch_id; input.t_last = g_inflight_sync_request ? time_get_utc() : @@ -503,20 +478,17 @@ static bool send_inflight_batch(uint32_t ts_for_display) { uint32_t dt_s = METER_SAMPLE_INTERVAL_MS / 1000; input.dt_s = dt_s > 0 ? static_cast(dt_s) : 1; input.n = g_inflight_sync_request ? 0 : g_inflight_count; - input.battery_mV = g_inflight_sync_request ? battery_mv_from_voltage(g_last_battery_voltage_v) : - battery_mv_from_voltage(g_inflight_samples[g_inflight_count - 1].battery_voltage_v); + input.meter_count = METER_COUNT; + input.battery_mV = battery_mv_from_voltage(g_last_battery_voltage_v); input.err_m = g_sender_faults.meter_read_fail > 255 ? 255 : static_cast(g_sender_faults.meter_read_fail); input.err_d = g_sender_faults.decode_fail > 255 ? 255 : static_cast(g_sender_faults.decode_fail); input.err_tx = g_sender_faults.lora_tx_fail > 255 ? 255 : static_cast(g_sender_faults.lora_tx_fail); input.err_last = static_cast(g_sender_last_error); input.err_rx_reject = static_cast(g_sender_rx_reject_reason); for (uint8_t i = 0; i < input.n; ++i) { - input.energy_wh[i] = kwh_to_wh_from_float(g_inflight_samples[i].energy_total_kwh); - if (!float_to_i16_w(g_inflight_samples[i].phase_power_w[0], input.p1_w[i]) || - !float_to_i16_w(g_inflight_samples[i].phase_power_w[1], input.p2_w[i]) || - !float_to_i16_w(g_inflight_samples[i].phase_power_w[2], input.p3_w[i])) { - return false; - } + input.energy1_kwh[i] = g_inflight_samples[i].energy_kwh[0]; + input.energy2_kwh[i] = g_inflight_samples[i].energy_kwh[1]; + input.energy3_kwh[i] = g_inflight_samples[i].energy_kwh[2]; } static uint8_t encoded[BATCH_MAX_COMPRESSED]; @@ -691,8 +663,10 @@ static bool process_batch_packet(const LoraPacket &pkt, BatchInput &out_batch, b } void setup() { - Serial.begin(115200); - delay(200); + if (SERIAL_DEBUG_MODE) { + Serial.begin(115200); + delay(200); + } #ifdef PAYLOAD_CODEC_TEST payload_codec_self_test(); #endif @@ -776,63 +750,60 @@ static void sender_loop() { } if (g_time_acquired) { - const char *frame = nullptr; - size_t frame_len = 0; - if (meter_poll_frame(frame, frame_len)) { - MeterData parsed = {}; - parsed.energy_total_kwh = NAN; - parsed.total_power_w = NAN; - parsed.phase_power_w[0] = NAN; - parsed.phase_power_w[1] = NAN; - parsed.phase_power_w[2] = NAN; - parsed.valid = false; - if (meter_parse_frame(frame, frame_len, parsed)) { - g_last_meter_data = parsed; - g_last_meter_valid = true; - g_last_meter_rx_ms = now_ms; - g_meter_stale_seconds = 0; + meter_poll(); + for (uint8_t i = 0; i < meter_count() && i < 3; ++i) { + uint32_t e_kwh = 0; + if (meter_get_last_energy_kwh(i, e_kwh)) { + g_last_energy_kwh[i] = e_kwh; + g_last_energy_valid[i] = true; } } if (now_ms - g_last_sample_ms >= METER_SAMPLE_INTERVAL_MS) { g_last_sample_ms = now_ms; - MeterData data = {}; - data.short_id = g_short_id; - strncpy(data.device_id, g_device_id, sizeof(data.device_id)); - - bool meter_ok = g_last_meter_valid; - if (meter_ok) { - data.energy_total_kwh = g_last_meter_data.energy_total_kwh; - data.total_power_w = g_last_meter_data.total_power_w; - data.phase_power_w[0] = g_last_meter_data.phase_power_w[0]; - data.phase_power_w[1] = g_last_meter_data.phase_power_w[1]; - data.phase_power_w[2] = g_last_meter_data.phase_power_w[2]; - uint32_t age_ms = now_ms - g_last_meter_rx_ms; - g_meter_stale_seconds = age_ms >= 1000 ? (age_ms / 1000) : 0; - } else { - g_meter_stale_seconds++; + bool any_meter_valid = false; + for (uint8_t i = 0; i < meter_count() && i < 3; ++i) { + if (g_last_energy_valid[i]) { + any_meter_valid = true; + break; + } } - if (!meter_ok) { + if (!any_meter_valid) { note_fault(g_sender_faults, g_sender_last_error, g_sender_last_error_utc, g_sender_last_error_ms, FaultType::MeterRead); display_set_last_error(g_sender_last_error, g_sender_last_error_utc, g_sender_last_error_ms); + } else { + BatchBuffer::EnergySample sample = {}; + sample.ts_utc = time_get_utc(); + sample.energy_kwh[0] = g_last_energy_valid[0] ? g_last_energy_kwh[0] : 0; + sample.energy_kwh[1] = g_last_energy_valid[1] ? g_last_energy_kwh[1] : 0; + sample.energy_kwh[2] = (meter_count() >= 3 && g_last_energy_valid[2]) ? g_last_energy_kwh[2] : 0; + g_last_sample_ts_utc = sample.ts_utc; + g_build_samples[g_build_count++] = sample; + if (g_build_count >= METER_BATCH_MAX_SAMPLES) { + batch_queue_enqueue(g_build_samples, g_build_count); + g_build_count = 0; + } + + MeterData view = {}; + view.short_id = g_short_id; + strncpy(view.device_id, g_device_id, sizeof(view.device_id)); + view.ts_utc = sample.ts_utc; + view.energy_multi = true; + view.energy_meter_count = meter_count(); + view.energy_kwh_int[0] = sample.energy_kwh[0]; + view.energy_kwh_int[1] = sample.energy_kwh[1]; + view.energy_kwh_int[2] = sample.energy_kwh[2]; + view.energy_total_kwh = static_cast(sample.energy_kwh[0]); + view.valid = true; + view.battery_voltage_v = g_last_battery_voltage_v; + view.battery_percent = g_last_battery_percent; + display_set_last_meter(view); + display_set_last_read(true, view.ts_utc); } + if (g_build_count == 0 && battery_sample_due(now_ms)) { update_battery_cache(); } - data.battery_voltage_v = g_last_battery_voltage_v; - data.battery_percent = g_last_battery_percent; - data.rx_reject_reason = static_cast(g_sender_rx_reject_reason); - data.ts_utc = time_get_utc(); - data.valid = meter_ok; - - g_last_sample_ts_utc = data.ts_utc; - g_build_samples[g_build_count++] = data; - if (g_build_count >= METER_BATCH_MAX_SAMPLES) { - batch_queue_enqueue(g_build_samples, g_build_count); - g_build_count = 0; - } - display_set_last_meter(data); - display_set_last_read(meter_ok, data.ts_utc); } if (!g_batch_ack_pending && now_ms - g_last_send_ms >= METER_SEND_INTERVAL_MS) { @@ -1052,11 +1023,24 @@ static void receiver_loop() { snprintf(data.device_id, sizeof(data.device_id), "dd3-0000"); } data.ts_utc = t_first + static_cast(s) * batch.dt_s; - data.energy_total_kwh = static_cast(batch.energy_wh[s]) / 1000.0f; - data.phase_power_w[0] = static_cast(batch.p1_w[s]); - data.phase_power_w[1] = static_cast(batch.p2_w[s]); - data.phase_power_w[2] = static_cast(batch.p3_w[s]); - data.total_power_w = data.phase_power_w[0] + data.phase_power_w[1] + data.phase_power_w[2]; + if (batch.schema_id == 1) { + data.energy_multi = true; + data.energy_meter_count = batch.meter_count; + data.energy_kwh_int[0] = batch.energy1_kwh[s]; + data.energy_kwh_int[1] = batch.energy2_kwh[s]; + data.energy_kwh_int[2] = batch.energy3_kwh[s]; + data.energy_total_kwh = static_cast(batch.energy1_kwh[s]); + data.phase_power_w[0] = 0.0f; + data.phase_power_w[1] = 0.0f; + data.phase_power_w[2] = 0.0f; + data.total_power_w = 0.0f; + } else { + data.energy_total_kwh = static_cast(batch.energy_wh[s]) / 1000.0f; + data.phase_power_w[0] = static_cast(batch.p1_w[s]); + data.phase_power_w[1] = static_cast(batch.p2_w[s]); + data.phase_power_w[2] = static_cast(batch.p3_w[s]); + data.total_power_w = data.phase_power_w[0] + data.phase_power_w[1] + data.phase_power_w[2]; + } data.battery_voltage_v = bat_v; data.battery_percent = !isnan(bat_v) ? battery_percent_from_voltage(bat_v) : 0; data.valid = true; diff --git a/src/meter_driver.cpp b/src/meter_driver.cpp index 665c4a1..5db227c 100644 --- a/src/meter_driver.cpp +++ b/src/meter_driver.cpp @@ -12,20 +12,23 @@ enum class MeterRxState : uint8_t { InFrame = 1 }; -static MeterRxState g_rx_state = MeterRxState::WaitStart; -static char g_frame_buf[METER_FRAME_MAX + 1]; -static size_t g_frame_len = 0; -static uint32_t g_last_rx_ms = 0; -static uint32_t g_bytes_rx = 0; -static uint32_t g_frames_ok = 0; -static uint32_t g_frames_parse_fail = 0; -static uint32_t g_rx_overflow = 0; -static uint32_t g_rx_timeout = 0; -static uint32_t g_last_log_ms = 0; +struct MeterPort { + HardwareSerial *serial; + MeterRxState state; + char frame_buf[METER_FRAME_MAX + 1]; + size_t frame_len; + uint32_t last_rx_ms; + uint32_t bytes_rx; + uint32_t frames_ok; + uint32_t frames_parse_fail; + uint32_t rx_overflow; + uint32_t rx_timeout; + uint32_t last_energy_kwh; + bool has_energy; +}; -void meter_init() { - Serial2.begin(9600, SERIAL_7E1, PIN_METER_RX, -1); -} +static MeterPort g_ports[METER_COUNT] = {}; +static uint32_t g_last_log_ms = 0; static bool parse_obis_ascii_value(const char *line, const char *obis, float &out_value) { const char *p = strstr(line, obis); @@ -62,34 +65,30 @@ static bool parse_obis_ascii_value(const char *line, const char *obis, float &ou return true; } -static bool parse_obis_ascii_unit_scale(const char *line, const char *obis, float &value) { - const char *p = strstr(line, obis); - if (!p) { - return false; - } - const char *asterisk = strchr(p, '*'); - if (!asterisk) { - return false; - } - const char *end = strchr(asterisk, ')'); - if (!end) { - return false; - } - char unit_buf[8]; - size_t ulen = 0; - for (const char *c = asterisk + 1; c < end && ulen + 1 < sizeof(unit_buf); ++c) { - if (*c == ' ') { +static bool parse_energy_kwh_floor(const char *frame, size_t len, uint32_t &out_kwh) { + char line[128]; + size_t line_len = 0; + for (size_t i = 0; i < len; ++i) { + char c = frame[i]; + if (c == '\r') { continue; } - unit_buf[ulen++] = *c; - } - unit_buf[ulen] = '\0'; - if (ulen == 0) { - return false; - } - if (strcmp(unit_buf, "Wh") == 0) { - value *= 0.001f; - return true; + if (c == '\n' || c == '!') { + line[line_len] = '\0'; + float value = NAN; + if (parse_obis_ascii_value(line, "1-0:1.8.0", value) && !isnan(value) && value >= 0.0f) { + out_kwh = static_cast(floorf(value)); + return true; + } + line_len = 0; + if (c == '!') { + break; + } + continue; + } + if (line_len + 1 < sizeof(line)) { + line[line_len++] = c; + } } return false; } @@ -103,162 +102,105 @@ static void meter_debug_log() { return; } g_last_log_ms = now_ms; - Serial.printf("meter: ok=%lu parse_fail=%lu overflow=%lu timeout=%lu bytes=%lu\n", - static_cast(g_frames_ok), - static_cast(g_frames_parse_fail), - static_cast(g_rx_overflow), - static_cast(g_rx_timeout), - static_cast(g_bytes_rx)); + for (uint8_t i = 0; i < METER_COUNT; ++i) { + const MeterPort &p = g_ports[i]; + Serial.printf("meter%u: ok=%lu parse_fail=%lu overflow=%lu timeout=%lu bytes=%lu e=%lu valid=%u\n", + static_cast(i + 1), + static_cast(p.frames_ok), + static_cast(p.frames_parse_fail), + static_cast(p.rx_overflow), + static_cast(p.rx_timeout), + static_cast(p.bytes_rx), + static_cast(p.last_energy_kwh), + p.has_energy ? 1 : 0); + } } -bool meter_poll_frame(const char *&frame, size_t &len) { - frame = nullptr; - len = 0; +void meter_init() { + g_ports[0].serial = &Serial2; + g_ports[0].serial->begin(9600, SERIAL_7E1, PIN_METER1_RX, -1); + g_ports[0].state = MeterRxState::WaitStart; + + if (METER_COUNT >= 2) { + g_ports[1].serial = &Serial1; + g_ports[1].serial->begin(9600, SERIAL_7E1, PIN_METER2_RX, -1); + g_ports[1].state = MeterRxState::WaitStart; + } + + if (METER_COUNT >= 3) { + g_ports[2].serial = &Serial; + g_ports[2].serial->begin(9600, SERIAL_7E1, PIN_METER3_RX, -1); + g_ports[2].state = MeterRxState::WaitStart; + } +} + +static void meter_poll_port(MeterPort &port) { + if (!port.serial) { + return; + } uint32_t now_ms = millis(); - - if (g_rx_state == MeterRxState::InFrame && (now_ms - g_last_rx_ms > METER_FRAME_TIMEOUT_MS)) { - g_rx_timeout++; - g_rx_state = MeterRxState::WaitStart; - g_frame_len = 0; + if (port.state == MeterRxState::InFrame && (now_ms - port.last_rx_ms > METER_FRAME_TIMEOUT_MS)) { + port.rx_timeout++; + port.state = MeterRxState::WaitStart; + port.frame_len = 0; } - while (Serial2.available()) { - char c = static_cast(Serial2.read()); - g_bytes_rx++; - g_last_rx_ms = now_ms; + while (port.serial->available()) { + char c = static_cast(port.serial->read()); + port.bytes_rx++; + port.last_rx_ms = now_ms; - if (g_rx_state == MeterRxState::WaitStart) { + if (port.state == MeterRxState::WaitStart) { if (c == '/') { - g_rx_state = MeterRxState::InFrame; - g_frame_len = 0; - g_frame_buf[g_frame_len++] = c; + port.state = MeterRxState::InFrame; + port.frame_len = 0; + port.frame_buf[port.frame_len++] = c; } continue; } - if (g_frame_len + 1 >= sizeof(g_frame_buf)) { - g_rx_overflow++; - g_rx_state = MeterRxState::WaitStart; - g_frame_len = 0; + if (port.frame_len + 1 >= sizeof(port.frame_buf)) { + port.rx_overflow++; + port.state = MeterRxState::WaitStart; + port.frame_len = 0; continue; } - g_frame_buf[g_frame_len++] = c; + port.frame_buf[port.frame_len++] = c; if (c == '!') { - g_frame_buf[g_frame_len] = '\0'; - frame = g_frame_buf; - len = g_frame_len; - g_rx_state = MeterRxState::WaitStart; - g_frame_len = 0; - meter_debug_log(); - return true; - } - } - - meter_debug_log(); - return false; -} - -bool meter_parse_frame(const char *frame, size_t len, MeterData &data) { - if (!frame || len == 0) { - return false; - } - bool got_any = false; - bool energy_ok = false; - bool total_p_ok = false; - bool p1_ok = false; - bool p2_ok = false; - bool p3_ok = false; - char line[128]; - size_t line_len = 0; - - for (size_t i = 0; i < len; ++i) { - char c = frame[i]; - if (c == '\r') { - continue; - } - if (c == '!') { - if (line_len + 1 < sizeof(line)) { - line[line_len++] = c; - } - line[line_len] = '\0'; - data.valid = energy_ok || total_p_ok || p1_ok || p2_ok || p3_ok; - if (data.valid) { - g_frames_ok++; + port.frame_buf[port.frame_len] = '\0'; + uint32_t energy_kwh = 0; + if (parse_energy_kwh_floor(port.frame_buf, port.frame_len, energy_kwh)) { + port.last_energy_kwh = energy_kwh; + port.has_energy = true; + port.frames_ok++; } else { - g_frames_parse_fail++; + port.frames_parse_fail++; } - return data.valid; - } - if (c == '\n') { - line[line_len] = '\0'; - if (line[0] == '!') { - data.valid = energy_ok || total_p_ok || p1_ok || p2_ok || p3_ok; - if (data.valid) { - g_frames_ok++; - } else { - g_frames_parse_fail++; - } - return data.valid; - } - - float value = NAN; - if (parse_obis_ascii_value(line, "1-0:1.8.0", value)) { - parse_obis_ascii_unit_scale(line, "1-0:1.8.0", value); - data.energy_total_kwh = value; - energy_ok = true; - got_any = true; - } - if (parse_obis_ascii_value(line, "1-0:16.7.0", value)) { - data.total_power_w = value; - total_p_ok = true; - got_any = true; - } - if (parse_obis_ascii_value(line, "1-0:36.7.0", value)) { - data.phase_power_w[0] = value; - p1_ok = true; - got_any = true; - } - if (parse_obis_ascii_value(line, "1-0:56.7.0", value)) { - data.phase_power_w[1] = value; - p2_ok = true; - got_any = true; - } - if (parse_obis_ascii_value(line, "1-0:76.7.0", value)) { - data.phase_power_w[2] = value; - p3_ok = true; - got_any = true; - } - - line_len = 0; - continue; - } - if (line_len + 1 < sizeof(line)) { - line[line_len++] = c; + port.state = MeterRxState::WaitStart; + port.frame_len = 0; } } - - data.valid = got_any; - if (data.valid) { - g_frames_ok++; - } else { - g_frames_parse_fail++; - } - return data.valid; } -bool meter_read(MeterData &data) { - data.energy_total_kwh = NAN; - data.total_power_w = NAN; - data.phase_power_w[0] = NAN; - data.phase_power_w[1] = NAN; - data.phase_power_w[2] = NAN; - data.valid = false; +void meter_poll() { + for (uint8_t i = 0; i < METER_COUNT; ++i) { + meter_poll_port(g_ports[i]); + } + meter_debug_log(); +} - const char *frame = nullptr; - size_t len = 0; - if (!meter_poll_frame(frame, len)) { +uint8_t meter_count() { + return METER_COUNT; +} + +bool meter_get_last_energy_kwh(uint8_t meter_idx, uint32_t &out_energy_kwh) { + if (meter_idx >= METER_COUNT) { return false; } - return meter_parse_frame(frame, len, data); + if (!g_ports[meter_idx].has_energy) { + return false; + } + out_energy_kwh = g_ports[meter_idx].last_energy_kwh; + return true; } diff --git a/src/payload_codec.cpp b/src/payload_codec.cpp index 11d0cb6..bc674c0 100644 --- a/src/payload_codec.cpp +++ b/src/payload_codec.cpp @@ -5,6 +5,8 @@ static constexpr uint16_t kMagic = 0xDDB3; static constexpr uint8_t kSchema = 2; static constexpr uint8_t kFlags = 0x01; static constexpr size_t kMaxSamples = 30; +static constexpr uint8_t kPayloadSchemaLegacy = 0; +static constexpr uint8_t kPayloadSchemaEnergyMulti = 1; static void write_u16_le(uint8_t *dst, uint16_t value) { dst[0] = static_cast(value & 0xFF); @@ -108,13 +110,14 @@ bool encode_batch(const BatchInput &in, uint8_t *out, size_t out_cap, size_t *ou return false; } size_t pos = 0; - if (!ensure_capacity(21, out_cap, pos)) { + if (!ensure_capacity(23, out_cap, pos)) { return false; } write_u16_le(&out[pos], kMagic); pos += 2; out[pos++] = kSchema; out[pos++] = kFlags; + out[pos++] = in.schema_id; write_u16_le(&out[pos], in.sender_id); pos += 2; write_u16_le(&out[pos], in.batch_id); @@ -130,12 +133,32 @@ bool encode_batch(const BatchInput &in, uint8_t *out, size_t out_cap, size_t *ou out[pos++] = in.err_tx; out[pos++] = in.err_last; out[pos++] = in.err_rx_reject; + out[pos++] = in.meter_count; if (in.n == 0) { *out_len = pos; return true; } + if (in.schema_id == kPayloadSchemaEnergyMulti) { + if (in.meter_count == 0 || in.meter_count > 3) { + return false; + } + if (!ensure_capacity(static_cast(in.n) * 12, out_cap, pos)) { + return false; + } + for (uint8_t i = 0; i < in.n; ++i) { + write_u32_le(&out[pos], in.energy1_kwh[i]); + pos += 4; + write_u32_le(&out[pos], in.energy2_kwh[i]); + pos += 4; + write_u32_le(&out[pos], in.energy3_kwh[i]); + pos += 4; + } + *out_len = pos; + return true; + } + if (!ensure_capacity(4, out_cap, pos)) { return false; } @@ -189,7 +212,7 @@ bool decode_batch(const uint8_t *buf, size_t len, BatchInput *out) { return false; } size_t pos = 0; - if (len < 21) { + if (len < 23) { return false; } uint16_t magic = read_u16_le(&buf[pos]); @@ -199,6 +222,7 @@ bool decode_batch(const uint8_t *buf, size_t len, BatchInput *out) { if (magic != kMagic || schema != kSchema || (flags & 0x01) == 0) { return false; } + out->schema_id = buf[pos++]; out->sender_id = read_u16_le(&buf[pos]); pos += 2; out->batch_id = read_u16_le(&buf[pos]); @@ -214,6 +238,7 @@ bool decode_batch(const uint8_t *buf, size_t len, BatchInput *out) { out->err_tx = buf[pos++]; out->err_last = buf[pos++]; out->err_rx_reject = buf[pos++]; + out->meter_count = buf[pos++]; if (out->n > kMaxSamples || out->dt_s == 0) { return false; @@ -227,6 +252,29 @@ bool decode_batch(const uint8_t *buf, size_t len, BatchInput *out) { } return pos == len; } + if (out->schema_id == kPayloadSchemaEnergyMulti) { + if (out->meter_count == 0 || out->meter_count > 3) { + return false; + } + if (pos + static_cast(out->n) * 12 > len) { + return false; + } + for (uint8_t i = 0; i < out->n; ++i) { + out->energy1_kwh[i] = read_u32_le(&buf[pos]); + pos += 4; + out->energy2_kwh[i] = read_u32_le(&buf[pos]); + pos += 4; + out->energy3_kwh[i] = read_u32_le(&buf[pos]); + pos += 4; + } + for (uint8_t i = out->n; i < kMaxSamples; ++i) { + out->energy1_kwh[i] = 0; + out->energy2_kwh[i] = 0; + out->energy3_kwh[i] = 0; + } + return pos == len; + } + if (pos + 4 > len) { return false; } @@ -289,6 +337,7 @@ bool decode_batch(const uint8_t *buf, size_t len, BatchInput *out) { #ifdef PAYLOAD_CODEC_TEST bool payload_codec_self_test() { BatchInput in = {}; + in.schema_id = kPayloadSchemaLegacy; in.sender_id = 1; in.batch_id = 42; in.t_last = 1700000000; @@ -300,6 +349,7 @@ bool payload_codec_self_test() { in.err_tx = 3; in.err_last = 2; in.err_rx_reject = 1; + in.meter_count = 0; in.energy_wh[0] = 100000; in.energy_wh[1] = 100001; in.energy_wh[2] = 100050; diff --git a/src/payload_codec.h b/src/payload_codec.h index 8887bd1..4cc4e16 100644 --- a/src/payload_codec.h +++ b/src/payload_codec.h @@ -3,17 +3,22 @@ #include struct BatchInput { + uint8_t schema_id; uint16_t sender_id; uint16_t batch_id; uint32_t t_last; uint8_t dt_s; uint8_t n; + uint8_t meter_count; uint16_t battery_mV; uint8_t err_m; uint8_t err_d; uint8_t err_tx; uint8_t err_last; uint8_t err_rx_reject; + uint32_t energy1_kwh[30]; + uint32_t energy2_kwh[30]; + uint32_t energy3_kwh[30]; uint32_t energy_wh[30]; int16_t p1_w[30]; int16_t p2_w[30]; diff --git a/src/web_server.cpp b/src/web_server.cpp index 8e37401..346f33a 100644 --- a/src/web_server.cpp +++ b/src/web_server.cpp @@ -374,11 +374,19 @@ static String render_sender_block(const SenderStatus &status) { if (!status.has_data) { s += "No data"; } else { - s += "Energy: " + String(status.last_data.energy_total_kwh, 2) + " kWh
"; - s += "Power: " + String(round_power_w(status.last_data.total_power_w)) + " W
"; - s += "P1/P2/P3: " + String(round_power_w(status.last_data.phase_power_w[0])) + " / " + - String(round_power_w(status.last_data.phase_power_w[1])) + " / " + - String(round_power_w(status.last_data.phase_power_w[2])) + " W
"; + if (status.last_data.energy_multi) { + s += "Energy1: " + String(status.last_data.energy_kwh_int[0]) + " kWh
"; + s += "Energy2: " + String(status.last_data.energy_kwh_int[1]) + " kWh
"; + if (status.last_data.energy_meter_count >= 3) { + s += "Energy3: " + String(status.last_data.energy_kwh_int[2]) + " kWh
"; + } + } else { + s += "Energy: " + String(status.last_data.energy_total_kwh, 2) + " kWh
"; + s += "Power: " + String(round_power_w(status.last_data.total_power_w)) + " W
"; + s += "P1/P2/P3: " + String(round_power_w(status.last_data.phase_power_w[0])) + " / " + + String(round_power_w(status.last_data.phase_power_w[1])) + " / " + + String(round_power_w(status.last_data.phase_power_w[2])) + " W
"; + } s += "Battery: " + String(status.last_data.battery_percent) + "% (" + String(status.last_data.battery_voltage_v, 2) + " V)"; } s += ""; @@ -605,14 +613,16 @@ static void handle_sender() { if (g_last_batch_count[i] > 0) { html += "

Last batch (" + String(g_last_batch_count[i]) + " samples)

"; html += ""; - html += ""; + html += ""; html += ""; for (uint8_t r = 0; r < g_last_batch_count[i]; ++r) { const MeterData &d = g_last_batch[i][r]; html += ""; html += ""; html += ""; - html += ""; + html += ""; + html += ""; + html += ""; html += ""; html += ""; html += "";
#tse_kwhp_wp1_wp2_wp3_w
#tsenergy1_kwhenergy2_kwhenergy3_kwhp_wp1_wp2_wp3_wbat_vbat_pctrssisnrerr_txerr_lastrx_reject
" + String(r) + "" + String(d.ts_utc) + "" + String(d.energy_total_kwh, 2) + "" + String(d.energy_kwh_int[0]) + "" + String(d.energy_kwh_int[1]) + "" + String(d.energy_kwh_int[2]) + "" + String(round_power_w(d.total_power_w)) + "" + String(round_power_w(d.phase_power_w[0])) + "" + String(round_power_w(d.phase_power_w[1])) + "