Release 1.1.0

Merge pull request #124 from yada75/reactive
add instantaneous reactive power + fixed swapped reactive total import export
2023-02-08 12:02:14 +01:00 · 2023-01-28 13:32:32 +01:00 · 2023-01-18 20:02:54 +01:00 · 2023-01-18 19:39:29 +01:00 · 2023-01-18 19:34:35 +01:00 · 2023-01-18 19:31:39 +01:00
14 changed files with 828 additions and 27 deletions
@@ -12,15 +12,15 @@ jobs:
    strategy:
      matrix:
        python-version:
-          - '3.6'
          - '3.7'
          - '3.8'
          - '3.9'
          - '3.10'
+          - '3.11'

    name: Python ${{ matrix.python-version }}
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3

      - name: Setup Python ${{ matrix.python-version }}
        uses: actions/setup-python@v2
@@ -28,7 +28,7 @@ jobs:
          python-version: ${{ matrix.python-version }}

      - name: Cached PIP dependencies
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        with:
          path: |
            ~/.cache/pip
@@ -43,4 +43,4 @@ jobs:
        run: tox

      - name: Code coverage upload
-        uses: codecov/codecov-action@v1
+        uses: codecov/codecov-action@v3
@@ -1,6 +1,21 @@
 Change Log
 ----------

+**1.1.0** (2023-02-08)
+
+- Add instantaneous reactive power + fixed swapped reactive total import export (`pull request #124 <https://github.com/ndokter/dsmr_parser/pull/124>`_ by `yada75 <https://github.com/yada75>`_)
+
+
+**1.0.0** (2022-12-22)
+
+- switched to new numbering scheme https://semver.org/
+- Added support for Python 3.11 and dropped support for Python 3.6 (`pull request #112 <https://github.com/ndokter/dsmr_parser/pull/112>`_)
+- Add support for Fluvius V1.7.1 DSMR messages (`pull request #110 <https://github.com/ndokter/dsmr_parser/pull/113>`_)
+
+**0.34** (2022-10-19)
+
+- Adds support for the Sagemcom T210-D-r smart meter (`pull request #110 <https://github.com/ndokter/dsmr_parser/pull/110>`_).
+
 **0.33** (2022-04-20)

 - Test Python 3.10 in CI + legacy badge fix (`pull request #105 <https://github.com/ndokter/dsmr_parser/pull/105>`_).
@@ -4,7 +4,7 @@ DSMR Parser
 .. image:: https://img.shields.io/pypi/v/dsmr-parser.svg
    :target: https://pypi.python.org/pypi/dsmr-parser

-.. image:: https://img.shields.io/github/workflow/status/ndokter/dsmr_parser/Tests/master
+.. image:: https://img.shields.io/github/actions/workflow/status/ndokter/dsmr_parser/tests.yml?branch=master
    :target: https://github.com/ndokter/dsmr_parser/actions/workflows/tests.yml

 A library for parsing Dutch Smart Meter Requirements (DSMR) telegram data. It
@@ -95,3 +95,35 @@ class AsyncSerialReader(SerialReader):
                    )
                except ParseError as e:
                    logger.warning('Failed to parse telegram: %s', e)
+
+    async def read_as_object(self, queue):
+        """
+        Read complete DSMR telegram's from the serial interface
+        and return a Telegram object.
+
+        Instead of being a generator, Telegram objects are pushed
+        to provided queue for asynchronous processing.
+
+        :rtype: None
+        """
+
+        # create Serial StreamReader
+        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
+        reader, _ = await conn
+
+        while True:
+
+            # Read line if available or give control back to loop until new
+            # data has arrived.
+            data = await reader.readline()
+            self.telegram_buffer.append(data.decode('ascii'))
+
+            for telegram in self.telegram_buffer.get_all():
+                try:
+                    queue.put_nowait(
+                        Telegram(telegram, self.telegram_parser, self.telegram_specification)
+                    )
+                except InvalidChecksumError as e:
+                    logger.warning(str(e))
+                except ParseError as e:
+                    logger.error('Failed to parse telegram: %s', e)
@@ -11,9 +11,11 @@ EN = {
    obis.P1_MESSAGE_HEADER: 'P1_MESSAGE_HEADER',
    obis.P1_MESSAGE_TIMESTAMP: 'P1_MESSAGE_TIMESTAMP',
    obis.ELECTRICITY_IMPORTED_TOTAL: 'ELECTRICITY_IMPORTED_TOTAL',
+    obis.ELECTRICITY_REACTIVE_IMPORTED_TOTAL: 'ELECTRICITY_REACTIVE_IMPORTED_TOTAL',
    obis.ELECTRICITY_USED_TARIFF_1: 'ELECTRICITY_USED_TARIFF_1',
    obis.ELECTRICITY_USED_TARIFF_2: 'ELECTRICITY_USED_TARIFF_2',
    obis.ELECTRICITY_EXPORTED_TOTAL: 'ELECTRICITY_EXPORTED_TOTAL',
+    obis.ELECTRICITY_REACTIVE_EXPORTED_TOTAL: 'ELECTRICITY_REACTIVE_EXPORTED_TOTAL',
    obis.ELECTRICITY_DELIVERED_TARIFF_1: 'ELECTRICITY_DELIVERED_TARIFF_1',
    obis.ELECTRICITY_DELIVERED_TARIFF_2: 'ELECTRICITY_DELIVERED_TARIFF_2',
    obis.ELECTRICITY_ACTIVE_TARIFF: 'ELECTRICITY_ACTIVE_TARIFF',
@@ -44,15 +46,42 @@ EN = {
    obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
    obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
    obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: 'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE: 'INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE',
+    obis.INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE: 'INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE',
    obis.EQUIPMENT_IDENTIFIER_GAS: 'EQUIPMENT_IDENTIFIER_GAS',
    obis.HOURLY_GAS_METER_READING: 'HOURLY_GAS_METER_READING',
    obis.GAS_METER_READING: 'GAS_METER_READING',
    obis.ACTUAL_TRESHOLD_ELECTRICITY: 'ACTUAL_TRESHOLD_ELECTRICITY',
    obis.ACTUAL_SWITCH_POSITION: 'ACTUAL_SWITCH_POSITION',
    obis.VALVE_POSITION_GAS: 'VALVE_POSITION_GAS',
-    obis.BELGIUM_5MIN_GAS_METER_READING: 'BELGIUM_5MIN_GAS_METER_READING',
+    obis.BELGIUM_VERSION_INFORMATION: 'BELGIUM_VERSION_INFORMATION',
+    obis.BELGIUM_EQUIPMENT_IDENTIFIER: 'BELGIUM_EQUIPMENT_IDENTIFIER',
+    obis.BELGIUM_CURRENT_AVERAGE_DEMAND: 'BELGIUM_CURRENT_AVERAGE_DEMAND',
+    obis.BELGIUM_MAXIMUM_DEMAND_MONTH: 'BELGIUM_MAXIMUM_DEMAND_MONTH',
+    obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS: 'BELGIUM_MAXIMUM_DEMAND_13_MONTHS',
    obis.BELGIUM_MAX_POWER_PER_PHASE: 'BELGIUM_MAX_POWER_PER_PHASE',
    obis.BELGIUM_MAX_CURRENT_PER_PHASE: 'BELGIUM_MAX_CURRENT_PER_PHASE',
+    obis.BELGIUM_MBUS1_DEVICE_TYPE: 'BELGIUM_MBUS1_DEVICE_TYPE',
+    obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER',
+    obis.BELGIUM_MBUS1_VALVE_POSITION: 'BELGIUM_MBUS1_VALVE_POSITION',
+    obis.BELGIUM_MBUS1_METER_READING1: 'BELGIUM_MBUS1_METER_READING1',
+    obis.BELGIUM_MBUS1_METER_READING2: 'BELGIUM_MBUS1_METER_READING2',
+    obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER',
+    obis.BELGIUM_MBUS2_VALVE_POSITION: 'BELGIUM_MBUS2_VALVE_POSITION',
+    obis.BELGIUM_MBUS2_METER_READING1: 'BELGIUM_MBUS2_METER_READING1',
+    obis.BELGIUM_MBUS2_METER_READING2: 'BELGIUM_MBUS2_METER_READING2',
+    obis.BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER',
+    obis.BELGIUM_MBUS3_VALVE_POSITION: 'BELGIUM_MBUS3_VALVE_POSITION',
+    obis.BELGIUM_MBUS3_METER_READING1: 'BELGIUM_MBUS3_METER_READING1',
+    obis.BELGIUM_MBUS3_METER_READING2: 'BELGIUM_MBUS3_METER_READING2',
+    obis.BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER: 'BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER',
+    obis.BELGIUM_MBUS4_VALVE_POSITION: 'BELGIUM_MBUS4_VALVE_POSITION',
+    obis.BELGIUM_MBUS4_METER_READING1: 'BELGIUM_MBUS4_METER_READING1',
+    obis.BELGIUM_MBUS4_METER_READING2: 'BELGIUM_MBUS4_METER_READING2',
    obis.LUXEMBOURG_EQUIPMENT_IDENTIFIER: 'LUXEMBOURG_EQUIPMENT_IDENTIFIER',
    obis.Q3D_EQUIPMENT_IDENTIFIER: 'Q3D_EQUIPMENT_IDENTIFIER',
    obis.Q3D_EQUIPMENT_STATE: 'Q3D_EQUIPMENT_STATE',
@@ -12,6 +12,14 @@ ELECTRICITY_USED_TARIFF_1 = r'\d-\d:1\.8\.1.+?\r\n'
 ELECTRICITY_USED_TARIFF_2 = r'\d-\d:1\.8\.2.+?\r\n'
 ELECTRICITY_DELIVERED_TARIFF_1 = r'\d-\d:2\.8\.1.+?\r\n'
 ELECTRICITY_DELIVERED_TARIFF_2 = r'\d-\d:2\.8\.2.+?\r\n'
+CURRENT_REACTIVE_IMPORTED = r'\d-\d:3\.7\.0.+?\r\n'
+ELECTRICITY_REACTIVE_IMPORTED_TOTAL = r'\d-\d:3\.8\.0.+?\r\n'
+ELECTRICITY_REACTIVE_IMPORTED_TARIFF_1 = r'\d-\d:3\.8\.1.+?\r\n'
+ELECTRICITY_REACTIVE_IMPORTED_TARIFF_2 = r'\d-\d:3\.8\.2.+?\r\n'
+CURRENT_REACTIVE_EXPORTED = r'\d-\d:4\.7\.0.+?\r\n'
+ELECTRICITY_REACTIVE_EXPORTED_TOTAL = r'\d-\d:4\.8\.0.+?\r\n'
+ELECTRICITY_REACTIVE_EXPORTED_TARIFF_1 = r'\d-\d:4\.8\.1.+?\r\n'
+ELECTRICITY_REACTIVE_EXPORTED_TARIFF_2 = r'\d-\d:4\.8\.2.+?\r\n'
 ELECTRICITY_ACTIVE_TARIFF = r'\d-\d:96\.14\.0.+?\r\n'
 EQUIPMENT_IDENTIFIER = r'\d-\d:96\.1\.1.+?\r\n'
 CURRENT_ELECTRICITY_USAGE = r'\d-\d:1\.7\.0.+?\r\n'
@@ -40,6 +48,12 @@ INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE = r'\d-\d:61\.7\.0.+?\r\n'
 INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE = r'\d-\d:22\.7\.0.+?\r\n'
 INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE = r'\d-\d:42\.7\.0.+?\r\n'
 INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE = r'\d-\d:62\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE = r'\d-\d:23\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE = r'\d-\d:24\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE = r'\d-\d:43\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE = r'\d-\d:44\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE = r'\d-\d:63\.7\.0.+?\r\n'
+INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE = r'\d-\d:64\.7\.0.+?\r\n'
 EQUIPMENT_IDENTIFIER_GAS = r'\d-\d:96\.1\.0.+?\r\n'
 # TODO differences between gas meter readings in v3 and lower and v4 and up
 HOURLY_GAS_METER_READING = r'\d-\d:24\.2\.1.+?\r\n'
@@ -65,10 +79,46 @@ ELECTRICITY_IMPORTED_TOTAL = r'\d-\d:1\.8\.0.+?\r\n'  # Total imported energy re
 ELECTRICITY_EXPORTED_TOTAL = r'\d-\d:2\.8\.0.+?\r\n'  # Total exported energy register (P-)

 # International non generalized additions (country specific) / risk for necessary refactoring
-BELGIUM_5MIN_GAS_METER_READING = r'\d-\d:24\.2\.3.+?\r\n'  # Different code, same format.
+BELGIUM_VERSION_INFORMATION = r'\d-\d:96\.1\.4.+?\r\n'
+BELGIUM_EQUIPMENT_IDENTIFIER = r'\d-0:96\.1\.1.+?\r\n'
+BELGIUM_CURRENT_AVERAGE_DEMAND = r'\d-\d:1\.4\.0.+?\r\n'
+BELGIUM_MAXIMUM_DEMAND_MONTH = r'\d-\d:1\.6\.0.+?\r\n'
+BELGIUM_MAXIMUM_DEMAND_13_MONTHS = r'\d-\d:98\.1\.0.+?\r\n'
 BELGIUM_MAX_POWER_PER_PHASE = r'\d-\d:17\.0\.0.+?\r\n'  # Applicable when power limitation is active
 BELGIUM_MAX_CURRENT_PER_PHASE = r'\d-\d:31\.4\.0.+?\r\n'  # Applicable when current limitation is active
+
+# Multiple 'slaves' can be linked to the main device.
+# Mostly MBUS1 = GAS METER with values on 24.2.3
+# While WATER METER reports it's values on 24.2.1
+# The GAS METER also reports its valve state on 24.4.0
+# Dev type for gas = 7 and water = 8
+BELGIUM_MBUS1_DEVICE_TYPE = r'\d-1:24\.1\.0.+?\r\n'
+BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER = r'\d-1:96\.1\.1.+?\r\n'
+BELGIUM_MBUS1_VALVE_POSITION = r'\d-1:24\.4\.0.+?\r\n'
+BELGIUM_MBUS1_METER_READING1 = r'\d-1:24\.2\.1.+?\r\n'
+BELGIUM_MBUS1_METER_READING2 = r'\d-1:24\.2\.3.+?\r\n'
+
+BELGIUM_MBUS2_DEVICE_TYPE = r'\d-2:24\.1\.0.+?\r\n'
+BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER = r'\d-2:96\.1\.1.+?\r\n'
+BELGIUM_MBUS2_VALVE_POSITION = r'\d-2:24\.4\.0.+?\r\n'
+BELGIUM_MBUS2_METER_READING1 = r'\d-2:24\.2\.1.+?\r\n'
+BELGIUM_MBUS2_METER_READING2 = r'\d-2:24\.2\.3.+?\r\n'
+
+BELGIUM_MBUS3_DEVICE_TYPE = r'\d-3:24\.1\.0.+?\r\n'
+BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER = r'\d-3:96\.1\.1.+?\r\n'
+BELGIUM_MBUS3_VALVE_POSITION = r'\d-3:24\.4\.0.+?\r\n'
+BELGIUM_MBUS3_METER_READING1 = r'\d-3:24\.2\.1.+?\r\n'
+BELGIUM_MBUS3_METER_READING2 = r'\d-3:24\.2\.3.+?\r\n'
+
+BELGIUM_MBUS4_DEVICE_TYPE = r'\d-4:24\.1\.0.+?\r\n'
+BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER = r'\d-4:96\.1\.1.+?\r\n'
+BELGIUM_MBUS4_VALVE_POSITION = r'\d-4:24\.4\.0.+?\r\n'
+BELGIUM_MBUS4_METER_READING1 = r'\d-4:24\.2\.1.+?\r\n'
+BELGIUM_MBUS4_METER_READING2 = r'\d-4:24\.2\.3.+?\r\n'
+
+
 LUXEMBOURG_EQUIPMENT_IDENTIFIER = r'\d-\d:42\.0\.0.+?\r\n'  # Logical device name
+
 Q3D_EQUIPMENT_IDENTIFIER = r'\d-\d:0\.0\.0.+?\r\n'  # Logical device name
 Q3D_EQUIPMENT_STATE = r'\d-\d:96\.5\.5.+?\r\n'  # Device state (hexadecimal)
 Q3D_EQUIPMENT_SERIALNUMBER = r'\d-\d:96\.1\.255.+?\r\n'  # Device Serialnumber
@@ -114,6 +114,51 @@ class MBusObject(DSMRObject):
        return json.dumps(output)


+class MBusObjectPeak(DSMRObject):
+
+    @property
+    def datetime(self):
+        return self.values[0]['value']
+
+    @property
+    def occurred(self):
+        return self.values[1]['value']
+
+    @property
+    def value(self):
+        return self.values[2]['value']
+
+    @property
+    def unit(self):
+        return self.values[2]['unit']
+
+    def __str__(self):
+        output = "{}\t[{}] at {} occurred {}"\
+            .format(str(self.value), str(self.unit), str(self.datetime.astimezone().isoformat()),
+                    str(self.occurred.astimezone().isoformat()))
+        return output
+
+    def to_json(self):
+        timestamp = self.datetime
+        if isinstance(self.datetime, datetime.datetime):
+            timestamp = self.datetime.astimezone().isoformat()
+        timestamp_occurred = self.occurred
+        if isinstance(self.occurred, datetime.datetime):
+            timestamp_occurred = self.occurred.astimezone().isoformat()
+        value = self.value
+        if isinstance(self.value, datetime.datetime):
+            value = self.value.astimezone().isoformat()
+        if isinstance(self.value, Decimal):
+            value = float(self.value)
+        output = {
+            'datetime': timestamp,
+            'occurred': timestamp_occurred,
+            'value': value,
+            'unit': self.unit
+        }
+        return json.dumps(output)
+
+
 class CosemObject(DSMRObject):

    @property
@@ -1,10 +1,16 @@
 import logging
 import re
+from binascii import unhexlify

 from ctypes import c_ushort
+from decimal import Decimal

-from dsmr_parser.objects import MBusObject, CosemObject, ProfileGenericObject
+from dlms_cosem.connection import XDlmsApduFactory
+from dlms_cosem.protocol.xdlms import GeneralGlobalCipher
+
+from dsmr_parser.objects import MBusObject, MBusObjectPeak, CosemObject, ProfileGenericObject
 from dsmr_parser.exceptions import ParseError, InvalidChecksumError
+from dsmr_parser.value_types import timestamp

 logger = logging.getLogger(__name__)

@@ -22,14 +28,15 @@ class TelegramParser(object):
        self.telegram_specification = telegram_specification
        self.apply_checksum_validation = apply_checksum_validation

-    def parse(self, telegram_data):
+    def parse(self, telegram_data, encryption_key="", authentication_key=""):  # noqa: C901
        """
        Parse telegram from string to dict.
-
        The telegram str type makes python 2.x integration easier.

        :param str telegram_data: full telegram from start ('/') to checksum
            ('!ABCD') including line endings in between the telegram's lines
+        :param str encryption_key: encryption key
+        :param str authentication_key: authentication key
        :rtype: dict
        :returns: Shortened example:
            {
@@ -43,6 +50,38 @@ class TelegramParser(object):
        :raises InvalidChecksumError:
        """

+        if "general_global_cipher" in self.telegram_specification:
+            if self.telegram_specification["general_global_cipher"]:
+                enc_key = unhexlify(encryption_key)
+                auth_key = unhexlify(authentication_key)
+                telegram_data = unhexlify(telegram_data)
+                apdu = XDlmsApduFactory.apdu_from_bytes(apdu_bytes=telegram_data)
+                if apdu.security_control.security_suite != 0:
+                    logger.warning("Untested security suite")
+                if apdu.security_control.authenticated and not apdu.security_control.encrypted:
+                    logger.warning("Untested authentication only")
+                if not apdu.security_control.authenticated and not apdu.security_control.encrypted:
+                    logger.warning("Untested not encrypted or authenticated")
+                if apdu.security_control.compressed:
+                    logger.warning("Untested compression")
+                if apdu.security_control.broadcast_key:
+                    logger.warning("Untested broadcast key")
+                telegram_data = apdu.to_plain_apdu(enc_key, auth_key).decode("ascii")
+            else:
+                try:
+                    if unhexlify(telegram_data[0:2])[0] == GeneralGlobalCipher.TAG:
+                        raise RuntimeError("Looks like a general_global_cipher frame "
+                                           "but telegram specification is not matching!")
+                except Exception:
+                    pass
+        else:
+            try:
+                if unhexlify(telegram_data[0:2])[0] == GeneralGlobalCipher.TAG:
+                    raise RuntimeError(
+                        "Looks like a general_global_cipher frame but telegram specification is not matching!")
+            except Exception:
+                pass
+
        if self.apply_checksum_validation \
                and self.telegram_specification['checksum_support']:
            self.validate_checksum(telegram_data)
@@ -177,6 +216,43 @@ class MBusParser(DSMRObjectParser):
        return MBusObject(self._parse(line))


+class MaxDemandParser(DSMRObjectParser):
+    """
+    Max demand history parser.
+
+    These are lines with multiple values. Each containing 2 timestamps and a value
+
+    Line format:
+    'ID (Count) (ID) (ID) (TST) (TST) (Mv1*U1)'
+
+     1  2  3  4  5  6  7
+
+    1) OBIS Reduced ID-code
+    2) Amount of values in the response
+    3) ID of the source
+    4) ^^
+    5) Time Stamp (TST) of the month
+    6) Time Stamp (TST) when the max demand occured
+    6) Measurement value 1 (most recent entry of buffer attribute without unit)
+    7) Unit of measurement values (Unit of capture objects attribute)
+    """
+
+    def parse(self, line):
+        pattern = re.compile(r'((?<=\()[0-9a-zA-Z\.\*\-\:]{0,}(?=\)))')
+        values = re.findall(pattern, line)
+
+        objects = []
+
+        count = int(values[0])
+        for i in range(1, count + 1):
+            timestamp_month = ValueParser(timestamp).parse(values[i * 3 + 1])
+            timestamp_occurred = ValueParser(timestamp).parse(values[i * 3 + 1])
+            value = ValueParser(Decimal).parse(values[i * 3 + 2])
+            objects.append(MBusObjectPeak([timestamp_month, timestamp_occurred, value]))
+
+        return objects
+
+
 class CosemParser(DSMRObjectParser):
    """
    Cosem object parser.
@@ -2,7 +2,7 @@ from decimal import Decimal
 from copy import deepcopy

 from dsmr_parser import obis_references as obis
-from dsmr_parser.parsers import CosemParser, ValueParser, MBusParser, ProfileGenericParser
+from dsmr_parser.parsers import CosemParser, ValueParser, MBusParser, ProfileGenericParser, MaxDemandParser
 from dsmr_parser.value_types import timestamp
 from dsmr_parser.profile_generic_specifications import BUFFER_TYPES, PG_HEAD_PARSERS, PG_UNIDENTIFIED_BUFFERTYPE_PARSERS

@@ -141,18 +141,88 @@ V5 = {

 ALL = (V2_2, V3, V4, V5)

-
-BELGIUM_FLUVIUS = deepcopy(V5)
-BELGIUM_FLUVIUS['objects'].update({
-    obis.BELGIUM_5MIN_GAS_METER_READING: MBusParser(
-        ValueParser(timestamp),
-        ValueParser(Decimal)
-    ),
-    obis.BELGIUM_MAX_POWER_PER_PHASE: CosemParser(ValueParser(Decimal)),
-    obis.BELGIUM_MAX_CURRENT_PER_PHASE: CosemParser(ValueParser(Decimal)),
-    obis.ACTUAL_SWITCH_POSITION: CosemParser(ValueParser(str)),
-    obis.VALVE_POSITION_GAS: CosemParser(ValueParser(str)),
-})
+BELGIUM_FLUVIUS = {
+    'checksum_support': True,
+    'objects': {
+        obis.BELGIUM_VERSION_INFORMATION: CosemParser(ValueParser(str)),
+        obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
+        obis.ELECTRICITY_USED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_USED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_DELIVERED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_DELIVERED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_ACTIVE_TARIFF: CosemParser(ValueParser(str)),
+        obis.BELGIUM_CURRENT_AVERAGE_DEMAND: CosemParser(ValueParser(Decimal)),
+        obis.BELGIUM_MAXIMUM_DEMAND_MONTH: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS: MaxDemandParser(),
+        obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_VOLTAGE_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_VOLTAGE_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_VOLTAGE_L3: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L3: CosemParser(ValueParser(Decimal)),
+        obis.ACTUAL_SWITCH_POSITION: CosemParser(ValueParser(int)),
+        obis.ACTUAL_TRESHOLD_ELECTRICITY: CosemParser(ValueParser(Decimal)),
+        obis.BELGIUM_MAX_POWER_PER_PHASE: CosemParser(ValueParser(Decimal)),
+        obis.BELGIUM_MAX_CURRENT_PER_PHASE: CosemParser(ValueParser(Decimal)),
+        obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
+        obis.BELGIUM_MBUS1_DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.BELGIUM_MBUS1_VALVE_POSITION: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS1_METER_READING1: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS1_METER_READING2: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS2_DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.BELGIUM_MBUS2_VALVE_POSITION: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS2_METER_READING1: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS2_METER_READING2: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS3_DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS3_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.BELGIUM_MBUS3_VALVE_POSITION: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS3_METER_READING1: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS3_METER_READING2: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS4_DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS4_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.BELGIUM_MBUS4_VALVE_POSITION: CosemParser(ValueParser(int)),
+        obis.BELGIUM_MBUS4_METER_READING1: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+        obis.BELGIUM_MBUS4_METER_READING2: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        ),
+    }
+}

 LUXEMBOURG_SMARTY = deepcopy(V5)
 LUXEMBOURG_SMARTY['objects'].update({
@@ -170,6 +240,8 @@ SWEDEN = {
        obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
        obis.ELECTRICITY_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
        obis.ELECTRICITY_EXPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_EXPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
        obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
        obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),
@@ -178,6 +250,12 @@ SWEDEN = {
        obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L1_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L2_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L2_NEGATIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L3_POSITIVE: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_REACTIVE_POWER_L3_NEGATIVE: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_VOLTAGE_L1: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_VOLTAGE_L2: CosemParser(ValueParser(Decimal)),
        obis.INSTANTANEOUS_VOLTAGE_L3: CosemParser(ValueParser(Decimal)),
@@ -201,3 +279,33 @@ Q3D = {
        obis.Q3D_EQUIPMENT_SERIALNUMBER: CosemParser(ValueParser(str)),
    },
 }
+
+
+SAGEMCOM_T210_D_R = {
+    "general_global_cipher": True,
+    "checksum_support": True,
+    'objects': {
+        obis.P1_MESSAGE_HEADER: CosemParser(ValueParser(str)),
+        obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
+        obis.ELECTRICITY_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_USED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_USED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
+
+        obis.ELECTRICITY_REACTIVE_EXPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_EXPORTED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_EXPORTED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_REACTIVE_IMPORTED: CosemParser(ValueParser(Decimal)),
+
+        obis.ELECTRICITY_EXPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_DELIVERED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_DELIVERED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
+
+        obis.ELECTRICITY_REACTIVE_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_IMPORTED_TARIFF_1: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_REACTIVE_IMPORTED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_REACTIVE_EXPORTED: CosemParser(ValueParser(Decimal)),
+    }
+}
+AUSTRIA_ENERGIENETZE_STEIERMARK = SAGEMCOM_T210_D_R
@@ -4,16 +4,17 @@ setup(
    name='dsmr-parser',
    description='Library to parse Dutch Smart Meter Requirements (DSMR)',
    author='Nigel Dokter and many others',
-    author_email='nigel@nldr.net',
+    author_email='mail@nldr.net',
    license='MIT',
    url='https://github.com/ndokter/dsmr_parser',
-    version='0.33',
+    version='1.1.0',
    packages=find_packages(exclude=('test', 'test.*')),
    install_requires=[
        'pyserial>=3,<4',
        'pyserial-asyncio<1',
        'pytz',
-        'Tailer==0.4.1'
+        'Tailer==0.4.1',
+        'dlms_cosem==21.3.2'
    ],
    entry_points={
        'console_scripts': ['dsmr_console=dsmr_parser.__main__:console']
@@ -129,6 +129,48 @@ TELEGRAM_V5 = (
    '!6EEE\r\n'
 )

+TELEGRAM_FLUVIUS_V171 = (
+    '/FLU5\253769484_A\r\n'
+    '\r\n'
+    '0-0:96.1.4(50217)\r\n'
+    '0-0:96.1.1(3153414733313031303231363035)\r\n'
+    '0-0:1.0.0(200512135409S)\r\n'
+    '1-0:1.8.1(000000.034*kWh)\r\n'
+    '1-0:1.8.2(000015.758*kWh)\r\n'
+    '1-0:2.8.1(000000.000*kWh)\r\n'
+    '1-0:2.8.2(000000.011*kWh)\r\n'
+    '1-0:1.4.0(02.351*kW)\r\n'
+    '1-0:1.6.0(200509134558S)(02.589*kW)\r\n'
+    '0-0:98.1.0(3)(1-0:1.6.0)(1-0:1.6.0)(200501000000S)(200423192538S)(03.695*kW)(200401000000S)(200305122139S)(05.980*kW)(200301000000S)(200210035421W)(04.318*kW)\r\n'
+    '0-0:96.14.0(0001)\r\n'
+    '1-0:1.7.0(00.000*kW)\r\n'
+    '1-0:2.7.0(00.000*kW)\r\n'
+    '1-0:21.7.0(00.000*kW)\r\n'
+    '1-0:41.7.0(00.000*kW)\r\n'
+    '1-0:61.7.0(00.000*kW)\r\n'
+    '1-0:22.7.0(00.000*kW)\r\n'
+    '1-0:42.7.0(00.000*kW)\r\n'
+    '1-0:62.7.0(00.000*kW)\r\n'
+    '1-0:32.7.0(234.7*V)\r\n'
+    '1-0:52.7.0(234.7*V)\r\n'
+    '1-0:72.7.0(234.7*V)\r\n'
+    '1-0:31.7.0(000.00*A)\r\n'
+    '1-0:51.7.0(000.00*A)\r\n'
+    '1-0:71.7.0(000.00*A)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:17.0.0(999.9*kW)\r\n'
+    '1-0:31.4.0(999*A)\r\n'
+    '0-0:96.13.0()\r\n'
+    '0-1:24.1.0(003)\r\n'
+    '0-1:96.1.1(37464C4F32313139303333373333)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '0-1:24.2.3(200512134558S)(00112.384*m3)\r\n'
+    '0-2:24.1.0(007)\r\n'
+    '0-2:96.1.1(3853414731323334353637383930)\r\n'
+    '0-2:24.2.1(200512134558S)(00872.234*m3)\r\n'
+    '!911C\r\n'
+)
+
 # EasyMeter via COM-1 Ethernet Gateway
 # Q3D Manual (german) https://www.easymeter.com/downloads/products/zaehler/Q3D/Easymeter_Q3D_DE_2016-06-15.pdf
 #  - type code on page 8
@@ -169,3 +211,27 @@ TELEGRAM_ESY5Q3DA1004_V304 = (
    '  25818685\r\n'
    'DE0000000000000000000000000000003\r\n'
 )
+
+TELEGRAM_SAGEMCOM_T210_D_R = (
+    '/EST5\\253710000_A\r\n'
+    '\r\n'
+    '1-3:0.2.8(50)\r\n'
+    '0-0:1.0.0(221006155014S)\r\n'
+    '1-0:1.8.0(006545766*Wh)\r\n'
+    '1-0:1.8.1(005017120*Wh)\r\n'
+    '1-0:1.8.2(001528646*Wh)\r\n'
+    '1-0:1.7.0(000000286*W)\r\n'
+    '1-0:2.8.0(000000058*Wh)\r\n'
+    '1-0:2.8.1(000000000*Wh)\r\n'
+    '1-0:2.8.2(000000058*Wh)\r\n'
+    '1-0:2.7.0(000000000*W)\r\n'
+    '1-0:3.8.0(000000747*varh)\r\n'
+    '1-0:3.8.1(000000000*varh)\r\n'
+    '1-0:3.8.2(000000747*varh)\r\n'
+    '1-0:3.7.0(000000000*var)\r\n'
+    '1-0:4.8.0(003897726*varh)\r\n'
+    '1-0:4.8.1(002692848*varh)\r\n'
+    '1-0:4.8.2(001204878*varh)\r\n'
+    '1-0:4.7.0(000000166*var)\r\n'
+    '!7EF9\r\n'
+)
@@ -0,0 +1,268 @@
+from decimal import Decimal
+
+import datetime
+import unittest
+
+import pytz
+
+from dsmr_parser import obis_references as obis
+from dsmr_parser import telegram_specifications
+from dsmr_parser.exceptions import InvalidChecksumError, ParseError
+from dsmr_parser.objects import CosemObject, MBusObject, MBusObjectPeak
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_FLUVIUS_V171
+
+
+class TelegramParserFluviusTest(unittest.TestCase):
+    """ Test parsing of a DSMR Fluvius telegram. """
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.BELGIUM_FLUVIUS)
+        result = parser.parse(TELEGRAM_FLUVIUS_V171)
+
+        # BELGIUM_VERSION_INFORMATION (0-0:96.1.4)
+        assert isinstance(result[obis.BELGIUM_VERSION_INFORMATION], CosemObject)
+        assert result[obis.BELGIUM_VERSION_INFORMATION].unit is None
+        assert isinstance(result[obis.BELGIUM_VERSION_INFORMATION].value, str)
+        assert result[obis.BELGIUM_VERSION_INFORMATION].value == '50217'
+
+        # EQUIPMENT_IDENTIFIER (0-0:96.1.1)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER].value == '3153414733313031303231363035'
+
+        # P1_MESSAGE_TIMESTAMP (0-0:1.0.0)
+        assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP], CosemObject)
+        assert result[obis.P1_MESSAGE_TIMESTAMP].unit is None
+        assert isinstance(result[obis.P1_MESSAGE_TIMESTAMP].value, datetime.datetime)
+        assert result[obis.P1_MESSAGE_TIMESTAMP].value == \
+            datetime.datetime(2020, 5, 12, 11, 54, 9, tzinfo=pytz.UTC)
+
+        # ELECTRICITY_USED_TARIFF_1 (1-0:1.8.1)
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1], CosemObject)
+        assert result[obis.ELECTRICITY_USED_TARIFF_1].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_1].value, Decimal)
+        assert result[obis.ELECTRICITY_USED_TARIFF_1].value == Decimal('0.034')
+
+        # ELECTRICITY_USED_TARIFF_2 (1-0:1.8.2)
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2], CosemObject)
+        assert result[obis.ELECTRICITY_USED_TARIFF_2].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_USED_TARIFF_2].value, Decimal)
+        assert result[obis.ELECTRICITY_USED_TARIFF_2].value == Decimal('15.758')
+
+        # ELECTRICITY_DELIVERED_TARIFF_1 (1-0:2.8.1)
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1], CosemObject)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value, Decimal)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_1].value == Decimal('0.000')
+
+        # ELECTRICITY_DELIVERED_TARIFF_2 (1-0:2.8.2)
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2], CosemObject)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].unit == 'kWh'
+        assert isinstance(result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value, Decimal)
+        assert result[obis.ELECTRICITY_DELIVERED_TARIFF_2].value == Decimal('0.011')
+
+        # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
+        assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF], CosemObject)
+        assert result[obis.ELECTRICITY_ACTIVE_TARIFF].unit is None
+        assert isinstance(result[obis.ELECTRICITY_ACTIVE_TARIFF].value, str)
+        assert result[obis.ELECTRICITY_ACTIVE_TARIFF].value == '0001'
+
+        # BELGIUM_CURRENT_AVERAGE_DEMAND (1-0:1.4.0)
+        assert isinstance(result[obis.BELGIUM_CURRENT_AVERAGE_DEMAND], CosemObject)
+        assert result[obis.BELGIUM_CURRENT_AVERAGE_DEMAND].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_CURRENT_AVERAGE_DEMAND].value, Decimal)
+        assert result[obis.BELGIUM_CURRENT_AVERAGE_DEMAND].value == Decimal('2.351')
+
+        # BELGIUM_MAXIMUM_DEMAND_MONTH (1-0:1.6.0)
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_MONTH], MBusObject)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_MONTH].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_MONTH].value, Decimal)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_MONTH].value == Decimal('2.589')
+
+        # BELGIUM_MAXIMUM_DEMAND_13_MONTHS (0-0:98.1.0) Value 0
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][0], MBusObjectPeak)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][0].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][0].value, Decimal)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][0].value == Decimal('3.695')
+        # BELGIUM_MAXIMUM_DEMAND_13_MONTHS (0-0:98.1.0) Value 1
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][1], MBusObjectPeak)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][1].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][1].value, Decimal)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][1].value == Decimal('5.980')
+        # BELGIUM_MAXIMUM_DEMAND_13_MONTHS (0-0:98.1.0) Value 2
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][2], MBusObjectPeak)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][2].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][2].value, Decimal)
+        assert result[obis.BELGIUM_MAXIMUM_DEMAND_13_MONTHS][2].value == Decimal('4.318')
+
+        # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE], CosemObject)
+        assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_USAGE].value, Decimal)
+        assert result[obis.CURRENT_ELECTRICITY_USAGE].value == Decimal('0.000')
+
+        # CURRENT_ELECTRICITY_DELIVERY (1-0:2.7.0)
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY], CosemObject)
+        assert result[obis.CURRENT_ELECTRICITY_DELIVERY].unit == 'kW'
+        assert isinstance(result[obis.CURRENT_ELECTRICITY_DELIVERY].value, Decimal)
+        assert result[obis.CURRENT_ELECTRICITY_DELIVERY].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE (1-0:41.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE (1-0:61.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE (1-0:22.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE (1-0:42.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE (1-0:62.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE], CosemObject)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].unit == 'kW'
+        assert isinstance(result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value, Decimal)
+        assert result[obis.INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE].value == Decimal('0.000')
+
+        # INSTANTANEOUS_VOLTAGE_L1 (1-0:32.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L1], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L1].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L1].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L1].value == Decimal('234.7')
+
+        # INSTANTANEOUS_VOLTAGE_L2 (1-0:52.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L2], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L2].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L2].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L2].value == Decimal('234.7')
+
+        # INSTANTANEOUS_VOLTAGE_L3 (1-0:72.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L3], CosemObject)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L3].unit == 'V'
+        assert isinstance(result[obis.INSTANTANEOUS_VOLTAGE_L3].value, Decimal)
+        assert result[obis.INSTANTANEOUS_VOLTAGE_L3].value == Decimal('234.7')
+
+        # INSTANTANEOUS_CURRENT_L1 (1-0:31.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L1].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L1].value == Decimal('0.000')
+
+        # INSTANTANEOUS_CURRENT_L2 (1-0:51.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L2].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L2].value == Decimal('0.000')
+
+        # INSTANTANEOUS_CURRENT_L3 (1-0:71.7.0)
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3], CosemObject)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].unit == 'A'
+        assert isinstance(result[obis.INSTANTANEOUS_CURRENT_L3].value, Decimal)
+        assert result[obis.INSTANTANEOUS_CURRENT_L3].value == Decimal('0.000')
+
+        # ACTUAL_SWITCH_POSITION (0-0:96.3.10)
+        assert isinstance(result[obis.ACTUAL_SWITCH_POSITION], CosemObject)
+        assert result[obis.ACTUAL_SWITCH_POSITION].unit is None
+        assert isinstance(result[obis.ACTUAL_SWITCH_POSITION].value, int)
+        assert result[obis.ACTUAL_SWITCH_POSITION].value == 1
+
+        # BELGIUM_MAX_POWER_PER_PHASE (0-0:17.0.0)
+        assert isinstance(result[obis.BELGIUM_MAX_POWER_PER_PHASE], CosemObject)
+        assert result[obis.BELGIUM_MAX_POWER_PER_PHASE].unit == 'kW'
+        assert isinstance(result[obis.BELGIUM_MAX_POWER_PER_PHASE].value, Decimal)
+        assert result[obis.BELGIUM_MAX_POWER_PER_PHASE].value == Decimal('999.9')
+
+        # BELGIUM_MAX_POWER_PER_PHASE (1-0:31.4.0)
+        assert isinstance(result[obis.BELGIUM_MAX_CURRENT_PER_PHASE], CosemObject)
+        assert result[obis.BELGIUM_MAX_CURRENT_PER_PHASE].unit == 'A'
+        assert isinstance(result[obis.BELGIUM_MAX_CURRENT_PER_PHASE].value, Decimal)
+        assert result[obis.BELGIUM_MAX_CURRENT_PER_PHASE].value == Decimal('999')
+
+        # TEXT_MESSAGE (0-0:96.13.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.TEXT_MESSAGE].unit is None
+        assert result[obis.TEXT_MESSAGE].value is None
+
+        # BELGIUM_MBUS1_DEVICE_TYPE (0-1:24.1.0)
+        assert isinstance(result[obis.BELGIUM_MBUS1_DEVICE_TYPE], CosemObject)
+        assert result[obis.BELGIUM_MBUS1_DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.BELGIUM_MBUS1_DEVICE_TYPE].value, int)
+        assert result[obis.BELGIUM_MBUS1_DEVICE_TYPE].value == 3
+
+        # BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER (0-1:96.1.1)
+        assert isinstance(result[obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER], CosemObject)
+        assert result[obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER].unit is None
+        assert isinstance(result[obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER].value, str)
+        assert result[obis.BELGIUM_MBUS1_EQUIPMENT_IDENTIFIER].value == '37464C4F32313139303333373333'
+
+        # BELGIUM_MBUS1_VALVE_POSITION (0-1:24.4.0)
+        assert isinstance(result[obis.BELGIUM_MBUS1_VALVE_POSITION], CosemObject)
+        assert result[obis.BELGIUM_MBUS1_VALVE_POSITION].unit is None
+        assert isinstance(result[obis.BELGIUM_MBUS1_VALVE_POSITION].value, int)
+        assert result[obis.BELGIUM_MBUS1_VALVE_POSITION].value == 1
+
+        # BELGIUM_MBUS1_METER_READING2 (0-1:24.2.3)
+        assert isinstance(result[obis.BELGIUM_MBUS1_METER_READING2], MBusObject)
+        assert result[obis.BELGIUM_MBUS1_METER_READING2].unit == 'm3'
+        assert isinstance(result[obis.BELGIUM_MBUS1_METER_READING2].value, Decimal)
+        assert result[obis.BELGIUM_MBUS1_METER_READING2].value == Decimal('112.384')
+
+        # BELGIUM_MBUS2_DEVICE_TYPE (0-2:24.1.0)
+        assert isinstance(result[obis.BELGIUM_MBUS2_DEVICE_TYPE], CosemObject)
+        assert result[obis.BELGIUM_MBUS2_DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.BELGIUM_MBUS2_DEVICE_TYPE].value, int)
+        assert result[obis.BELGIUM_MBUS2_DEVICE_TYPE].value == 7
+
+        # BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER (0-2:96.1.1)
+        assert isinstance(result[obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER], CosemObject)
+        assert result[obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER].unit is None
+        assert isinstance(result[obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER].value, str)
+        assert result[obis.BELGIUM_MBUS2_EQUIPMENT_IDENTIFIER].value == '3853414731323334353637383930'
+
+        # BELGIUM_MBUS2_METER_READING1 (0-1:24.2.1)
+        assert isinstance(result[obis.BELGIUM_MBUS2_METER_READING1], MBusObject)
+        assert result[obis.BELGIUM_MBUS2_METER_READING1].unit == 'm3'
+        assert isinstance(result[obis.BELGIUM_MBUS2_METER_READING1].value, Decimal)
+        assert result[obis.BELGIUM_MBUS2_METER_READING1].value == Decimal('872.234')
+
+    def test_checksum_valid(self):
+        # No exception is raised.
+        TelegramParser.validate_checksum(TELEGRAM_FLUVIUS_V171)
+
+    def test_checksum_invalid(self):
+        # Remove the electricty used data value. This causes the checksum to
+        # not match anymore.
+        corrupted_telegram = TELEGRAM_FLUVIUS_V171.replace(
+            '1-0:1.8.1(000000.034*kWh)\r\n',
+            ''
+        )
+
+        with self.assertRaises(InvalidChecksumError):
+            TelegramParser.validate_checksum(corrupted_telegram)
+
+    def test_checksum_missing(self):
+        # Remove the checksum value causing a ParseError.
+        corrupted_telegram = TELEGRAM_FLUVIUS_V171.replace('!911C\r\n', '')
+        with self.assertRaises(ParseError):
+            TelegramParser.validate_checksum(corrupted_telegram)
@@ -0,0 +1,107 @@
+from binascii import unhexlify
+from copy import deepcopy
+
+import unittest
+
+from dlms_cosem.exceptions import DecryptionError
+from dlms_cosem.protocol.xdlms import GeneralGlobalCipher
+from dlms_cosem.security import SecurityControlField, encrypt
+
+from dsmr_parser import telegram_specifications
+from dsmr_parser.exceptions import ParseError
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_SAGEMCOM_T210_D_R
+
+
+class TelegramParserEncryptedTest(unittest.TestCase):
+    """ Test parsing of a DSML encypted DSMR v5.x telegram. """
+    DUMMY_ENCRYPTION_KEY = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+    DUMMY_AUTHENTICATION_KEY = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
+
+    def __generate_encrypted(self, security_suite=0, authenticated=True, encrypted=True):
+        security_control = SecurityControlField(
+            security_suite=security_suite, authenticated=authenticated, encrypted=encrypted
+        )
+        encryption_key = unhexlify(self.DUMMY_ENCRYPTION_KEY)
+        authentication_key = unhexlify(self.DUMMY_AUTHENTICATION_KEY)
+        system_title = "SYSTEMID".encode("ascii")
+        invocation_counter = int.from_bytes(bytes.fromhex("10000001"), "big")
+        plain_data = TELEGRAM_SAGEMCOM_T210_D_R.encode("ascii")
+
+        encrypted = encrypt(
+            security_control=security_control,
+            key=encryption_key,
+            auth_key=authentication_key,
+            system_title=system_title,
+            invocation_counter=invocation_counter,
+            plain_text=plain_data,
+        )
+
+        full_frame = bytearray(GeneralGlobalCipher.TAG.to_bytes(1, "big", signed=False))
+        full_frame.extend(len(system_title).to_bytes(1, "big", signed=False))
+        full_frame.extend(system_title)
+        full_frame.extend([0x82])  # Length of the following length bytes
+        # https://github.com/pwitab/dlms-cosem/blob/739f81a58e5f07663a512d4a128851333a0ed5e6/dlms_cosem/a_xdr.py#L33
+
+        security_control = security_control.to_bytes()
+        invocation_counter = invocation_counter.to_bytes(4, "big", signed=False)
+        full_frame.extend((len(encrypted)
+                           + len(invocation_counter)
+                           + len(security_control)).to_bytes(2, "big", signed=False))
+        full_frame.extend(security_control)
+        full_frame.extend(invocation_counter)
+        full_frame.extend(encrypted)
+
+        return full_frame
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+        result = parser.parse(self.__generate_encrypted().hex(),
+                              self.DUMMY_ENCRYPTION_KEY,
+                              self.DUMMY_AUTHENTICATION_KEY)
+        self.assertEqual(len(result), 18)
+
+    def test_damaged_frame(self):
+        # If the frame is damaged decrypting fails (crc is technically not needed)
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+
+        generated = self.__generate_encrypted()
+        generated[150] = 0x00
+        generated = generated.hex()
+
+        with self.assertRaises(DecryptionError):
+            parser.parse(generated, self.DUMMY_ENCRYPTION_KEY, self.DUMMY_AUTHENTICATION_KEY)
+
+    def test_plain(self):
+        # If a plain request is parsed with "general_global_cipher": True it fails
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+
+        with self.assertRaises(Exception):
+            parser.parse(TELEGRAM_SAGEMCOM_T210_D_R, self.DUMMY_ENCRYPTION_KEY, self.DUMMY_AUTHENTICATION_KEY)
+
+    def test_general_global_cipher_not_specified(self):
+        # If a GGC frame is detected but general_global_cipher is not set it fails
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+        parser = deepcopy(parser)  # We do not want to change the module value
+        parser.telegram_specification['general_global_cipher'] = False
+
+        with self.assertRaises(ParseError):
+            parser.parse(self.__generate_encrypted().hex(), self.DUMMY_ENCRYPTION_KEY, self.DUMMY_AUTHENTICATION_KEY)
+
+    def test_only_encrypted(self):
+        # Not implemented by dlms_cosem
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+
+        only_auth = self.__generate_encrypted(0, authenticated=False, encrypted=True).hex()
+
+        with self.assertRaises(ValueError):
+            parser.parse(only_auth, self.DUMMY_ENCRYPTION_KEY)
+
+    def test_only_auth(self):
+        # Not implemented by dlms_cosem
+        parser = TelegramParser(telegram_specifications.SAGEMCOM_T210_D_R)
+
+        only_auth = self.__generate_encrypted(0, authenticated=True, encrypted=False).hex()
+
+        with self.assertRaises(ValueError):
+            parser.parse(only_auth, authentication_key=self.DUMMY_AUTHENTICATION_KEY)
@@ -5,6 +5,7 @@ deps=
  pylama
  pytest-asyncio
  pytest-mock
+  dlms_cosem
 commands=
  py.test --cov=dsmr_parser test {posargs}
  pylama dsmr_parser test
@@ -15,8 +16,11 @@ ignore = W0611
 [pylama:dsmr_parser/parsers.py]
 ignore = W605

+[pylama:test/example_telegrams.py]
+ignore = E501
+
 [pylama:pylint]
 max_line_length = 120

 [pylama:pycodestyle]
-max_line_length = 120
+max_line_length = 120
Author	SHA1	Message	Date
Nigel	ca8392504d	Release 1.1.0	2023-02-08 12:02:14 +01:00
Nigel	026b91cd49	Merge pull request #124 from yada75/reactive add instantaneous reactive power + fixed swapped reactive total import export	2023-01-28 13:32:32 +01:00
yada75	02eb3a34dd	Update obis_name_mapping.py	2023-01-18 20:02:54 +01:00
yada75	142b7359a1	Update telegram_specifications.py	2023-01-18 19:39:29 +01:00
yada75	21b8547655	Update obis_name_mapping.py	2023-01-18 19:34:35 +01:00
yada75	a2b9fe5e3b	Update obis_references.py	2023-01-18 19:31:39 +01:00
Nigel	0a259a3c9d	fix code style	2023-01-01 20:55:58 +01:00
Nigel	f851f48225	Merge pull request #118 from dennissiemensma/bug/readme-shield Fixed Shields badge in favor of badges/shields#8671	2023-01-01 20:37:24 +01:00
Nigel	3a3054324a	Merge pull request #116 from lowdef/add_pylama_backin_post_py36 add pylama back in + fix uniform style issues reported by pylama	2023-01-01 20:36:39 +01:00
Nigel	041ac758f4	Merge pull request #115 from robcalon/patch-1 asynchronous read_as_object method	2023-01-01 20:35:48 +01:00
Dennis Siemensma	d50d775e38	Fixed Shields badge in favor of badges/shields#8671	2022-12-30 21:05:17 +01:00
Nigel	10613acbd9	Merge pull request #114 from dupondje/fix_name_mapping Fix missing value from name mapping	2022-12-29 19:50:26 +01:00
Hans Erik van Elburg	5f58bc8f72	add pylama back in + fix uniform style issues reported by pylama	2022-12-27 18:58:48 +01:00
Rob Calon	371e1f3c5e	update docstring	2022-12-27 17:36:10 +01:00
Rob Calon	0eae28e183	correct rtype	2022-12-27 17:27:23 +01:00
Rob Calon	431ddadb5f	asynchronous read_as_object method fix inheritance of synchronous read_as_object method from parent	2022-12-27 17:20:24 +01:00
Jean-Louis Dupond	9e01dc32c0	Fix missing value from name mapping	2022-12-26 12:50:59 +01:00
Nigel	650d16862b	Fix changelog	2022-12-22 10:18:47 +01:00
Nigel	301a00e226	Prepare release 1.0.0	2022-12-22 10:13:26 +01:00
Nigel	d0cc429eda	Merge pull request #113 from dupondje/add_peakusage Add peakusage	2022-12-12 20:32:42 +01:00
Jean-Louis Dupond	d05fe2692b	Add support for Fluvius V1.7.1 DSMR messages These include (since 1.6) the water mater messages. And since 1.7.X also peak usage values. https://maakjemeterslim.be/rails/active_storage/blobs/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBZ0lEIiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--cdd9b48fd0838e89b177f03b745b23450fd8f53e/e-MUCS_P1_Ed_1_7_1.pdf?disposition=attachment	2022-12-12 20:27:53 +01:00
Dennis Siemensma	e80ba9862b	No longer run Python 3.6 in CI as it is end-of-life	2022-12-07 20:33:58 +01:00
Dennis Siemensma	cffcac2e87	Bump versions of Actions used in CI	2022-12-07 20:32:01 +01:00
Dennis Siemensma	357bae1bce	Run tests for Python 3.11 as well	2022-12-07 20:30:58 +01:00
Nigel	98a10998e9	Remove pylama because of incompatibility with python3.6, maybe find replacement	2022-10-19 14:20:29 +02:00
Nigel	00ac7c71be	Prepare version 0.34	2022-10-19 13:52:08 +02:00
Nigel	594db890fe	Merge pull request #110 from debug-richard/master Adds support for the Sagemcom T210-D-r smart meter	2022-10-16 12:49:55 +02:00
Richard Schleich	09f4afcada	Adds support for the Sagemcom T210-D-r smart meter installed by Austrian grid operators. The smart meter uses the DSMR/P1 standard and embeds the data in an encrypted and authenticated "DLMS General Global Cipher" frame. The encryption/decryption is handled by the "dlms_cosem" lib. Test cases are included. Adds OBIS codes for reactive energy.	2022-10-14 17:50:02 +02:00