From d1db480b324d97e8458812a52aae64bd4618561a Mon Sep 17 00:00:00 2001
From: PolarGoose <35307286+PolarGoose@users.noreply.github.com>
Date: Mon, 13 Apr 2026 16:37:11 +0200
Subject: [PATCH] * Remove dynamic memory allocations * Add support for TF-PSA
encryption * Improve test coverage * Add logging * Incorporate pull request
"add OBIS for israel meters":
https://github.com/esphome-libs/dsmr_parser/pull/50 * Increase the version of
the library to "1.3.0"
---
README.md | 10 +-
library.json | 2 +-
src/dsmr_parser/aes128gcm.h | 47 -
src/dsmr_parser/decryption/aes128gcm.h | 41 +
.../{ => decryption}/aes128gcm_bearssl.h | 20 +-
.../{ => decryption}/aes128gcm_mbedtls.h | 10 +-
src/dsmr_parser/decryption/aes128gcm_tfpsa.h | 98 ++
src/dsmr_parser/dlms_packet_decryptor.h | 87 +-
src/dsmr_parser/fields.h | 255 ++--
src/dsmr_parser/packet_accumulator.h | 93 +-
src/dsmr_parser/parser.h | 600 +++-----
src/dsmr_parser/util.h | 163 +-
.../aes128gcm_bearssl_include_test.cpp | 4 +-
.../aes128gcm_mbedtls_include_test.cpp | 4 +-
.../aes128gcm_tfpsa_include_test.cpp | 12 +
tests/dlms_packet_decryptor_example_test.cpp | 28 +-
tests/dlms_packet_decryptor_include_test.cpp | 8 +-
tests/dlms_packet_decryptor_test.cpp | 105 +-
tests/packet_accumulator_example_test.cpp | 66 +-
tests/packet_accumulator_include_test.cpp | 2 +-
tests/packet_accumulator_test.cpp | 211 ++-
tests/parser_include_test.cpp | 3 +-
tests/parser_test.cpp | 1355 +++++++++--------
tests/test_util.h | 43 +
24 files changed, 1660 insertions(+), 1607 deletions(-)
delete mode 100644 src/dsmr_parser/aes128gcm.h
create mode 100644 src/dsmr_parser/decryption/aes128gcm.h
rename src/dsmr_parser/{ => decryption}/aes128gcm_bearssl.h (55%)
rename src/dsmr_parser/{ => decryption}/aes128gcm_mbedtls.h (53%)
create mode 100644 src/dsmr_parser/decryption/aes128gcm_tfpsa.h
rename tests/{ => decryption}/aes128gcm_bearssl_include_test.cpp (70%)
rename tests/{ => decryption}/aes128gcm_mbedtls_include_test.cpp (70%)
create mode 100644 tests/decryption/aes128gcm_tfpsa_include_test.cpp
create mode 100644 tests/test_util.h
diff --git a/README.md b/README.md
index e57d7b5..ef0f4e5 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,10 @@ The primary goal is to make the parser independent of the Arduino framework and
* Combines all fixes from [matthijskooijman/arduino-dsmr](https://github.com/matthijskooijman/arduino-dsmr) and [glmnet/arduino-dsmr](https://github.com/glmnet/arduino-dsmr) including unmerged pull requests.
* Added an extensive unit test suite
* Code optimizations
+* No dynamic memory allocations
* Supported compilers: MSVC, GCC, Clang
* Header-only library, no dependencies
-* Code can be used on any platform, not only embedded.
+* Code can be used on any platform, not only embedded
# Differences from the original arduino-dsmr
* Requires a C++20 compatible compiler.
@@ -17,20 +18,19 @@ The primary goal is to make the parser independent of the Arduino framework and
# How to use
## General usage
The library is header-only. Add the `src/dsmr_parser` folder to your project.
-Note: [dlms_packet_decryptor.h](https://github.com/esphome-libs/dsmr_parser/blob/main/src/dsmr_parser/dlms_packet_decryptor.h) depends on [Mbed TLS](https://www.trustedfirmware.org/projects/mbed-tls/) or [BearSsl](https://bearssl.org/) library. `Mbed TLS` is already included in the `ESP-IDF` framework and can be easily added to any other platforms.
+Note: [dlms_packet_decryptor.h](https://github.com/esphome-libs/dsmr_parser/blob/main/src/dsmr_parser/dlms_packet_decryptor.h) requires one of the encryption libraries: [TF-PSA](https://github.com/Mbed-TLS/TF-PSA-Crypto), [Mbed TLS](https://github.com/Mbed-TLS/mbedtls) or [BearSsl](https://bearssl.org/).
## Usage from PlatformIO
The library is available on the PlatformIO registry:
[esphome/dsmr_parser](https://registry.platformio.org/libraries/esphome/dsmr_parser)
# Examples
-* How to use the parser
- * [minimal_parse.ino](https://github.com/matthijskooijman/arduino-dsmr/blob/master/examples/minimal_parse/minimal_parse.ino)
- * [parse.ino](https://github.com/matthijskooijman/arduino-dsmr/blob/master/examples/parse/parse.ino)
* Complete example using PacketAccumulator
* [packet_accumulator_example_test.cpp](https://github.com/esphome-libs/dsmr_parser/blob/main/src/test/packet_accumulator_example_test.cpp)
* Example using DlmsPacketDecryptor
* [dlms_packet_decryptor_example_test.cpp](https://github.com/esphome-libs/dsmr_parser/blob/main/src/test/dlms_packet_decryptor_example_test.cpp)
+* Usage in EspHome project
+ * [DSMR component](https://github.com/esphome/esphome/tree/dev/esphome/components/dsmr)
# History behind arduino-dsmr
[matthijskooijman](https://github.com/matthijskooijman) is the original creator of this DSMR parser.
diff --git a/library.json b/library.json
index 8903635..f0f2eb6 100644
--- a/library.json
+++ b/library.json
@@ -1,6 +1,6 @@
{
"name": "dsmr_parser",
- "version": "1.2.0",
+ "version": "1.3.0",
"description": "A parser for Dutch Smart Meter Requirements (DSMR) telegrams. Fork of arduino-dsmr. Doesn't depend on the Arduino framework and has many bug fixes and code quality improvements. Supports encrypted DSMR packets.",
"keywords": "dsmr",
"repository": {
diff --git a/src/dsmr_parser/aes128gcm.h b/src/dsmr_parser/aes128gcm.h
deleted file mode 100644
index ce11599..0000000
--- a/src/dsmr_parser/aes128gcm.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-#include "util.h"
-#include
-
-namespace dsmr_parser {
-
-class Aes128GcmEncryptionKey final {
- std::array key{};
-
- Aes128GcmEncryptionKey() = default;
-
-public:
- // key_hex is a string like "00112233445566778899AABBCCDDEEFF"
- static std::optional from_hex(std::string_view key_hex) {
- if (key_hex.size() != 32) {
- return {};
- }
-
- Aes128GcmEncryptionKey res;
-
- for (size_t i = 0; i < 16; ++i) {
- const auto hi = to_hex_value(key_hex[2 * i]);
- const auto lo = to_hex_value(key_hex[2 * i + 1]);
- if (!hi || !lo) {
- return {};
- }
- res.key[i] = static_cast((*hi << 4) | *lo);
- }
-
- return res;
- }
-
- const uint8_t* data() const { return key.data(); }
-
-private:
- static std::optional to_hex_value(const char c) {
- if (c >= '0' && c <= '9')
- return static_cast(c - '0');
- if (c >= 'a' && c <= 'f')
- return static_cast(c - 'a' + 10);
- if (c >= 'A' && c <= 'F')
- return static_cast(c - 'A' + 10);
- return {};
- }
-};
-
-}
diff --git a/src/dsmr_parser/decryption/aes128gcm.h b/src/dsmr_parser/decryption/aes128gcm.h
new file mode 100644
index 0000000..9896f92
--- /dev/null
+++ b/src/dsmr_parser/decryption/aes128gcm.h
@@ -0,0 +1,41 @@
+#pragma once
+#include "../util.h"
+#include
+#include
+#include
+
+namespace dsmr_parser {
+
+class Aes128GcmDecryptionKey final {
+ std::array key{};
+ explicit Aes128GcmDecryptionKey(const std::array k) : key(k) {}
+
+public:
+ // hex is a string like "00112233445566778899AABBCCDDEEFF"
+ static std::optional from_hex(const std::string_view hex) {
+ if (hex.size() != 32)
+ return std::nullopt;
+ std::array arr{};
+ for (size_t i = 0; i < 16; ++i) {
+ auto [ptr, ec] = std::from_chars(hex.data() + i * 2, hex.data() + i * 2 + 2, arr[i], 16);
+ if (ec != std::errc{})
+ return std::nullopt;
+ }
+ return Aes128GcmDecryptionKey(arr);
+ }
+
+ const uint8_t* data() const { return key.data(); }
+};
+
+class Aes128GcmDecryptor {
+public:
+ virtual void set_encryption_key(const Aes128GcmDecryptionKey& key) = 0;
+ virtual bool decrypt_inplace(std::span aad, std::span nonce, std::span ciphertext,
+ std::span tag) = 0;
+
+protected:
+ virtual ~Aes128GcmDecryptor() = default;
+ std::optional decryption_key_;
+};
+
+}
diff --git a/src/dsmr_parser/aes128gcm_bearssl.h b/src/dsmr_parser/decryption/aes128gcm_bearssl.h
similarity index 55%
rename from src/dsmr_parser/aes128gcm_bearssl.h
rename to src/dsmr_parser/decryption/aes128gcm_bearssl.h
index 3663992..5beedea 100644
--- a/src/dsmr_parser/aes128gcm_bearssl.h
+++ b/src/dsmr_parser/decryption/aes128gcm_bearssl.h
@@ -1,12 +1,20 @@
#pragma once
-#include "aes128gcm.h"
-#include "util.h"
+
+#if __has_include()
+#include
+#elif __has_include()
#include
+#else
+#error "BearSSL header not found"
+#endif
+
+#include "../util.h"
+#include "aes128gcm.h"
#include
namespace dsmr_parser {
-class Aes128GcmBearSsl final : NonCopyableAndNonMovable {
+class Aes128GcmBearSsl final : public Aes128GcmDecryptor, NonCopyableAndNonMovable {
br_gcm_context gcm;
br_aes_ct_ctr_keys aes;
bool initialized = false;
@@ -14,14 +22,14 @@ class Aes128GcmBearSsl final : NonCopyableAndNonMovable {
public:
Aes128GcmBearSsl() = default;
- void set_encryption_key(const Aes128GcmEncryptionKey& key) {
+ void set_encryption_key(const Aes128GcmDecryptionKey& key) override {
br_aes_ct_ctr_init(&aes, key.data(), 16);
br_gcm_init(&gcm, &aes.vtable, br_ghash_ctmul32);
initialized = true;
}
- bool decrypt_inplace(const std::array& aad, const std::array& nonce, std::span ciphertext,
- const std::array& tag) {
+ bool decrypt_inplace(std::span aad, std::span nonce, std::span ciphertext,
+ std::span tag) override {
if (!initialized) {
return false;
}
diff --git a/src/dsmr_parser/aes128gcm_mbedtls.h b/src/dsmr_parser/decryption/aes128gcm_mbedtls.h
similarity index 53%
rename from src/dsmr_parser/aes128gcm_mbedtls.h
rename to src/dsmr_parser/decryption/aes128gcm_mbedtls.h
index 9295274..9af225d 100644
--- a/src/dsmr_parser/aes128gcm_mbedtls.h
+++ b/src/dsmr_parser/decryption/aes128gcm_mbedtls.h
@@ -1,21 +1,21 @@
#pragma once
+#include "../util.h"
#include "aes128gcm.h"
-#include "util.h"
#include
#include
namespace dsmr_parser {
-class Aes128GcmMbedTls final : NonCopyableAndNonMovable {
+class Aes128GcmMbedTls final : public Aes128GcmDecryptor, NonCopyableAndNonMovable {
mbedtls_gcm_context gcm;
public:
Aes128GcmMbedTls() { mbedtls_gcm_init(&gcm); }
- void set_encryption_key(const Aes128GcmEncryptionKey& key) { mbedtls_gcm_setkey(&gcm, MBEDTLS_CIPHER_ID_AES, key.data(), 128); }
+ void set_encryption_key(const Aes128GcmDecryptionKey& key) override { mbedtls_gcm_setkey(&gcm, MBEDTLS_CIPHER_ID_AES, key.data(), 128); }
- bool decrypt_inplace(const std::array& aad, const std::array& nonce, std::span ciphertext,
- const std::array& tag) {
+ bool decrypt_inplace(std::span aad, std::span nonce, std::span ciphertext,
+ std::span tag) override {
const auto& res = mbedtls_gcm_auth_decrypt(&gcm, ciphertext.size(), nonce.data(), nonce.size(), aad.data(), aad.size(), tag.data(), tag.size(),
ciphertext.data(), ciphertext.data());
return res == 0;
diff --git a/src/dsmr_parser/decryption/aes128gcm_tfpsa.h b/src/dsmr_parser/decryption/aes128gcm_tfpsa.h
new file mode 100644
index 0000000..f7f7d2c
--- /dev/null
+++ b/src/dsmr_parser/decryption/aes128gcm_tfpsa.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include "../util.h"
+#include "aes128gcm.h"
+#include
+#include
+
+namespace dsmr_parser {
+
+class Aes128GcmTfPsa final : public Aes128GcmDecryptor, NonCopyableAndNonMovable {
+ psa_key_id_t key_id = 0;
+ bool initialized = false;
+
+public:
+ Aes128GcmTfPsa() { initialized = (psa_crypto_init() == PSA_SUCCESS); }
+
+ void set_encryption_key(const Aes128GcmDecryptionKey& key) override {
+ if (!initialized) {
+ return;
+ }
+
+ if (key_id != 0) {
+ psa_destroy_key(key_id);
+ key_id = 0;
+ }
+
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
+ psa_set_key_bits(&attributes, 128);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 12));
+
+ const psa_status_t status = psa_import_key(&attributes, key.data(), 16, &key_id);
+
+ psa_reset_key_attributes(&attributes);
+
+ if (status != PSA_SUCCESS) {
+ key_id = 0;
+ }
+ }
+
+ bool decrypt_inplace(std::span aad, std::span nonce, std::span ciphertext,
+ std::span tag) override {
+ if (!initialized || key_id == 0) {
+ return false;
+ }
+
+ psa_aead_operation_t op = PSA_AEAD_OPERATION_INIT;
+ size_t out_len = 0;
+ size_t tail_len = 0;
+
+ psa_status_t status = psa_aead_decrypt_setup(&op, key_id, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, tag.size()));
+ if (status != PSA_SUCCESS) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ status = psa_aead_set_nonce(&op, nonce.data(), nonce.size());
+ if (status != PSA_SUCCESS) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ status = psa_aead_update_ad(&op, aad.data(), aad.size());
+ if (status != PSA_SUCCESS) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ status = psa_aead_update(&op, ciphertext.data(), ciphertext.size(), ciphertext.data(), ciphertext.size(), &out_len);
+ if (status != PSA_SUCCESS || out_len != ciphertext.size()) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ status = psa_aead_verify(&op, nullptr, 0, &tail_len, tag.data(), tag.size());
+
+ if (status != PSA_SUCCESS) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ if (tail_len != 0) {
+ psa_aead_abort(&op);
+ return false;
+ }
+
+ return true;
+ }
+
+ ~Aes128GcmTfPsa() {
+ if (key_id != 0) {
+ psa_destroy_key(key_id);
+ }
+ }
+};
+
+} // namespace dsmr_parser
diff --git a/src/dsmr_parser/dlms_packet_decryptor.h b/src/dsmr_parser/dlms_packet_decryptor.h
index f984b9c..3e26d7f 100644
--- a/src/dsmr_parser/dlms_packet_decryptor.h
+++ b/src/dsmr_parser/dlms_packet_decryptor.h
@@ -1,8 +1,10 @@
#pragma once
-#include "aes128gcm.h"
+#include "decryption/aes128gcm.h"
+#include "packet_accumulator.h"
#include "util.h"
#include
#include
+#include
#include
#include
#include
@@ -11,13 +13,12 @@ namespace dsmr_parser {
// Decrypts DLMS packets encrypted with AES-128-GCM.
// The encryption is described in the "specs/Luxembourg Smarty P1 specification v1.1.3.pdf" chapter "3.2.5 P1 software – Channel security".
-template
-class DlmsPacketDecryptor final {
+class DlmsPacketDecryptor final : NonCopyableAndNonMovable {
#pragma pack(push, 1)
// The packet has the following structure:
// Header (18 bytes) | Encrypted Telegram | GCM Tag (12 bytes)
- struct DlmsPacket final {
+ struct DlmsPacket final : NonCopyableAndNonMovable {
private:
struct {
uint8_t tag; // always = 0xDB
@@ -33,15 +34,26 @@ class DlmsPacketDecryptor final {
public:
static DlmsPacket* from_bytes(const std::span bytes) {
if (bytes.size() < sizeof(header) + /* tag length */ 12) {
+ Logger::log(LogLevel::DEBUG, "DLMS packet is too short. Size: %zu", bytes.size());
return nullptr;
}
auto& packet = *reinterpret_cast(bytes.data());
+ const auto expected_length = sizeof(header) + /* tag length */ 12 + packet.telegram_length();
+ if (expected_length != bytes.size()) {
+ Logger::log(LogLevel::DEBUG, "DLMS packet length mismatch. Expected: %zu, actual: %zu", expected_length, bytes.size());
+ return nullptr;
+ }
+
+ if (packet.telegram_length() < 10) {
+ Logger::log(LogLevel::DEBUG, "DLMS encrypted telegram is too short. Size: %zu", packet.telegram_length());
+ return nullptr;
+ }
- const auto& length_correct = bytes.size() == sizeof(header) + /* tag length */ 12 + packet.telegram_length();
- const auto& header_bytes_consistent = packet.header.tag == 0xDB && packet.header.system_title_length == 0x08 &&
- packet.header.long_form_length_indicator == 0x82 && packet.header.security_control_field == 0x30;
- if (!length_correct || !header_bytes_consistent) {
+ const auto header_bytes_consistent = packet.header.tag == 0xDB && packet.header.system_title_length == 0x08 &&
+ packet.header.long_form_length_indicator == 0x82 && packet.header.security_control_field == 0x30;
+ if (!header_bytes_consistent) {
+ Logger::log(LogLevel::DEBUG, "DLMS packet header is corrupted");
return nullptr;
}
@@ -49,7 +61,7 @@ class DlmsPacketDecryptor final {
}
// Also called "IV"
- std::array nonce() const {
+ std::array nonce() const {
// nonce = SystemTitle (8 bytes) + InvocationCounter (4 bytes)
const auto& st = header.system_title;
const auto& ic = header.invocation_counter_big_endian;
@@ -57,10 +69,8 @@ class DlmsPacketDecryptor final {
}
std::span encrypted_telegram() { return {encrypted_telegram_with_gcm_tag, telegram_length()}; }
- std::array gcm_tag() const {
- const uint8_t* p = encrypted_telegram_with_gcm_tag + telegram_length();
- return {p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11]};
- }
+
+ std::span gcm_tag() const { return std::span{encrypted_telegram_with_gcm_tag + telegram_length(), 12}; }
private:
// encrypted and decrypted telegrams have the same length
@@ -73,28 +83,63 @@ class DlmsPacketDecryptor final {
#pragma pack(pop)
static_assert(sizeof(DlmsPacket) == 19, "EncryptedPacket struct must be 19 bytes");
- Aes128Gcm decryptor;
+ Aes128GcmDecryptor& decryptor;
+
+ static void log_span_as_hex(const LogLevel level, const std::span data) {
+ constexpr size_t kCharsPerChunk = 200;
+ constexpr size_t kBytesPerChunk = kCharsPerChunk / 2;
+ for (size_t i = 0; i < data.size(); i += kBytesPerChunk) {
+ char hex[kCharsPerChunk + 1];
+ const size_t n = std::min(kBytesPerChunk, data.size() - i);
+ for (size_t j = 0; j < n; ++j) {
+ constexpr char kHex[] = "0123456789ABCDEF";
+ hex[j * 2] = kHex[data[i + j] >> 4];
+ hex[j * 2 + 1] = kHex[data[i + j] & 0x0F];
+ }
+ hex[n * 2] = '\0';
+ Logger::log(level, "%s", hex);
+ }
+ }
public:
- void set_encryption_key(const Aes128GcmEncryptionKey& key) { decryptor.set_encryption_key(key); }
+ explicit DlmsPacketDecryptor(Aes128GcmDecryptor& dec) : decryptor(dec) {}
+
+ std::optional decrypt_inplace(std::span dlms_packet_bytes) {
+ Logger::log(LogLevel::VERY_VERBOSE, "Decrypt DLMS packet:");
+ log_span_as_hex(LogLevel::VERY_VERBOSE, dlms_packet_bytes);
+ Logger::log(LogLevel::VERY_VERBOSE, "=========");
- std::optional decrypt_inplace(std::span dlms_packet_bytes) {
auto dlms_packet = DlmsPacket::from_bytes(dlms_packet_bytes);
if (dlms_packet == nullptr) {
- return {};
+ return std::nullopt;
}
// aad = AdditionalAuthenticatedData = SecurityControlField + AuthenticationKey.
// SecurityControlField is always 0x30.
// AuthenticationKey = "00112233445566778899AABBCCDDEEFF". It is hardcoded and is the same for all DSMR devices.
- constexpr std::array aad{0x30, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
-
+ constexpr std::array aad{0x30, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
const bool res = decryptor.decrypt_inplace(aad, dlms_packet->nonce(), dlms_packet->encrypted_telegram(), dlms_packet->gcm_tag());
if (!res) {
- return {};
+ Logger::log(LogLevel::DEBUG, "Decryption of DLMS packet failed");
+ return std::nullopt;
}
- return std::string_view{reinterpret_cast(dlms_packet->encrypted_telegram().data()), dlms_packet->encrypted_telegram().size()};
+ // The unencrypted DSMR telegram looks like "/data!abcd\r\n". We skip everything after the "!" sign. The encryption already handles integrity check.
+ const auto telegram = std::string_view{reinterpret_cast(dlms_packet->encrypted_telegram().data()), dlms_packet->encrypted_telegram().size()};
+ if (telegram.front() != '/') {
+ Logger::log(LogLevel::DEBUG, "Unencrypted DSMR telegram should start with '/' character");
+ return std::nullopt;
+ }
+ const auto bangPos = std::ranges::find(telegram, '!');
+ if (bangPos == telegram.end()) {
+ Logger::log(LogLevel::DEBUG, "Unencrypted DSMR telegram should contain '!' character");
+ return std::nullopt;
+ }
+ const auto dsmrUnencryptedTelegram = std::string_view{telegram.begin(), bangPos + 1};
+
+ Logger::log(LogLevel::VERBOSE, "DLMS packet decryption succeeded");
+
+ return DsmrUnencryptedTelegram(dsmrUnencryptedTelegram);
}
};
diff --git a/src/dsmr_parser/fields.h b/src/dsmr_parser/fields.h
index 1a55650..c3bdb63 100644
--- a/src/dsmr_parser/fields.h
+++ b/src/dsmr_parser/fields.h
@@ -2,6 +2,8 @@
#include "parser.h"
#include "util.h"
+#include
+#include
#ifndef DSMR_GAS_MBUS_ID
#define DSMR_GAS_MBUS_ID 1
@@ -18,23 +20,22 @@
namespace dsmr_parser {
-// Superclass for data items in a P1 message.
template
struct ParsedField {
template
void apply(F& f) {
f.apply(*static_cast(this));
}
- // By defaults, fields have no unit
static const char* unit() noexcept { return ""; }
};
template
struct StringField : ParsedField {
- ParseResult parse(const char* str, const char* end) {
- ParseResult res = StringParser::parse_string(minlen, maxlen, str, end);
- if (!res.err)
- static_cast(this)->val() = res.result;
+ std::optional parse(std::string_view input) {
+ std::string_view sv;
+ auto res = parse_string(sv, minlen, maxlen, input);
+ if (res)
+ static_cast(this)->val() = sv;
return res;
}
};
@@ -70,13 +71,14 @@ struct FixedValue {
// integer unit is passed as a template argument.
template
struct FixedField : ParsedField {
- ParseResult parse(const char* str, const char* end) {
+ std::optional parse(std::string_view input) {
// Some smart meters publish int values instead of a float.
// E.g. most meters would publish "1-0:1.8.0(000441.879*kWh)",
// but some use "1-0:1.8.0(000441879*Wh)" instead.
- auto res = NumParser::parse_float_or_int(3, _unit, _int_unit, str, end);
- if (!res.err)
- static_cast(this)->val()._value = res.result;
+ int32_t val;
+ auto res = parse_float_or_int(val, 3, _unit, _int_unit, input);
+ if (res)
+ static_cast(this)->val()._value = val;
return res;
}
@@ -85,60 +87,51 @@ struct FixedField : ParsedField {
};
struct TimestampedFixedValue : public FixedValue {
- std::string timestamp;
+ std::string_view timestamp;
};
// Some numerical values are prefixed with a timestamp. This is simply
// both of them concatenated, e.g. 0-1:24.2.1(150117180000W)(00473.789*m3)
template
struct TimestampedFixedField : public FixedField {
- ParseResult parse(const char* str, const char* end) {
- // First, parse timestamp
- ParseResult res = StringParser::parse_string(13, 13, str, end);
- if (res.err)
- return res;
-
- static_cast(this)->val().timestamp = res.result;
-
- // Which is immediately followed by the numerical value
- return FixedField::parse(res.next, end);
+ std::optional parse(std::string_view input) {
+ std::string_view ts;
+ auto res = parse_string(ts, 13, 13, input);
+ if (!res)
+ return std::nullopt;
+ static_cast(this)->val().timestamp = ts;
+ return FixedField::parse(*res);
}
};
-// Take the last value of multiple values
+// Take the last value of multiple parenthesized values
// e.g. 0-0:98.1.0(1)(1-0:1.6.0)(1-0:1.6.0)(230201000000W)(230117224500W)(04.329*kW)
template
struct LastFixedField : public FixedField {
- ParseResult parse(const char* str, const char* end) {
- // we parse last entry 2 times
- const char* last = end;
-
- ParseResult res;
- res.next = str;
-
- while (res.next != end) {
- last = res.next;
- res = StringParser::parse_string(1, 20, res.next, end);
- if (res.err)
- return res;
+ std::optional parse(std::string_view input) {
+ std::string_view last = input;
+ std::string_view remaining = input;
+ while (!remaining.empty()) {
+ last = remaining;
+ std::string_view sv;
+ auto res = parse_string(sv, 1, 20, remaining);
+ if (!res)
+ return std::nullopt;
+ remaining = *res;
}
-
- // (04.329*kW) Which is followed by the numerical value
- return FixedField::parse(last, end);
+ return FixedField::parse(last);
}
};
// A integer number is just represented as an integer.
template
struct IntField : ParsedField {
- ParseResult parse(const char* str, const char* end) {
- ParseResult res = NumParser::parse(0, _unit, str, end);
- if (!res.err) {
+ std::optional parse(std::string_view input) {
+ int32_t val;
+ auto res = parse_num(val, 0, _unit, input);
+ if (res) {
auto& dst = static_cast(this)->val();
- using Dst = std::remove_reference_t;
-
- // Narrow conversion. It is possible to loose data here
- dst = static_cast(res.result);
+ dst = static_cast>(val);
}
return res;
}
@@ -146,71 +139,56 @@ struct IntField : ParsedField {
static const char* unit() noexcept { return _unit; }
};
-// Take the average value of multiple values. Example:
+// Take the average of multiple timestamped values. Example:
// 0-0:98.1.0(2)(1-0:1.6.0)(1-0:1.6.0)(230201000000W)(230117224500W)(04.329*kW)(230202000000W)(230214224500W)(04.529*kW)
// Will produce an average between 4.329 and 4.529
template
struct AveragedFixedField : public FixedField {
- ParseResult parse(const char* str, const char* end) {
- // get the number of values that are available in the data
- auto numberOfValues = NumParser::parse(0, "", str, end);
- if (numberOfValues.err) {
- return numberOfValues;
- }
+ std::optional parse(std::string_view input) {
+ int32_t count;
+ auto res = parse_num(count, 0, "", input);
+ if (!res)
+ return std::nullopt;
- if (numberOfValues.result == 0) {
- numberOfValues.next = end; // mark that we consumed all input
+ if (count == 0) {
static_cast(this)->val()._value = 0;
- return numberOfValues;
+ return std::string_view{};
}
- // Skip (1-0:1.6.0)
- auto res = StringParser::parse_string(1, 20, numberOfValues.next, end);
- if (res.err)
- return res;
-
- // Skip another (1-0:1.6.0)
- res = StringParser::parse_string(1, 20, res.next, end);
- if (res.err)
- return res;
-
- ParseResult average;
- average.succeed(0);
- average.next = res.next;
- for (int32_t i = 0; i < numberOfValues.result; i++) {
- // skip date (230201000000W)
- res = StringParser::parse_string(1, 20, average.next, end);
- if (res.err)
- return res;
-
- // skip second date (230117224500W)
- res = StringParser::parse_string(1, 20, res.next, end);
- if (res.err)
- return res;
-
- // parse value (04.329*kW) or (04329*W)
- auto monthValue = NumParser::parse_float_or_int(3, _unit, _int_unit, res.next, end);
- if (monthValue.err)
- return monthValue;
-
- average.next = monthValue.next;
- average.result += monthValue.result;
+ std::string_view sv;
+ res = parse_string(sv, 1, 20, *res);
+ if (!res)
+ return std::nullopt;
+ res = parse_string(sv, 1, 20, *res);
+ if (!res)
+ return std::nullopt;
+
+ int32_t total = 0;
+ for (int32_t i = 0; i < count; i++) {
+ res = parse_string(sv, 1, 20, *res);
+ if (!res)
+ return std::nullopt;
+ res = parse_string(sv, 1, 20, *res);
+ if (!res)
+ return std::nullopt;
+ int32_t val;
+ res = parse_float_or_int(val, 3, _unit, _int_unit, *res);
+ if (!res)
+ return std::nullopt;
+ total += val;
}
- average.result /= numberOfValues.result;
- static_cast(this)->val()._value = average.result;
-
- return average;
+ static_cast(this)->val()._value = total / count;
+ return res;
}
};
-// A RawField is not parsed, the entire value (including any parenthesis around it) is returned as a string.
+// Raw field — no parsing, just store the entire value, including any parenthesis around it, as a string_view
template
struct RawField : ParsedField {
- ParseResult parse(const char* str, const char* end) {
- // Just copy the string verbatim value without any parsing
- static_cast(this)->val().append(str, static_cast(end - str));
- return ParseResult().until(end);
+ std::optional parse(std::string_view input) {
+ static_cast(this)->val() = input;
+ return std::string_view{};
}
};
@@ -242,11 +220,6 @@ struct units final {
static inline constexpr char kHz[] = "kHz";
};
-const uint8_t GAS_MBUS_ID = DSMR_GAS_MBUS_ID;
-const uint8_t WATER_MBUS_ID = DSMR_WATER_MBUS_ID;
-const uint8_t THERMAL_MBUS_ID = DSMR_THERMAL_MBUS_ID;
-const uint8_t SUB_MBUS_ID = DSMR_SUB_MBUS_ID;
-
#define DEFINE_FIELD(fieldname, value_t, obis, field_t, ...) \
struct fieldname : field_t { \
value_t fieldname; \
@@ -258,17 +231,17 @@ const uint8_t SUB_MBUS_ID = DSMR_SUB_MBUS_ID;
}
// Meter identification. This is not a normal field, but a specially-formatted first line of the message
-DEFINE_FIELD(identification, std::string, ObisId(255, 255, 255, 255, 255, 255), RawField);
+DEFINE_FIELD(identification, std::string_view, ObisId(255, 255, 255, 255, 255, 255), RawField);
// Version information for P1 output
-DEFINE_FIELD(p1_version, std::string, ObisId(1, 3, 0, 2, 8), StringField, 2, 2);
-DEFINE_FIELD(p1_version_be, std::string, ObisId(0, 0, 96, 1, 4), StringField, 2, 96);
+DEFINE_FIELD(p1_version, std::string_view, ObisId(1, 3, 0, 2, 8), StringField, 2, 2);
+DEFINE_FIELD(p1_version_be, std::string_view, ObisId(0, 0, 96, 1, 4), StringField, 2, 96);
// Date-time stamp of the P1 message
-DEFINE_FIELD(timestamp, std::string, ObisId(0, 0, 1, 0, 0), TimestampField);
+DEFINE_FIELD(timestamp, std::string_view, ObisId(0, 0, 1, 0, 0), TimestampField);
// Equipment identifier
-DEFINE_FIELD(equipment_id, std::string, ObisId(0, 0, 96, 1, 1), StringField, 0, 96);
+DEFINE_FIELD(equipment_id, std::string_view, ObisId(0, 0, 96, 1, 1), StringField, 0, 96);
// Meter Reading electricity delivered to client (Special for Lux) in 0,001 kWh
// TODO: by OBIS 1-0:1.8.0.255 IEC 62056 it should be Positive active energy (A+) total [kWh], should we rename it?
@@ -324,10 +297,28 @@ DEFINE_FIELD(energy_returned_tariff1_ch, FixedValue, ObisId(1, 1, 2, 8, 1), Fixe
// Meter Reading electricity delivered by client (Tariff 2) in 0,001 kWh
DEFINE_FIELD(energy_returned_tariff2_ch, FixedValue, ObisId(1, 1, 2, 8, 2), FixedField, units::kWh, units::Wh);
+// Specific fields used for Israel
+// Meter Reading electricity delivered to client (Tariff 1) in 0,001 kWh
+DEFINE_FIELD(energy_delivered_tariff1_il, FixedValue, ObisId(1, 0, 1, 8, 11), FixedField, units::kWh, units::Wh);
+// Meter Reading electricity delivered to client (Tariff 2) in 0,001 kWh
+DEFINE_FIELD(energy_delivered_tariff2_il, FixedValue, ObisId(1, 0, 1, 8, 12), FixedField, units::kWh, units::Wh);
+// Meter Reading electricity delivered to client (Tariff 3) in 0,001 kWh
+DEFINE_FIELD(energy_delivered_tariff3_il, FixedValue, ObisId(1, 0, 1, 8, 13), FixedField, units::kWh, units::Wh);
+// Meter Reading electricity delivered by client (Tariff 1) in 0,001 kWh
+DEFINE_FIELD(energy_returned_tariff1_il, FixedValue, ObisId(1, 0, 2, 8, 11), FixedField, units::kWh, units::Wh);
+// Meter Reading electricity delivered by client (Tariff 2) in 0,001 kWh
+DEFINE_FIELD(energy_returned_tariff2_il, FixedValue, ObisId(1, 0, 2, 8, 12), FixedField, units::kWh, units::Wh);
+// Meter Reading electricity delivered by client (Tariff 3) in 0,001 kWh
+DEFINE_FIELD(energy_returned_tariff3_il, FixedValue, ObisId(1, 0, 2, 8, 13), FixedField, units::kWh, units::Wh);
+// Tariff indicator electricity.
+DEFINE_FIELD(electricity_tariff_il, std::string_view, ObisId(0, 0, 96, 14, 1), StringField, 2, 2);
+// Power Failure Event Log (long power failures)
+DEFINE_FIELD(electricity_failure_log_il, std::string_view, ObisId(1, 0, 99, 1, 0), RawField);
+
// Tariff indicator electricity. The tariff indicator can also be used
// to switch tariff dependent loads e.g boilers. This is the
// responsibility of the P1 user
-DEFINE_FIELD(electricity_tariff, std::string, ObisId(0, 0, 96, 14, 0), StringField, 4, 4);
+DEFINE_FIELD(electricity_tariff, std::string_view, ObisId(0, 0, 96, 14, 0), StringField, 4, 4);
// Actual electricity power delivered (+P) in 1 Watt resolution
DEFINE_FIELD(power_delivered, FixedValue, ObisId(1, 0, 1, 7, 0), FixedField, units::kW, units::W);
@@ -356,7 +347,7 @@ DEFINE_FIELD(electricity_failures, uint32_t, ObisId(0, 0, 96, 7, 21), IntField,
DEFINE_FIELD(electricity_long_failures, uint32_t, ObisId(0, 0, 96, 7, 9), IntField, units::none);
// Power Failure Event Log (long power failures)
-DEFINE_FIELD(electricity_failure_log, std::string, ObisId(1, 0, 99, 97, 0), RawField);
+DEFINE_FIELD(electricity_failure_log, std::string_view, ObisId(1, 0, 99, 97, 0), RawField);
// Number of voltage sags in phase L1
DEFINE_FIELD(electricity_sags_l1, uint32_t, ObisId(1, 0, 32, 32, 0), IntField, units::none);
@@ -389,10 +380,10 @@ DEFINE_FIELD(voltage_swell_time_l3, uint32_t, ObisId(1, 0, 72, 37, 0), IntField,
DEFINE_FIELD(voltage_swell_l3, uint32_t, ObisId(1, 0, 72, 38, 0), IntField, units::V);
// Text message codes: numeric 8 digits (Note: Missing from 5.0 spec)
-DEFINE_FIELD(message_short, std::string, ObisId(0, 0, 96, 13, 1), StringField, 0, 16);
+DEFINE_FIELD(message_short, std::string_view, ObisId(0, 0, 96, 13, 1), StringField, 0, 16);
// Text message max 2048 characters (Note: Spec says 1024 in comment and
// 2048 in format spec, so we stick to 2048).
-DEFINE_FIELD(message_long, std::string, ObisId(0, 0, 96, 13, 0), StringField, 0, 2048);
+DEFINE_FIELD(message_long, std::string_view, ObisId(0, 0, 96, 13, 0), StringField, 0, 2048);
// Instantaneous voltage L1 in 0.1V resolution (Note: Spec says V
// resolution in comment, but 0.1V resolution in format spec. Added in 5.0)
@@ -487,63 +478,63 @@ DEFINE_FIELD(active_demand_net, FixedValue, ObisId(1, 0, 16, 24, 0), FixedField,
DEFINE_FIELD(active_demand_abs, FixedValue, ObisId(1, 0, 15, 24, 0), FixedField, units::kW, units::W);
// Device-Type
-DEFINE_FIELD(gas_device_type, uint16_t, ObisId(0, GAS_MBUS_ID, 24, 1, 0), IntField, units::none);
+DEFINE_FIELD(gas_device_type, uint16_t, ObisId(0, DSMR_GAS_MBUS_ID, 24, 1, 0), IntField, units::none);
// Equipment identifier (Gas)
-DEFINE_FIELD(gas_equipment_id, std::string, ObisId(0, GAS_MBUS_ID, 96, 1, 0), StringField, 0, 96);
+DEFINE_FIELD(gas_equipment_id, std::string_view, ObisId(0, DSMR_GAS_MBUS_ID, 96, 1, 0), StringField, 0, 96);
// Equipment identifier (Gas) BE
-DEFINE_FIELD(gas_equipment_id_be, std::string, ObisId(0, GAS_MBUS_ID, 96, 1, 1), StringField, 0, 96);
+DEFINE_FIELD(gas_equipment_id_be, std::string_view, ObisId(0, DSMR_GAS_MBUS_ID, 96, 1, 1), StringField, 0, 96);
// Valve position Gas (on/off/released) (Note: Removed in 4.0.7 / 4.2.2 / 5.0).
-DEFINE_FIELD(gas_valve_position, uint8_t, ObisId(0, GAS_MBUS_ID, 24, 4, 0), IntField, units::none);
+DEFINE_FIELD(gas_valve_position, uint8_t, ObisId(0, DSMR_GAS_MBUS_ID, 24, 4, 0), IntField, units::none);
// Last 5-minute value (temperature converted), gas delivered to client
// in m3, including decimal values and capture time (Note: 4.x spec has "hourly value")
-DEFINE_FIELD(gas_delivered, TimestampedFixedValue, ObisId(0, GAS_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
+DEFINE_FIELD(gas_delivered, TimestampedFixedValue, ObisId(0, DSMR_GAS_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
// Eneco in the Netherlands has smart meters for their district heating network, which uses the gas_delivered in GJ rather than m3
-DEFINE_FIELD(gas_delivered_gj, TimestampedFixedValue, ObisId(0, GAS_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::GJ, units::MJ);
+DEFINE_FIELD(gas_delivered_gj, TimestampedFixedValue, ObisId(0, DSMR_GAS_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::GJ, units::MJ);
// _BE
-DEFINE_FIELD(gas_delivered_be, TimestampedFixedValue, ObisId(0, GAS_MBUS_ID, 24, 2, 3), TimestampedFixedField, units::m3, units::dm3);
-DEFINE_FIELD(gas_delivered_text, std::string, ObisId(0, GAS_MBUS_ID, 24, 3, 0), RawField);
+DEFINE_FIELD(gas_delivered_be, TimestampedFixedValue, ObisId(0, DSMR_GAS_MBUS_ID, 24, 2, 3), TimestampedFixedField, units::m3, units::dm3);
+DEFINE_FIELD(gas_delivered_text, std::string_view, ObisId(0, DSMR_GAS_MBUS_ID, 24, 3, 0), RawField);
// Device-Type
-DEFINE_FIELD(thermal_device_type, uint16_t, ObisId(0, THERMAL_MBUS_ID, 24, 1, 0), IntField, units::none);
+DEFINE_FIELD(thermal_device_type, uint16_t, ObisId(0, DSMR_THERMAL_MBUS_ID, 24, 1, 0), IntField, units::none);
// Equipment identifier (Thermal: heat or cold)
-DEFINE_FIELD(thermal_equipment_id, std::string, ObisId(0, THERMAL_MBUS_ID, 96, 1, 0), StringField, 0, 96);
+DEFINE_FIELD(thermal_equipment_id, std::string_view, ObisId(0, DSMR_THERMAL_MBUS_ID, 96, 1, 0), StringField, 0, 96);
// Valve position (on/off/released) (Note: Removed in 4.0.7 / 4.2.2 / 5.0).
-DEFINE_FIELD(thermal_valve_position, uint8_t, ObisId(0, THERMAL_MBUS_ID, 24, 4, 0), IntField, units::none);
+DEFINE_FIELD(thermal_valve_position, uint8_t, ObisId(0, DSMR_THERMAL_MBUS_ID, 24, 4, 0), IntField, units::none);
// Last 5-minute Meter reading Heat or Cold in 0,01 GJ and capture time
// (Note: 4.x spec has "hourly meter reading")
-DEFINE_FIELD(thermal_delivered, TimestampedFixedValue, ObisId(0, THERMAL_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::GJ, units::MJ);
+DEFINE_FIELD(thermal_delivered, TimestampedFixedValue, ObisId(0, DSMR_THERMAL_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::GJ, units::MJ);
// Device-Type
-DEFINE_FIELD(water_device_type, uint16_t, ObisId(0, WATER_MBUS_ID, 24, 1, 0), IntField, units::none);
+DEFINE_FIELD(water_device_type, uint16_t, ObisId(0, DSMR_WATER_MBUS_ID, 24, 1, 0), IntField, units::none);
// Equipment identifier (Thermal: heat or cold)
-DEFINE_FIELD(water_equipment_id, std::string, ObisId(0, WATER_MBUS_ID, 96, 1, 0), StringField, 0, 96);
+DEFINE_FIELD(water_equipment_id, std::string_view, ObisId(0, DSMR_WATER_MBUS_ID, 96, 1, 0), StringField, 0, 96);
// Valve position (on/off/released) (Note: Removed in 4.0.7 / 4.2.2 / 5.0).
-DEFINE_FIELD(water_valve_position, uint8_t, ObisId(0, WATER_MBUS_ID, 24, 4, 0), IntField, units::none);
+DEFINE_FIELD(water_valve_position, uint8_t, ObisId(0, DSMR_WATER_MBUS_ID, 24, 4, 0), IntField, units::none);
// Last 5-minute Meter reading in 0,001 m3 and capture time
// (Note: 4.x spec has "hourly meter reading")
-DEFINE_FIELD(water_delivered, TimestampedFixedValue, ObisId(0, WATER_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
+DEFINE_FIELD(water_delivered, TimestampedFixedValue, ObisId(0, DSMR_WATER_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
// Device-Type
-DEFINE_FIELD(sub_device_type, uint16_t, ObisId(0, SUB_MBUS_ID, 24, 1, 0), IntField, units::none);
+DEFINE_FIELD(sub_device_type, uint16_t, ObisId(0, DSMR_SUB_MBUS_ID, 24, 1, 0), IntField, units::none);
// Equipment identifier (Thermal: heat or cold)
-DEFINE_FIELD(sub_equipment_id, std::string, ObisId(0, SUB_MBUS_ID, 96, 1, 0), StringField, 0, 96);
+DEFINE_FIELD(sub_equipment_id, std::string_view, ObisId(0, DSMR_SUB_MBUS_ID, 96, 1, 0), StringField, 0, 96);
// Valve position (on/off/released) (Note: Removed in 4.0.7 / 4.2.2 / 5.0).
-DEFINE_FIELD(sub_valve_position, uint8_t, ObisId(0, SUB_MBUS_ID, 24, 4, 0), IntField, units::none);
+DEFINE_FIELD(sub_valve_position, uint8_t, ObisId(0, DSMR_SUB_MBUS_ID, 24, 4, 0), IntField, units::none);
// Last 5-minute Meter reading Heat or Cold and capture time (e.g. sub
// E meter) (Note: 4.x spec has "hourly meter reading")
-DEFINE_FIELD(sub_delivered, TimestampedFixedValue, ObisId(0, SUB_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
+DEFINE_FIELD(sub_delivered, TimestampedFixedValue, ObisId(0, DSMR_SUB_MBUS_ID, 24, 2, 1), TimestampedFixedField, units::m3, units::dm3);
// Extra fields used for Belgian capacity rate/peak consumption (cappaciteitstarief). Current quart-hourly energy consumption
DEFINE_FIELD(active_energy_import_current_average_demand, FixedValue, ObisId(1, 0, 1, 4, 0), FixedField, units::kW, units::W);
@@ -565,11 +556,11 @@ DEFINE_FIELD(active_energy_import_maximum_demand_running_month, TimestampedFixed
DEFINE_FIELD(active_energy_import_maximum_demand_last_13_months, FixedValue, ObisId(0, 0, 98, 1, 0), AveragedFixedField, units::kW, units::W);
// Image Core Version and checksum
-DEFINE_FIELD(fw_core_version, std::string, ObisId(1, 0, 0, 2, 0), StringField, 0, 96);
-DEFINE_FIELD(fw_core_checksum, std::string, ObisId(1, 0, 0, 2, 8), StringField, 0, 96);
+DEFINE_FIELD(fw_core_version, std::string_view, ObisId(1, 0, 0, 2, 0), StringField, 0, 96);
+DEFINE_FIELD(fw_core_checksum, std::string_view, ObisId(1, 0, 0, 2, 8), StringField, 0, 96);
// Image Module Version and checksum
-DEFINE_FIELD(fw_module_version, std::string, ObisId(1, 1, 0, 2, 0), StringField, 0, 96);
-DEFINE_FIELD(fw_module_checksum, std::string, ObisId(1, 1, 0, 2, 8), StringField, 0, 96);
+DEFINE_FIELD(fw_module_version, std::string_view, ObisId(1, 1, 0, 2, 0), StringField, 0, 96);
+DEFINE_FIELD(fw_module_checksum, std::string_view, ObisId(1, 1, 0, 2, 8), StringField, 0, 96);
// Instantaneous power factor
DEFINE_FIELD(power_factor, FixedValue, ObisId(1, 0, 13, 7, 0), FixedField, units::none, units::none);
diff --git a/src/dsmr_parser/packet_accumulator.h b/src/dsmr_parser/packet_accumulator.h
index df13b2a..a9cae84 100644
--- a/src/dsmr_parser/packet_accumulator.h
+++ b/src/dsmr_parser/packet_accumulator.h
@@ -10,15 +10,15 @@ namespace dsmr_parser {
// Receives unencrypted DSMR packets.
class PacketAccumulator final {
class DsmrPacketBuffer final {
- std::span _buffer;
+ std::span _buffer;
std::size_t _packetSize = 0;
public:
- explicit DsmrPacketBuffer(std::span buffer) : _buffer{buffer} {}
+ explicit DsmrPacketBuffer(std::span buffer) : _buffer{buffer} {}
- std::string_view packet() const { return std::string_view(_buffer.data(), _packetSize); }
+ std::string_view packet() const { return std::string_view(reinterpret_cast(_buffer.data()), _packetSize); }
- void add(char byte) {
+ void add(uint8_t byte) {
_buffer[_packetSize] = byte;
_packetSize++;
}
@@ -45,13 +45,13 @@ class PacketAccumulator final {
size_t amount_of_crc_nibbles = 0;
public:
- bool add_to_crc(char byte) {
+ bool add_to_crc(uint8_t byte) {
if (byte >= '0' && byte <= '9') {
byte = byte - '0';
} else if (byte >= 'A' && byte <= 'F') {
- byte = static_cast(byte - 'A' + 10);
+ byte = static_cast(byte - 'A' + 10);
} else if (byte >= 'a' && byte <= 'f') {
- byte = static_cast(byte - 'a' + 10);
+ byte = static_cast(byte - 'a' + 10);
} else {
return false;
}
@@ -68,115 +68,76 @@ class PacketAccumulator final {
enum class State { WaitingForPacketStartSymbol, WaitingForPacketEndSymbol, WaitingForCrc };
State _state = State::WaitingForPacketStartSymbol;
- std::span _raw_buffer;
+ std::span _raw_buffer;
DsmrPacketBuffer _buf;
CrcAccumulator _crc_accumulator;
bool _check_crc;
public:
- enum class Error {
- BufferOverflow,
- PacketStartSymbolInPacket,
- IncorrectCrcCharacter,
- CrcMismatch,
- };
-
- class Result final {
- friend class PacketAccumulator;
-
- std::optional _packet;
- std::optional _error;
-
- Result() = default;
- Result(std::string_view packet) : _packet(packet) {}
- Result(Error error) : _error(error) {}
-
- public:
- auto packet() const { return _packet; }
- auto error() const { return _error; }
- };
-
- PacketAccumulator(std::span buffer, bool check_crc) : _raw_buffer(buffer), _buf(buffer), _check_crc(check_crc) {}
+ PacketAccumulator(std::span buffer, bool check_crc) : _raw_buffer(buffer), _buf(buffer), _check_crc(check_crc) {}
- Result process_byte(const char byte) {
+ std::optional process_byte(const uint8_t byte) {
if (!_buf.has_space()) {
+ Logger::log(LogLevel::DEBUG, "Buffer overflow. Discarding the accumulated data");
_buf = DsmrPacketBuffer(_raw_buffer);
_state = State::WaitingForPacketStartSymbol;
- if (byte != '/') {
- return Error::BufferOverflow;
- }
}
if (byte == '/') {
+ Logger::log(LogLevel::VERBOSE, "Found telegram start symbol '/'");
_buf = DsmrPacketBuffer(_raw_buffer);
_buf.add(byte);
- const auto prev_state = _state;
_state = State::WaitingForPacketEndSymbol;
-
- if (prev_state == State::WaitingForPacketEndSymbol || prev_state == State::WaitingForCrc) {
- return Error::PacketStartSymbolInPacket;
- }
- return {};
+ return std::nullopt;
}
switch (_state) {
case State::WaitingForPacketStartSymbol:
- return {};
+ return std::nullopt;
case State::WaitingForPacketEndSymbol:
_buf.add(byte);
if (byte != '!') {
- return {};
+ return std::nullopt;
}
+ Logger::log(LogLevel::VERBOSE, "Found telegram end symbol '!'");
if (!_check_crc) {
_state = State::WaitingForPacketStartSymbol;
- return Result(_buf.packet());
+ Logger::log(LogLevel::VERBOSE, "Successfully received the telegram without CRC check");
+ return DsmrUnencryptedTelegram(_buf.packet());
}
_state = State::WaitingForCrc;
_crc_accumulator = CrcAccumulator();
- return {};
+ return std::nullopt;
case State::WaitingForCrc:
if (!_crc_accumulator.add_to_crc(byte)) {
+ Logger::log(LogLevel::DEBUG, "Incorrect CRC character '%c'", byte);
_state = State::WaitingForPacketStartSymbol;
- return Error::IncorrectCrcCharacter;
+ return std::nullopt;
}
if (!_crc_accumulator.has_full_crc()) {
- return {};
+ return std::nullopt;
}
_state = State::WaitingForPacketStartSymbol;
if (_crc_accumulator.crc_value() == _buf.calculate_crc16()) {
- return _buf.packet();
+ Logger::log(LogLevel::VERBOSE, "Successfully received the telegram with correct CRC");
+ return DsmrUnencryptedTelegram(_buf.packet());
}
- return Error::CrcMismatch;
+ Logger::log(LogLevel::DEBUG, "CRC mismatch: expected %04X, got %04X", _crc_accumulator.crc_value(), _buf.calculate_crc16());
+ return std::nullopt;
}
// unreachable
- return {};
+ return std::nullopt;
}
};
-inline const char* to_string(const PacketAccumulator::Error error) {
- switch (error) {
- case PacketAccumulator::Error::BufferOverflow:
- return "BufferOverflow";
- case PacketAccumulator::Error::PacketStartSymbolInPacket:
- return "PacketStartSymbolInPacket";
- case PacketAccumulator::Error::IncorrectCrcCharacter:
- return "IncorrectCrcCharacter";
- case PacketAccumulator::Error::CrcMismatch:
- return "CrcMismatch";
- }
-
- // unreachable
- return "Unknown error";
-}
-
}
diff --git a/src/dsmr_parser/parser.h b/src/dsmr_parser/parser.h
index a145902..5763eb9 100644
--- a/src/dsmr_parser/parser.h
+++ b/src/dsmr_parser/parser.h
@@ -1,460 +1,290 @@
#pragma once
#include "util.h"
-#include
+#include
+#include
+#include
namespace dsmr_parser {
-// ParsedData is a template for the result of parsing a Dsmr P1 message.
+// ParsedData is a template for the result of parsing a DSMR telegram.
// You pass the fields you want to add to it as template arguments.
-//
-// This template will then generate a class that extends all the fields
-// passed (the fields really are classes themselves). Since each field
-// class has a single member variable, with the same name as the field
-// class, all of these fields will be available on the generated class.
-//
-// In other words, if I have:
-//
-// using MyData = ParsedData<
-// identification,
-// equipment_id
-// >;
-//
-// MyData data;
-//
-// then I can refer to the fields like data.identification and
-// data.equipment_id normally.
-//
-// Furthermore, this class offers some helper methods that can be used
-// to loop over all the fields inside it.
+// Each field becomes a base class, exposing its member variable directly.
template
struct ParsedData final : Ts... {
-private:
- static const auto& fields_map() {
- static const auto& m = []() {
- const auto hasher = [](const ObisId& id) noexcept {
- std::uint64_t x = 0;
- std::memcpy(&x, id.v.data(), 6);
- return std::hash{}(x);
- };
- using FieldParseFunc = ParseResult (*)(ParsedData&, const char*, const char*);
- std::unordered_map tmp;
- (void)std::initializer_list{(tmp.emplace(Ts::id,
- [](ParsedData& self, const char* str, const char* end) {
- auto& field = static_cast(self);
- ParseResult res;
- if (field.present())
- return res.fail("Duplicate field", str);
- field.present() = true;
- return field.parse(str, end);
- }),
- 0)...};
- return tmp;
- }();
- return m;
- }
-
-public:
- ParseResult parse_line(const ObisId& obisId, const char* str, const char* end) {
- const auto& m = fields_map();
- auto it = m.find(obisId);
- if (it == m.end())
- return ParseResult().until(str);
- return it->second(*this, str, end);
- }
-
- template
- void applyEach(F&& f) {
- (Ts::apply(f), ...);
+ std::optional parse_line(const ObisId& obis_id, std::string_view input) {
+ std::optional res = input;
+ auto try_field = [&](auto& field) -> bool {
+ using F = std::remove_reference_t;
+ if (!(F::id == obis_id))
+ return false;
+ if (field.present()) {
+ Logger::log(LogLevel::ERROR, "Duplicate field [%.*s]", static_cast(input.size()), input.data());
+ res = std::nullopt;
+ } else {
+ field.present() = true;
+ res = field.parse(input);
+ }
+ return true;
+ };
+ (void)try_field;
+ (void)(try_field(static_cast(*this)) || ...);
+ return res;
}
bool all_present() { return (Ts::present() && ...); }
};
-struct StringParser final {
- static ParseResult parse_string(size_t min, size_t max, const char* str, const char* end) {
- ParseResult res;
- if (str >= end || *str != '(')
- return res.fail("Missing (", str);
-
- const char* str_start = str + 1; // Skip (
- const char* str_end = str_start;
-
- while (str_end < end && *str_end != ')')
- ++str_end;
-
- // We can have )) at the end. Thus we should add the first ) to the string.
- // Like in the situation when we parse "((ER11))".
- if (str_end + 1 < end && *(str_end + 1) == ')')
- ++str_end;
-
- if (str_end == end)
- return res.fail("Missing )", str_end);
-
- const auto& len = static_cast(str_end - str_start);
- if (len < min || len > max)
- return res.fail("Invalid string length", str_start);
-
- res.result.append(str_start, len);
-
- return res.until(str_end + 1); // Skip )
+// Parse a parenthesized string: (content)
+// Handles double-closing brackets like ((ER11))
+inline std::optional parse_string(std::string_view& out, size_t min, size_t max, std::string_view input) {
+ if (input.empty() || input.front() != '(') {
+ Logger::log(LogLevel::ERROR, "Missing ( '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
-};
-static constexpr char INVALID_NUMBER[] = "Invalid number";
-static constexpr char INVALID_UNIT[] = "Invalid unit";
+ size_t pos = 1;
+ while (pos < input.size() && input[pos] != ')')
+ ++pos;
-struct NumParser final {
- static ParseResult parse_float_or_int(const size_t max_decimals, const char* float_unit, const char* int_unit, const char* str, const char* end) {
- auto float_res = NumParser::parse(max_decimals, float_unit, str, end);
- if (!float_res.err)
- return float_res;
+ // Handle )) at the end — include the first ) in the string
+ if (pos + 1 < input.size() && input[pos + 1] == ')')
+ ++pos;
- auto int_res = NumParser::parse(0, int_unit, str, end);
- if (!int_res.err)
- return int_res;
+ if (pos == input.size()) {
+ Logger::log(LogLevel::ERROR, "Missing ) '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
- return float_res;
+ auto len = pos - 1;
+ if (len < min || len > max) {
+ Logger::log(LogLevel::ERROR, "Invalid string length '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
- static ParseResult parse(size_t max_decimals, const char* unit, const char* str, const char* end) {
- ParseResult res;
- if (str >= end || *str != '(')
- return res.fail("Missing (", str);
+ out = input.substr(1, len);
+ return input.substr(pos + 1);
+}
- const char* cur_symbol = str + 1; // Skip (
+// Parse a numeric value in parentheses: ([-]digits[.decimals][*unit])
+inline std::optional parse_num(int32_t& out, size_t max_decimals, const char* unit, std::string_view input, bool log_errors = true) {
+ if (input.empty() || input.front() != '(') {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Missing ( '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
- bool negative = false;
- if (cur_symbol < end && *cur_symbol == '-') {
- negative = true;
- ++cur_symbol;
- }
+ size_t p = 1;
+ bool negative = (p < input.size() && input[p] == '-');
+ if (negative)
+ ++p;
- int32_t value = 0;
+ int32_t value = 0;
- // Parse integer part
- while (cur_symbol < end && !strchr("*.)", *cur_symbol)) {
- if (*cur_symbol < '0' || *cur_symbol > '9')
- return res.fail(INVALID_NUMBER, cur_symbol);
- value *= 10;
- value += (*cur_symbol - '0');
- ++cur_symbol;
+ while (p < input.size() && input[p] != '.' && input[p] != '*' && input[p] != ')') {
+ if (input[p] < '0' || input[p] > '9') {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Invalid number '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
+ value = value * 10 + (input[p] - '0');
+ ++p;
+ }
- // Parse decimal part, if any
- if (max_decimals && cur_symbol < end && *cur_symbol == '.') {
- ++cur_symbol;
-
- while (cur_symbol < end && !strchr("*)", *cur_symbol) && max_decimals) {
- max_decimals--;
- if (*cur_symbol < '0' || *cur_symbol > '9')
- return res.fail(INVALID_NUMBER, cur_symbol);
- value *= 10;
- value += (*cur_symbol - '0');
- ++cur_symbol;
+ size_t remaining = max_decimals;
+ if (remaining && p < input.size() && input[p] == '.') {
+ ++p;
+ while (p < input.size() && input[p] != '*' && input[p] != ')' && remaining) {
+ if (input[p] < '0' || input[p] > '9') {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Invalid number '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
+ value = value * 10 + (input[p] - '0');
+ --remaining;
+ ++p;
}
+ }
- // Fill in missing decimals with zeroes
- while (max_decimals--)
- value *= 10;
-
- // Workaround for https://github.com/matthijskooijman/arduino-dsmr/issues/50
- // If value is 0, then we allow missing unit.
- if (unit && *unit && (cur_symbol >= end || (*cur_symbol != '*' && *cur_symbol != '.')) && value == 0) {
- cur_symbol = std::find(cur_symbol, end, ')');
- }
-
- // If a unit was passed, check that the unit in the message matches the unit passed.
- else if (unit && *unit) {
- if (cur_symbol >= end || *cur_symbol != '*')
- return res.fail("Missing unit", cur_symbol);
- const char* unit_start = ++cur_symbol; // skip *
- while (cur_symbol < end && *cur_symbol != ')' && *unit) {
- // Next character in units do not match?
- if (std::tolower(static_cast(*cur_symbol++)) != std::tolower(static_cast(*unit++)))
- return res.fail(INVALID_UNIT, unit_start);
+ while (remaining--)
+ value *= 10;
+
+ if (unit && *unit) {
+ // Value 0 allows missing unit (workaround for some meters)
+ if (value == 0 && (p >= input.size() || (input[p] != '*' && input[p] != '.'))) {
+ auto close = input.find(')', p);
+ p = (close != std::string_view::npos) ? close : input.size();
+ } else {
+ if (p >= input.size() || input[p] != '*') {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Missing unit '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
+ ++p;
+ const char* u = unit;
+ while (p < input.size() && input[p] != ')' && *u) {
+ if (std::tolower(static_cast(input[p])) != std::tolower(static_cast(*u))) {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Invalid unit '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
+ ++p;
+ ++u;
+ }
+ if (*u) {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Invalid unit '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
- // At the end of the message unit, but not the passed unit?
- if (*unit)
- return res.fail(INVALID_UNIT, unit_start);
}
+ }
- if (cur_symbol >= end || *cur_symbol != ')')
- return res.fail("Extra data", cur_symbol);
+ if (p >= input.size() || input[p] != ')') {
+ if (log_errors)
+ Logger::log(LogLevel::ERROR, "Extra data '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
- if (negative)
- value = -value;
+ out = negative ? -value : value;
+ return input.substr(p + 1);
+}
- return res.succeed(value).until(cur_symbol + 1); // Skip )
- }
-};
+// Try float unit first, fall back to integer unit
+inline std::optional parse_float_or_int(int32_t& out, size_t max_decimals, const char* float_unit, const char* int_unit,
+ std::string_view input) {
+ auto res = parse_num(out, max_decimals, float_unit, input, /*log_errors=*/false);
+ if (res)
+ return res;
+ return parse_num(out, 0, int_unit, input);
+}
-struct ObisIdParser final {
- static ParseResult parse(const char* str, const char* end) noexcept {
- // Parse a Obis ID of the form 1-2:3.4.5.6
- // Stops parsing on the first unrecognized character. Any unparsed
- // parts are set to 255.
- ParseResult res;
- ObisId& id = res.result;
- res.next = str;
- uint8_t part = 0;
- while (res.next < end) {
- char c = *res.next;
-
- if (c >= '0' && c <= '9') {
- const auto& digit = c - '0';
- if (id.v[part] > 25 || (id.v[part] == 25 && digit > 5))
- return res.fail("Obis ID has number over 255", res.next);
- id.v[part] = static_cast(id.v[part] * 10 + digit);
- } else if (part == 0 && c == '-') {
- part++;
- } else if (part == 1 && c == ':') {
- part++;
- } else if (part > 1 && part < 5 && c == '.') {
- part++;
- } else {
- break;
+// Parse OBIS identifier (a-b:c.d.e.f)
+inline std::optional parse_obis(ObisId& id, std::string_view input) {
+ size_t pos = 0;
+ uint8_t part = 0;
+ while (pos < input.size()) {
+ char c = input[pos];
+ if (c >= '0' && c <= '9') {
+ auto digit = static_cast(c - '0');
+ if (id.v[part] > 25 || (id.v[part] == 25 && digit > 5)) {
+ Logger::log(LogLevel::ERROR, "Obis ID has number over 255 '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
}
- ++res.next;
+ id.v[part] = static_cast(id.v[part] * 10 + digit);
+ } else if (part == 0 && c == '-') {
+ part++;
+ } else if (part == 1 && c == ':') {
+ part++;
+ } else if (part > 1 && part < 5 && c == '.') {
+ part++;
+ } else {
+ break;
}
+ ++pos;
+ }
- if (res.next == str)
- return res.fail("OBIS id Empty", str);
+ if (pos == 0) {
+ Logger::log(LogLevel::ERROR, "OBIS id Empty '%.*s'", static_cast(input.size()), input.data());
+ return std::nullopt;
+ }
- for (++part; part < 6; ++part)
- id.v[part] = 255;
+ for (++part; part < 6; ++part)
+ id.v[part] = 255;
- return res;
- }
-};
+ return input.substr(pos);
+}
-struct CrcParser final {
+struct DsmrParser final {
private:
- static const size_t CRC_LEN = 4;
-
- static bool hex_nibble(char c, uint8_t& out) noexcept {
- if (c >= '0' && c <= '9') {
- out = static_cast(c - '0');
- return true;
- }
- if (c >= 'A' && c <= 'F') {
- out = static_cast(c - 'A' + 10);
- return true;
- }
- if (c >= 'a' && c <= 'f') {
- out = static_cast(c - 'a' + 10);
+ template
+ static bool parse_line(Data& data, std::string_view input, bool unknown_error) {
+ if (input.empty())
return true;
- }
- return false;
- }
-public:
- // Parse a crc value. str must point to the first of the four hex
- // bytes in the CRC.
- static ParseResult parse(const char* str, const char* end) {
- ParseResult res;
-
- if (str + CRC_LEN > end)
- return res.fail("No checksum found", str);
-
- uint16_t value = 0;
- for (size_t i = 0; i < CRC_LEN; ++i) {
- uint8_t nibble;
- if (!hex_nibble(str[i], nibble))
- return res.fail("Incomplete or malformed checksum", str + i);
- value = static_cast((value << 4) | nibble);
- }
+ ObisId id;
+ auto idres = parse_obis(id, input);
+ if (!idres)
+ return false;
- res.next = str + CRC_LEN;
- return res.succeed(value);
- }
-};
+ auto datares = data.parse_line(id, *idres);
+ if (!datares)
+ return false;
-struct P1Parser final {
-private:
- // uses polynomial x^16+x^15+x^2+1
- static uint16_t crc16_update(uint16_t crc, uint8_t data) noexcept {
- crc ^= data;
- for (size_t i = 0; i < 8; ++i) {
- if (crc & 1) {
- crc = (crc >> 1) ^ 0xA001;
- } else {
- crc = (crc >> 1);
- }
+ if ((*datares).data() != (*idres).data() && !(*datares).empty()) {
+ Logger::log(LogLevel::ERROR, "Trailing characters on data line '%.*s'", static_cast(input.size()), input.data());
+ return false;
}
- return crc;
- }
-
-public:
- // Parse a complete P1 telegram. The string passed should start
- // with '/' and run up to and including the ! and the following
- // four byte checksum. It's ok if the string is longer, the .next
- // pointer in the result will indicate the next unprocessed byte.
- template
- static ParseResult parse(ParsedData& data, const char* str, size_t n, bool unknown_error = false, bool check_crc = true) {
- ParseResult res;
-
- const char* const buf_begin = str;
- const char* const buf_end = str + n;
-
- if (!n || *buf_begin != '/')
- return res.fail("Data should start with /", buf_begin);
-
- // The payload starts after '/', and runs up to (but not including) '!'
- const char* const data_begin = buf_begin + 1;
-
- // Find the terminating '!' (or the end of buffer if not present)
- const char* term = std::find(data_begin, buf_end, '!');
- if (term == buf_end)
- return res.fail("Data should end with !");
-
- if (check_crc) {
- // With CRC enabled, '!' must exist and be followed by 4 hex chars.
- if (term >= buf_end)
- return res.fail("No checksum found", term);
-
- // Compute CRC over '/' .. '!' (inclusive).
- uint16_t crc = 0;
- for (const char* p = buf_begin; p <= term; ++p)
- crc = crc16_update(crc, static_cast(*p));
-
- // Parse and verify the 4-hex checksum after '!'
- ParseResult check = CrcParser::parse(term + 1, buf_end);
- if (check.err)
- return check;
- if (check.result != crc)
- return res.fail("Checksum mismatch", term + 1);
-
- // Parse payload (between '/' and '!')
- res = parse_data(data, data_begin, term, unknown_error);
- res.next = check.next; // Advance past checksum
- return res;
+ if ((*datares).data() == (*idres).data() && unknown_error) {
+ Logger::log(LogLevel::ERROR, "Unknown field '%.*s'", static_cast(input.size()), input.data());
+ return false;
}
- // No CRC checking: parse up to '!' if present, otherwise up to buf_end.
- res = parse_data(data, data_begin, term, unknown_error);
- res.next = (term < buf_end) ? term : buf_end;
- return res;
+ return true;
}
- // Parse the data part of a message. Str should point to the first
- // character after the leading /, end should point to the ! before the
- // checksum. Does not verify the checksum.
+public:
template
- static ParseResult parse_data(ParsedData& data, const char* str, const char* end, bool unknown_error = false) {
- // Split into lines and parse those
- const char* line_end = str;
- const char* line_start = str;
+ static bool parse(ParsedData& data, DsmrUnencryptedTelegram telegram, bool unknown_error = false) {
+ // Strip leading '/' and trailing '!'
+ auto input = telegram.content().substr(1, telegram.content().size() - 2);
+
+ size_t pos = 0;
+ size_t line_start = 0;
// Parse ID line
- while (line_end < end) {
- if (*line_end == '\r' || *line_end == '\n') {
- // The first identification line looks like:
- // XXX5
- // The DSMR spec is vague on details, but in 62056-21, the X's
- // are a three-letter (registerd) manufacturer ID, the id
- // string is up to 16 chars of arbitrary characters and the
- // '5' is a baud rate indication. 5 apparently means 9600,
- // which DSMR 3.x and below used. It seems that DSMR 2.x
- // passed '3' here (which is mandatory for "mode D"
- // communication according to 62956-21), so we also allow
- // that. Apparently swedish meters use '9' for 115200. This code
- // used to check the format of the line somewhat, but for
- // flexibility (and since we do not actually parse the contents
- // of the line anyway), just allow anything now.
- //
- // Offer it for processing using the all-ones Obis ID, which
- // is not otherwise valid.
- ParseResult tmp = data.parse_line(ObisId(255, 255, 255, 255, 255, 255), line_start, line_end);
- if (tmp.err)
- return tmp;
- line_start = ++line_end;
+ while (pos < input.size()) {
+ if (input[pos] == '\r' || input[pos] == '\n') {
+ auto res = data.parse_line(ObisId(255, 255, 255, 255, 255, 255), input.substr(line_start, pos - line_start));
+ if (!res)
+ return false;
+ line_start = ++pos;
break;
}
- ++line_end;
+ ++pos;
}
- // Parse data lines
- // We need to track brackets to handle cases like:
- // 0-0:96.13.0(303132333435
- // 30313233343)
- // Also we need to handle cases like:
- // 1-0:0.2.0((ER11))
- bool open_bracket_found = false;
- while (line_end < end) {
- char c = *line_end;
- char next_c = (line_end + 1 < end) ? *(line_end + 1) : '\0';
-
- if ((c == '(' && next_c == '(') || (c == ')' && next_c == ')')) {
- // we have a case like:
- // 1-0:0.2.0((ER11))
- // Treat double brackets as a single bracket for bracket tracking
- line_end++;
- c = next_c;
+ // Parse data lines — track brackets to handle multi-line values
+ // and double brackets like ((ER11))
+ bool open_bracket = false;
+ while (pos < input.size()) {
+ char c = input[pos];
+ char nc = (pos + 1 < input.size()) ? input[pos + 1] : '\0';
+
+ if ((c == '(' && nc == '(') || (c == ')' && nc == ')')) {
+ ++pos;
+ c = nc;
}
if (c == '(') {
- if (open_bracket_found) {
- return ParseResult().fail("Unexpected '(' symbol", line_end);
+ if (open_bracket) {
+ Logger::log(LogLevel::ERROR, "Unexpected '(' symbol");
+ return false;
}
- open_bracket_found = true;
+ open_bracket = true;
} else if (c == ')') {
- if (!open_bracket_found) {
- return ParseResult().fail("Unexpected ')' symbol", line_end);
+ if (!open_bracket) {
+ Logger::log(LogLevel::ERROR, "Unexpected ')' symbol");
+ return false;
}
- open_bracket_found = false;
+ open_bracket = false;
} else if (c == '\r' || c == '\n') {
-
- // handles case like:
- // 0-1:24.3.0(120517020000)(08)(60)(1)(0-1:24.2.1)(m3)
- // (00124.477)
- const auto& next_part_of_the_data_line_on_next_line = (end - line_end > 2) && (line_end[1] == '(' || line_end[2] == '(');
-
- const auto& break_in_the_middle_of_the_data_line = open_bracket_found || next_part_of_the_data_line_on_next_line;
-
- if (!break_in_the_middle_of_the_data_line) {
- // End of logical line -> parse it
- ParseResult tmp = parse_line(data, line_start, line_end, unknown_error);
- if (tmp.err)
- return tmp;
-
- line_start = line_end + 1;
+ bool continuation = open_bracket || ((input.size() - pos > 2) && (input[pos + 1] == '(' || input[pos + 2] == '('));
+ if (!continuation) {
+ if (!parse_line(data, input.substr(line_start, pos - line_start), unknown_error))
+ return false;
+ line_start = pos + 1;
}
}
- ++line_end;
+ ++pos;
}
- if (line_end != line_start)
- return ParseResult().fail("Last dataline not CRLF terminated", line_end);
-
- return ParseResult();
- }
+ if (pos != line_start) {
+ Logger::log(LogLevel::ERROR, "Last dataline not CRLF terminated");
+ return false;
+ }
- template
- static ParseResult parse_line(Data& data, const char* line, const char* end, bool unknown_error) {
- ParseResult res;
- if (line == end)
- return res;
-
- ParseResult idres = ObisIdParser::parse(line, end);
- if (idres.err)
- return idres;
-
- ParseResult datares = data.parse_line(idres.result, idres.next, end);
- if (datares.err)
- return datares;
-
- // If datares.next didn't move at all, there was no parser for
- // this field, that's ok. But if it did move, but not all the way
- // to the end, that's an error.
- if (datares.next != idres.next && datares.next != end)
- return res.fail("Trailing characters on data line", datares.next);
- else if (datares.next == idres.next && unknown_error)
- return res.fail("Unknown field", line);
-
- return res.until(end);
+ return true;
}
};
}
diff --git a/src/dsmr_parser/util.h b/src/dsmr_parser/util.h
index ef724c1..147a1d6 100644
--- a/src/dsmr_parser/util.h
+++ b/src/dsmr_parser/util.h
@@ -1,11 +1,14 @@
#pragma once
-#include
#include
+#include
#include
-#include
-#include
-#include
+#include
+#include
+#include
+#if defined(_MSC_VER)
+#include
+#endif
namespace dsmr_parser {
@@ -32,117 +35,61 @@ class NonCopyableAndNonMovable : NonCopyable {
NonCopyableAndNonMovable& operator=(NonCopyableAndNonMovable&&) = delete;
};
-// The ParseResult class wraps the result of a parse function. The type
-// of the result is passed as a template parameter and can be void to
-// not return any result.
-//
-// A ParseResult can either:
-// - Return an error. In this case, err is set to an error message, ctx
-// is optionally set to where the error occurred. The result (if any)
-// and the next pointer are meaningless.
-// - Return succesfully. In this case, err and ctx are NULL, result
-// contains the result (if any) and next points one past the last
-// byte processed by the parser.
-//
-// The ParseResult class has some convenience functions:
-// - succeed(result): sets the result to the given value and returns
-// the ParseResult again.
-// - fail(err): Set the err member to the error message passed,
-// optionally sets the ctx and return the ParseResult again.
-// - until(next): Set the next member and return the ParseResult again.
-//
-// Furthermore, ParseResults can be implicitely converted to other
-// types. In this case, the error message, context and and next pointer are
-// conserved, the return value is reset to the default value for the
-// target type.
-//
-// Note that ctx points into the string being parsed, so it does not
-// need to be freed, lives as long as the original string and is
-// probably way longer that needed.
-
-// Superclass for ParseResult so we can specialize for void without
-// having to duplicate all content
-template
-struct _ParseResult {
- T result;
-
- template
- P& succeed(U&& value) {
- result = std::forward(value);
- return *static_cast(this);
- }
+// An OBIS ID like: "1-0:1.7.0.255"
+struct ObisId final {
+ std::array v{};
+ constexpr explicit ObisId(const uint8_t a, const uint8_t b = 255, const uint8_t c = 255, const uint8_t d = 255, const uint8_t e = 255,
+ const uint8_t f = 255) noexcept
+ : v{a, b, c, d, e, f} {};
+ ObisId() = default;
+ bool operator==(const ObisId&) const = default;
};
-// partial specialization for void result
-template
-struct _ParseResult {};
-
-// Actual ParseResult class
-template
-struct ParseResult final : public _ParseResult, T> {
- const char* next = nullptr;
- const char* err = nullptr;
- const char* ctx = nullptr;
+// Represents an unencrypted DSMR telegram that starts with '/' and ends with '!' without CRC at the end.
+// Example:
+// "/AAA5MTR\r\n"
+// "\r\n"
+// "1-0:1.7.0(00.100*kW)\r\n"
+// "1-0:1.7.0(00.200*kW)\r\n"
+// "!";
+class DsmrUnencryptedTelegram final {
+ std::string_view data;
+public:
+ explicit DsmrUnencryptedTelegram(std::string_view telegram) : data(telegram) {}
+ std::string_view content() const { return data; }
+};
- ParseResult& fail(const char* error, const char* context = nullptr) noexcept {
- this->err = error;
- this->ctx = context;
- return *this;
- }
+enum class LogLevel {
+ VERY_VERBOSE,
+ VERBOSE,
+ DEBUG,
+ INFO,
+ WARNING,
+ ERROR,
+};
- ParseResult& until(const char* nextToken) noexcept {
- this->next = nextToken;
- return *this;
+class Logger final {
+public:
+ static void set_log_function(std::function