diff --git a/CHANGELOG.md b/CHANGELOG.md index 29759f9..5f0d412 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,25 @@ and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0. ## [Unreleased] +### Fixed +- **Techem meters not recognised.** Several Techem MVT rows had the + version and type bytes swapped relative to wmbusmeters + (`mvt = TCH,,`), so MK-Radio 3/4/3a water, Compact V + heat, Vario 451 heat and TSD2 smoke frames fell through to the + generic walker. Rows now match wmbusmeters `drivers/src/*.xmq`. +- **Vario 451 kWh 100× too high.** The MJ→kWh conversion used + `raw × 250 / 9` instead of `raw / 3.6`. +- Vario 451 MID (v0x17) and Vario 411 (v0x28) send OMS DIF/VIF + records and now use the generic walker instead of the compact decoder. + +### Added +- Techem MK-Radio water version 0x52 (seen in the field, same layout + as MK-Radio 3). +- Water titles show warm/cold water; MK-Radio 4 shows billing dates. +- TSD2 smoke detector status (OK / SMOKE / DEFECT) and billing date. +- Host tests `tests/test_techem_water.c` and `tests/test_techem_other.c` + using wmbusmeters test vectors. + ## [1.1.1] — 2026-05-01 ### Fixed diff --git a/drivers/engine/registry.c b/drivers/engine/registry.c index 6b439a5..376e51a 100644 --- a/drivers/engine/registry.c +++ b/drivers/engine/registry.c @@ -17,9 +17,12 @@ extern const WmbusDriver wmbus_drv_techem_fhkv; extern const WmbusDriver wmbus_drv_techem_mkradio3; extern const WmbusDriver wmbus_drv_techem_mkradio4; +extern const WmbusDriver wmbus_drv_techem_mkradio4a; extern const WmbusDriver wmbus_drv_techem_compact5; extern const WmbusDriver wmbus_drv_techem_vario; +extern const WmbusDriver wmbus_drv_techem_vario_oms; extern const WmbusDriver wmbus_drv_techem_smoke; +extern const WmbusDriver wmbus_drv_techem_tsd2; /* === HCA drivers with custom 12-byte preamble === */ extern const WmbusDriver wmbus_drv_qundis_hca; @@ -146,9 +149,12 @@ const WmbusDriver* const wmbus_engine_registry[] = { &wmbus_drv_techem_fhkv, &wmbus_drv_techem_mkradio3, &wmbus_drv_techem_mkradio4, + &wmbus_drv_techem_mkradio4a, &wmbus_drv_techem_compact5, &wmbus_drv_techem_vario, + &wmbus_drv_techem_vario_oms, &wmbus_drv_techem_smoke, + &wmbus_drv_techem_tsd2, &wmbus_drv_qundis_hca, &wmbus_drv_ista_hca, &wmbus_drv_brunata_hca, diff --git a/drivers/europe/techem/README.md b/drivers/europe/techem/README.md index 5b6a6f8..55a7a47 100644 --- a/drivers/europe/techem/README.md +++ b/drivers/europe/techem/README.md @@ -18,8 +18,7 @@ right decoder. ## Known limitations -- The Vario heat decoder uses an integer GJ→kWh approximation - (raw × 250 / 9). The largest possible 16-bit raw value rounds - to within ±0.06 kWh of the IEEE-double calculation. +- The Vario heat decoder converts MJ to kWh with integer math + (raw × 5 / 18, i.e. raw / 3.6), rounded to the nearest kWh. - Smoke alarm bit semantics are not public; we surface the status byte verbatim so a non-zero value flags an event. diff --git a/drivers/europe/techem/_compact.c b/drivers/europe/techem/_compact.c index 6931676..e1b812b 100644 --- a/drivers/europe/techem/_compact.c +++ b/drivers/europe/techem/_compact.c @@ -102,7 +102,7 @@ size_t techem_decode_fhkv(uint8_t version, return pos; } -size_t techem_decode_water(bool with_dates, +size_t techem_decode_water(const char* title, bool with_dates, const uint8_t* a, size_t l, char* o, size_t cap) { if(l < 9) return techem_hex_dump(a, l, o, cap, "Techem water short"); @@ -111,7 +111,7 @@ size_t techem_decode_water(bool with_dates, uint32_t total_dl = (uint32_t)prev + curr; size_t pos = 0; - pos += append(o, cap, pos, "Techem water\n"); + pos += append(o, cap, pos, "%s\n", title ? title : "Techem water"); pos += append(o, cap, pos, "Now %lu.%lu m3\n", (unsigned long)(total_dl / 10), (unsigned long)(total_dl % 10)); pos += append(o, cap, pos, "Period %u.%u m3\n", @@ -129,7 +129,7 @@ size_t techem_decode_water(bool with_dates, techem_curr_date(curr_date_w, yr_prev, day_prev, mon_prev, dcurr, sizeof(dcurr)); pos += append(o, cap, pos, "Reset %s\n", dprev); - pos += append(o, cap, pos, "Ends %s\n", dcurr); + pos += append(o, cap, pos, "Read %s\n", dcurr); } return pos; } @@ -152,16 +152,14 @@ size_t techem_decode_compact5(const uint8_t* a, size_t l, size_t techem_decode_vario(const uint8_t* a, size_t l, char* o, size_t cap) { if(l < 9) return techem_hex_dump(a, l, o, cap, "Vario heat short"); - /* Raw u16 = "GJ × 1000". Convert to kWh via integer math: - * 1 GJ = 1e9 J = 1e9 / 3600 Wh ≈ 277.778 kWh - * raw / 1000 GJ × (1000 × 1000 / 3600) kWh/GJ - * = raw × (1000 / 3600) / 1 - * = raw × 250 / 9 (exact rational form) - * Width: raw ≤ 65535 → kWh ≤ 1820972. Fits in u32. */ + /* Raw u16 = "GJ × 1000" (MJ). 1 GJ = 277.78 kWh, so + * kWh = raw / 1000 × 277.78 = raw / 3.6 = raw × 5 / 18 + * which matches wmbusmeters vario451.xmq (`raw / 3.6 * 1 kwh`). + * Rounded to the nearest kWh. */ uint16_t prev_raw = (uint16_t)(a[3] | (a[4] << 8)); uint16_t curr_raw = (uint16_t)(a[7] | (a[8] << 8)); - uint32_t prev_kwh = (uint32_t)((uint64_t)prev_raw * 250 / 9); - uint32_t curr_kwh = (uint32_t)((uint64_t)curr_raw * 250 / 9); + uint32_t prev_kwh = ((uint32_t)prev_raw * 5 + 9) / 18; + uint32_t curr_kwh = ((uint32_t)curr_raw * 5 + 9) / 18; /* GJ to two decimals: raw / 1000 GJ → raw / 10 in centi-GJ. */ uint32_t prev_gj_x100 = (uint32_t)prev_raw / 10; @@ -185,6 +183,22 @@ size_t techem_decode_vario(const uint8_t* a, size_t l, return pos; } +size_t techem_decode_tsd2(const uint8_t* a, size_t l, + char* o, size_t cap) { + if(l < 3) return techem_hex_dump(a, l, o, cap, "Techem TSD2 short"); + const char* st = a[0] == 0x00 ? "OK" : + a[0] == 0x01 ? "SMOKE" : + a[0] == 0x80 ? "DEFECT" : NULL; + char dprev[16]; + techem_prev_date((uint16_t)(a[1] | (a[2] << 8)), dprev, sizeof(dprev), NULL); + size_t pos = 0; + pos += append(o, cap, pos, "Techem TSD2 smoke\n"); + if(st) pos += append(o, cap, pos, "Status %s\n", st); + else pos += append(o, cap, pos, "Status 0x%02X\n", a[0]); + pos += append(o, cap, pos, "Reset %s\n", dprev); + return pos; +} + size_t techem_decode_smoke(const uint8_t* a, size_t l, char* o, size_t cap) { size_t pos = 0; diff --git a/drivers/europe/techem/_compact.h b/drivers/europe/techem/_compact.h index 8155609..a08cba0 100644 --- a/drivers/europe/techem/_compact.h +++ b/drivers/europe/techem/_compact.h @@ -26,10 +26,10 @@ size_t techem_decode_fhkv(uint8_t version, const uint8_t* a, size_t l, char* o, size_t cap); -/* Decode an MK-Radio water frame. `with_dates` enables the - * billing-period date fields (mkradio3 has them, mkradio4 ships - * zero-filled date bytes that aren't worth showing). */ -size_t techem_decode_water(bool with_dates, +/* Decode an MK-Radio water frame. `title` is the first output line + * (e.g. "Techem warm water"). `with_dates` enables the billing-period + * date fields; invalid dates render as "-". */ +size_t techem_decode_water(const char* title, bool with_dates, const uint8_t* a, size_t l, char* o, size_t cap); @@ -46,3 +46,7 @@ size_t techem_decode_vario(const uint8_t* a, size_t l, * is not public; we surface status + flag bytes verbatim. */ size_t techem_decode_smoke(const uint8_t* a, size_t l, char* o, size_t cap); + +/* Decode a TSD2 smoke detector frame: status + previous billing date. */ +size_t techem_decode_tsd2(const uint8_t* a, size_t l, + char* o, size_t cap); diff --git a/drivers/europe/techem/compact5_heat.c b/drivers/europe/techem/compact5_heat.c index ebe3cf9..6c77622 100644 --- a/drivers/europe/techem/compact5_heat.c +++ b/drivers/europe/techem/compact5_heat.c @@ -5,12 +5,13 @@ #include "../../engine/driver.h" #include "_compact.h" +/* (version, type) per wmbusmeters `drivers/src/compact5.xmq`. */ static const WmbusMVT k_mvt[] = { - {"TCH", 0x04, 0x45}, - {"TCH", 0xC3, 0x45}, - {"TCH", 0x43, 0x45}, - {"TCH", 0x43, 0x39}, - {"TCH", 0x43, 0x22}, + {"TCH", 0x45, 0x04}, + {"TCH", 0x45, 0xC3}, + {"TCH", 0x22, 0x43}, + {"TCH", 0x45, 0x43}, + {"TCH", 0x39, 0x43}, { {0}, 0, 0 } }; diff --git a/drivers/europe/techem/fhkv_hca.c b/drivers/europe/techem/fhkv_hca.c index a43d89d..15cf3dd 100644 --- a/drivers/europe/techem/fhkv_hca.c +++ b/drivers/europe/techem/fhkv_hca.c @@ -15,11 +15,6 @@ static const WmbusMVT k_mvt[] = { {"TCH", 0x69, 0x80}, {"TCH", 0x94, 0x08}, {"TCH", 0x94, 0x80}, - /* Some Techem firmwares ship the version / medium bytes swapped in - * the link header — wmbusmeters lists both orderings under the same - * `fhkvdataiii` driver. */ - {"TCH", 0x80, 0x69}, - {"TCH", 0x80, 0x94}, { {0}, 0, 0 } }; diff --git a/drivers/europe/techem/mkradio3a.c b/drivers/europe/techem/mkradio3a.c index 7a57115..a4e8971 100644 --- a/drivers/europe/techem/mkradio3a.c +++ b/drivers/europe/techem/mkradio3a.c @@ -58,8 +58,9 @@ static size_t decode_mk3a(uint16_t m, uint8_t v, uint8_t med, return pos; } +/* wmbusmeters: mvt = TCH,50,72 (version 0x50, type 0x72). */ static const WmbusMVT k_mvt[] = { - {"TCH", 0x72, 0x50}, + {"TCH", 0x50, 0x72}, { {0}, 0, 0 } }; const WmbusDriver wmbus_drv_techem_mkradio3a = { diff --git a/drivers/europe/techem/mkradio_water.c b/drivers/europe/techem/mkradio_water.c index 2b3eed2..501c57b 100644 --- a/drivers/europe/techem/mkradio_water.c +++ b/drivers/europe/techem/mkradio_water.c @@ -1,23 +1,41 @@ /* Techem MK-Radio 3 / 4 / 4a water meter. * - * MK-Radio 3 telegrams carry billing-period date fields; MK-Radio - * 4 and 4a omit them (the bytes are zero-filled). MVT lists are - * mirrored from wmbusmeters `src/driver_mkradio3.cc`, - * `src/driver_mkradio4.cc`, and `drivers/src/mkradio4a.xmq`. */ + * MVT lists mirror wmbusmeters `drivers/src/mkradio3.xmq`, + * `mkradio4.xmq` and `mkradio4a.xmq`. Their `mvt = TCH,,` + * lines are (manufacturer, version, type) — the same order as our + * WmbusMVT struct. Techem uses type 0x62 for warm water and 0x72 for + * cold water. + * + * Payload (bytes after CI 0xA2): + * [0] status + * [1..2] previous billing date (day bits 0-4, month 5-8, year 9-14) + * [3..4] volume at previous billing date, 0.1 m3 + * [5..6] current date (day bits 4-8, month 9-12) + * [7..8] volume since previous billing date, 0.1 m3 */ #include "../../engine/driver.h" #include "_compact.h" -/* MK-Radio 3 — version 0x62/0x72 + medium 0x74. */ +static const char* water_title(uint8_t med) { + if(med == 0x62) return "Techem warm water"; + if(med == 0x72) return "Techem cold water"; + return "Techem water"; +} + +/* MK-Radio 3 — version 0x74 (wmbusmeters mkradio3). + * Version 0x52 is not in wmbusmeters; it was seen in the field with + * the same layout and valid billing dates, so it is decoded the same way. */ static const WmbusMVT k_mvt_mk3[] = { - {"TCH", 0x62, 0x74}, - {"TCH", 0x72, 0x74}, + {"TCH", 0x74, 0x62}, + {"TCH", 0x74, 0x72}, + {"TCH", 0x52, 0x62}, + {"TCH", 0x52, 0x72}, { {0}, 0, 0 } }; static size_t decode_mk3(uint16_t m, uint8_t v, uint8_t med, const uint8_t* a, size_t l, char* o, size_t cap) { - (void)m; (void)v; (void)med; - return techem_decode_water(/* with_dates */ true, a, l, o, cap); + (void)m; (void)v; + return techem_decode_water(water_title(med), /* with_dates */ true, a, l, o, cap); } const WmbusDriver wmbus_drv_techem_mkradio3 = { .id = "techem-mkradio3", @@ -26,21 +44,20 @@ const WmbusDriver wmbus_drv_techem_mkradio3 = { .decode = decode_mk3, }; -/* MK-Radio 4 / 4a — versions 0x62/0x72/0x95 + mediums 0x70/0x95/0x37. */ +/* MK-Radio 4 — versions 0x95 / 0x70 (wmbusmeters mkradio4). + * wmbusmeters ignores the date bytes, but field captures of 0x95 + * carry valid billing dates, so they are shown (invalid ones render "-"). */ static const WmbusMVT k_mvt_mk4[] = { - {"TCH", 0x62, 0x70}, - {"TCH", 0x72, 0x70}, - {"TCH", 0x62, 0x95}, - {"TCH", 0x72, 0x95}, - {"TCH", 0x95, 0x37}, - {"TCH", 0x72, 0x50}, /* MK Radio 3a — wmbusmeters mkradio3a */ - {"HYD", 0xFE, 0x06}, /* mkradio4a OEM rebadge */ + {"TCH", 0x95, 0x62}, + {"TCH", 0x95, 0x72}, + {"TCH", 0x70, 0x62}, + {"TCH", 0x70, 0x72}, { {0}, 0, 0 } }; static size_t decode_mk4(uint16_t m, uint8_t v, uint8_t med, const uint8_t* a, size_t l, char* o, size_t cap) { - (void)m; (void)v; (void)med; - return techem_decode_water(/* with_dates */ false, a, l, o, cap); + (void)m; (void)v; + return techem_decode_water(water_title(med), /* with_dates */ true, a, l, o, cap); } const WmbusDriver wmbus_drv_techem_mkradio4 = { .id = "techem-mkradio4", @@ -48,3 +65,17 @@ const WmbusDriver wmbus_drv_techem_mkradio4 = { .mvt = k_mvt_mk4, .decode = decode_mk4, }; + +/* MK-Radio 4a — wmbusmeters mkradio4a. This one is a standard OMS + * frame (DIF/VIF), so it goes through the generic walker. */ +static const WmbusMVT k_mvt_mk4a[] = { + {"TCH", 0x95, 0x37}, + {"HYD", 0xFE, 0x06}, + { {0}, 0, 0 } +}; +const WmbusDriver wmbus_drv_techem_mkradio4a = { + .id = "techem-mkradio4a", + .title = "Techem MK-Radio4a water", + .mvt = k_mvt_mk4a, + .decode = NULL, +}; diff --git a/drivers/europe/techem/smoke.c b/drivers/europe/techem/smoke.c index 3e3ca18..8182d36 100644 --- a/drivers/europe/techem/smoke.c +++ b/drivers/europe/techem/smoke.c @@ -6,11 +6,8 @@ #include "_compact.h" static const WmbusMVT k_mvt[] = { - /* Wildcard medium 0x1A covers OMS-canonical smoke-detector - * frames; the second tuple is the Techem-private medium. */ + /* Wildcard version, OMS smoke-detector type 0x1A. */ {"TCH", 0xFF, 0x1A}, - {"TCH", 0x00, 0x76}, /* legacy code seen in older Techem stock */ - {"TCH", 0xF0, 0x76}, /* TSD2 — wmbusmeters tsd2 driver */ { {0}, 0, 0 } }; @@ -26,3 +23,22 @@ const WmbusDriver wmbus_drv_techem_smoke = { .mvt = k_mvt, .decode = decode, }; + +/* TSD2 — wmbusmeters `drivers/src/tsd2.xmq`: version 0x76, type 0xF0. + * Payload [0] status (0x00 OK, 0x01 smoke, 0x80 defect), + * [1..2] previous billing date. */ +static const WmbusMVT k_mvt_tsd2[] = { + {"TCH", 0x76, 0xF0}, + { {0}, 0, 0 } +}; +static size_t decode_tsd2(uint16_t m, uint8_t v, uint8_t med, + const uint8_t* a, size_t l, char* o, size_t cap) { + (void)m; (void)v; (void)med; + return techem_decode_tsd2(a, l, o, cap); +} +const WmbusDriver wmbus_drv_techem_tsd2 = { + .id = "techem-tsd2", + .title = "Techem TSD2 smoke", + .mvt = k_mvt_tsd2, + .decode = decode_tsd2, +}; diff --git a/drivers/europe/techem/vario_heat.c b/drivers/europe/techem/vario_heat.c index bd0a640..9c64123 100644 --- a/drivers/europe/techem/vario_heat.c +++ b/drivers/europe/techem/vario_heat.c @@ -6,16 +6,10 @@ #include "../../engine/driver.h" #include "_compact.h" +/* (version, type) per wmbusmeters `drivers/src/vario451.xmq`. */ static const WmbusMVT k_mvt[] = { - {"TCH", 0x04, 0x27}, - {"TCH", 0xC3, 0x27}, - /* The MID-certified Vario 451 ships under (TCH, 0x17, 0x04) - * per the wmbusmeters declarative driver `vario451mid.xmq`. */ - {"TCH", 0x17, 0x04}, - /* Vario 411 (older heat meter) — ver 0x28, med 0x04. The - * billing-period offsets are identical, so the Vario decoder - * applies. */ - {"TCH", 0x28, 0x04}, + {"TCH", 0x27, 0x04}, + {"TCH", 0x27, 0xC3}, { {0}, 0, 0 } }; @@ -31,3 +25,18 @@ const WmbusDriver wmbus_drv_techem_vario = { .mvt = k_mvt, .decode = decode, }; + +/* Vario 451 MID (0x17) and Vario 411 (0x28) send standard OMS + * DIF/VIF records (wmbusmeters `vario451mid.xmq`, `vario411.xmq`), + * not the compact layout, so they use the generic walker. */ +static const WmbusMVT k_mvt_oms[] = { + {"TCH", 0x17, 0x04}, + {"TCH", 0x28, 0x04}, + { {0}, 0, 0 } +}; +const WmbusDriver wmbus_drv_techem_vario_oms = { + .id = "techem-vario-oms", + .title = "Techem Vario heat", + .mvt = k_mvt_oms, + .decode = NULL, +}; diff --git a/tests/Makefile b/tests/Makefile index b7440e1..380637f 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -47,13 +47,39 @@ PORTS_SRC = test_ports.c \ test_ports: $(PORTS_SRC) $(CC) $(CFLAGS) $(PORTS_SRC) -o $@ -check: test_link test_izar test_apator_hca test_ports +COMMON_SRC = ../drivers/europe/techem/_compact.c \ + ../drivers/engine/driver.c \ + ../protocol/wmbus_link.c \ + ../protocol/wmbus_manuf.c \ + ../protocol/wmbus_medium.c \ + ../protocol/wmbus_app_layer.c + +TECHEM_WATER_SRC = test_techem_water.c \ + ../drivers/europe/techem/mkradio_water.c \ + $(COMMON_SRC) + +test_techem_water: $(TECHEM_WATER_SRC) + $(CC) $(CFLAGS) $(TECHEM_WATER_SRC) -o $@ + +TECHEM_OTHER_SRC = test_techem_other.c \ + ../drivers/europe/techem/fhkv_hca.c \ + ../drivers/europe/techem/compact5_heat.c \ + ../drivers/europe/techem/vario_heat.c \ + ../drivers/europe/techem/smoke.c \ + $(COMMON_SRC) + +test_techem_other: $(TECHEM_OTHER_SRC) + $(CC) $(CFLAGS) $(TECHEM_OTHER_SRC) -o $@ + +check: test_link test_izar test_apator_hca test_ports test_techem_water test_techem_other ./test_link ./test_izar ./test_apator_hca ./test_ports + ./test_techem_water + ./test_techem_other clean: - rm -f test_link test_izar test_apator_hca test_ports + rm -f test_link test_izar test_apator_hca test_ports test_techem_water test_techem_other .PHONY: check clean diff --git a/tests/test_techem_other.c b/tests/test_techem_other.c new file mode 100644 index 0000000..01717ca --- /dev/null +++ b/tests/test_techem_other.c @@ -0,0 +1,125 @@ +/* Host-side regression test for the Techem heat, HCA and smoke drivers. + * + * Checks routing (MVT lookup) and decoded values against the test + * vectors in wmbusmeters `drivers/src/{compact5,vario451,vario411, + * fhkvdataiii,tsd2}.xmq`, plus a field capture of an FHKV HCA. */ + +#include "../drivers/engine/driver.h" +#include "../protocol/wmbus_link.h" +#include "../protocol/wmbus_manuf.h" + +#include +#include +#include + +extern const WmbusDriver wmbus_drv_techem_fhkv; +extern const WmbusDriver wmbus_drv_techem_compact5; +extern const WmbusDriver wmbus_drv_techem_vario; +extern const WmbusDriver wmbus_drv_techem_vario_oms; +extern const WmbusDriver wmbus_drv_techem_smoke; +extern const WmbusDriver wmbus_drv_techem_tsd2; + +const WmbusDriver* const wmbus_engine_registry[] = { + &wmbus_drv_techem_fhkv, + &wmbus_drv_techem_compact5, + &wmbus_drv_techem_vario, + &wmbus_drv_techem_vario_oms, + &wmbus_drv_techem_smoke, + &wmbus_drv_techem_tsd2, +}; +const size_t wmbus_engine_registry_len = 6; + +static int hex2nyb(char c) { + if(c >= '0' && c <= '9') return c - '0'; + if(c >= 'a' && c <= 'f') return c - 'a' + 10; + if(c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; +} +static size_t hex2bin(const char* s, uint8_t* out, size_t cap) { + size_t n = 0; + while(*s && n < cap) { + if(*s == ' ' || *s == '_') { s++; continue; } + int hi = hex2nyb(*s++); if(hi < 0) break; + int lo = hex2nyb(*s++); if(lo < 0) break; + out[n++] = (uint8_t)((hi << 4) | lo); + } + return n; +} + +/* Routing check only: header bytes are enough. */ +static void route(const char* name, const char* hex, const char* driver_id) { + uint8_t fr[16]; + hex2bin(hex, fr, sizeof(fr)); + uint16_t m = (uint16_t)(fr[2] | (fr[3] << 8)); + const WmbusDriver* d = wmbus_engine_find(m, fr[8], fr[9]); + printf("--- %s [V=%02X T=%02X -> %s]\n", name, fr[8], fr[9], d->id); + if(strcmp(d->id, driver_id) != 0) { + fprintf(stderr, "%s: matched '%s', expected '%s'\n", name, d->id, driver_id); + exit(1); + } +} + +static void run(const char* name, const char* hex, const char* driver_id, + const char* const* must) { + uint8_t fr[300]; + size_t flen = hex2bin(hex, fr, sizeof(fr)); + WmbusLinkFrame link; + if(!wmbus_link_parse(fr, flen, &link)) { + fprintf(stderr, "%s: link parse failed\n", name); + exit(1); + } + route(name, hex, driver_id); + const WmbusDriver* d = wmbus_engine_find(link.M, link.version, link.medium); + char out[1024]; + size_t n = d->decode(link.M, link.version, link.medium, + link.apdu, link.apdu_len, out, sizeof(out)); + out[n < sizeof(out) ? n : sizeof(out) - 1] = 0; + printf("%s\n", out); + for(; *must; must++) { + if(!strstr(out, *must)) { + fprintf(stderr, "%s: missing expected '%s'\n", name, *must); + exit(1); + } + } +} + +int main(void) { + /* compact5: previous 375, current 120, total 495 kWh */ + run("compact5 (wmbusmeters)", + "36446850626262624543A1_009F2777010060780000000A000000000000000000000000000000000000000000000000A0400000B4010000", + "techem-compact5", + (const char* []){"Total 495 kWh", "Period 120 kWh", "Last 375 kWh", NULL}); + /* vario451: previous 3642.2, current 2729.4 kWh */ + run("vario451 (wmbusmeters)", + "374468506549235827C3A2_129F25383300A8622600008200800A2AF862115175552877A36F26C9AB1CB24400000004000000000004908002", + "techem-vario", + (const char* []){"Period 2729 kWh", "Last 3642 kWh", NULL}); + /* vario411 / vario451mid: OMS frames, only routing is checked */ + route("vario411 (wmbusmeters)", "624468507578626728048C00", "techem-vario-oms"); + route("vario451mid (wmbusmeters)", "734468501204439417048c00", "techem-vario-oms"); + /* fhkvdataiii: current 131, previous 1026, room 22.44 C, radiator 25.51 C */ + run("fhkvdataiii 0x69 (wmbusmeters)", + "34446850226677116980A0119F27020480048300C408F709143C003D341A2B0B2A0707000000000000062D114457563D71A1850000", + "techem-fhkv", + (const char* []){"Now 131 u", "Prev 1026 u", "Reset 2019-12-31", + "Ends 2020-02-08", "Room 22.44 C", "Rad 25.51 C", NULL}); + run("fhkvdataiii 0x94 (wmbusmeters)", + "33446850341211119480A2_0F9F292D005024040011BD08380904000000070000000000000000000000000001000000000003140E", + "techem-fhkv", + (const char* []){"Now 4 u", "Prev 45 u", "Room 22.37 C", "Rad 23.60 C", NULL}); + /* tsd2: status OK / SMOKE / DEFECT, previous date 2019-12-31 */ + run("tsd2 ok (wmbusmeters)", + "294468506935639176F0A0_009F2782290060822900000401D6311AF93E1BF93E008DC3009ED4000FE500", + "techem-tsd2", + (const char* []){"Status OK", "Reset 2019-12-31", NULL}); + run("tsd2 smoke (wmbusmeters)", + "294468506935639176F0A0_019F2782290060822900000401D6311AF93E1BF93E008DC3009ED4000FE500", + "techem-tsd2", + (const char* []){"Status SMOKE", NULL}); + run("tsd2 defect (wmbusmeters)", + "294468506935639176F0A0_809F2782290060822900000401D6311AF93E1BF93E008DC3009ED4000FE580", + "techem-tsd2", + (const char* []){"Status DEFECT", NULL}); + printf("\nAll Techem heat/HCA/smoke tests passed.\n"); + return 0; +} diff --git a/tests/test_techem_water.c b/tests/test_techem_water.c new file mode 100644 index 0000000..155886e --- /dev/null +++ b/tests/test_techem_water.c @@ -0,0 +1,105 @@ +/* Host-side regression test for the Techem MK-Radio water drivers. + * + * Checks that each telegram is routed to the right driver (the MVT + * lookup) and that the decoded volumes/dates come out right. Vectors + * come from wmbusmeters `drivers/src/mkradio3.xmq` / `mkradio4.xmq` + * plus field captures of version 0x52 and 0x95 meters. */ + +#include "../drivers/engine/driver.h" +#include "../protocol/wmbus_link.h" +#include "../protocol/wmbus_manuf.h" + +#include +#include +#include + +extern const WmbusDriver wmbus_drv_techem_mkradio3; +extern const WmbusDriver wmbus_drv_techem_mkradio4; +extern const WmbusDriver wmbus_drv_techem_mkradio4a; + +const WmbusDriver* const wmbus_engine_registry[] = { + &wmbus_drv_techem_mkradio3, + &wmbus_drv_techem_mkradio4, + &wmbus_drv_techem_mkradio4a, +}; +const size_t wmbus_engine_registry_len = 3; + +static int hex2nyb(char c) { + if(c >= '0' && c <= '9') return c - '0'; + if(c >= 'a' && c <= 'f') return c - 'a' + 10; + if(c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; +} +static size_t hex2bin(const char* s, uint8_t* out, size_t cap) { + size_t n = 0; + while(*s && n < cap) { + if(*s == ' ' || *s == '_') { s++; continue; } + int hi = hex2nyb(*s++); if(hi < 0) break; + int lo = hex2nyb(*s++); if(lo < 0) break; + out[n++] = (uint8_t)((hi << 4) | lo); + } + return n; +} + +static void run(const char* name, const char* hex, const char* driver_id, + const char* const* must) { + uint8_t fr[300]; + size_t flen = hex2bin(hex, fr, sizeof(fr)); + WmbusLinkFrame link; + if(!wmbus_link_parse(fr, flen, &link)) { + fprintf(stderr, "%s: link parse failed\n", name); + exit(1); + } + const WmbusDriver* d = wmbus_engine_find(link.M, link.version, link.medium); + if(strcmp(d->id, driver_id) != 0) { + fprintf(stderr, "%s: matched driver '%s', expected '%s'\n", + name, d->id, driver_id); + exit(1); + } + char out[1024]; + size_t n = d->decode(link.M, link.version, link.medium, + link.apdu, link.apdu_len, out, sizeof(out)); + out[n < sizeof(out) ? n : sizeof(out) - 1] = 0; + printf("--- %s [V=%02X T=%02X -> %s] ---\n%s\n", + name, link.version, link.medium, d->id, out); + for(; *must; must++) { + if(!strstr(out, *must)) { + fprintf(stderr, "%s: missing expected '%s'\n", name, *must); + exit(1); + } + } +} + +int main(void) { + /* wmbusmeters mkradio3: total 13.8, target 8.9, prev 2018-12-31, current 2019-04-27 */ + run("mkradio3 (wmbusmeters)", + "2F446850313233347462A2_069F255900B029310000000306060906030609070606050509050505050407040605070500", + "techem-mkradio3", + (const char* []){"Techem warm water", "Now 13.8 m3", "Last 8.9 m3", + "Reset 2018-12-31", "Read 2019-04-27", NULL}); + /* wmbusmeters mkradio4: total 0.4, target 0.1 */ + run("mkradio4 (wmbusmeters)", + "2F446850200141029562A2_06702901006017030004000300000000000000000000000000000000000000000000000000", + "techem-mkradio4", + (const char* []){"Techem warm water", "Now 0.4 m3", "Last 0.1 m3", NULL}); + /* Field capture, version 0x52 warm water */ + run("v0x52 warm (field)", + "2F446850785634125262A2063E351E003016010000000001010002010102010300000003020000020000000100010000", + "techem-mkradio3", + (const char* []){"Techem warm water", "Now 3.1 m3", "Last 3.0 m3", + "Reset 2026-09-30", "Read 2026-11-03", NULL}); + /* Field capture, version 0x52 cold water */ + run("v0x52 cold (field)", + "2F446850214365875272A2063E35DE003016140000000209100F0E0B0904040303020305060302020004050602040503", + "techem-mkradio3", + (const char* []){"Techem cold water", "Now 24.2 m3", "Period 2.0 m3", + "Last 22.2 m3", NULL}); + /* Field capture, version 0x95 warm water */ + run("v0x95 warm (field)", + "2F446850111111119562A2063E35F802301600000000000000000506000406080B0E090B0E0C0A120B0C0E0A0A0E0207", + "techem-mkradio4", + (const char* []){"Techem warm water", "Now 76.0 m3", "Reset 2026-09-30", + "Read 2026-11-03", NULL}); + printf("\nAll Techem water tests passed.\n"); + return 0; +}