Updated version number

Fix DSMR v5.0 serial settings which were not used

CHANGELOG.rst

@@ -1,9 +1,28 @@
 Change Log
 ----------
 
-**0.9** (2017-03-02)
+**0.13** (2019-03-04)
 
-- allow the telegram specification to optionally be autodetected
+- Fix DSMR v5.0 serial settings which were not used (`pull request #33 <https://github.com/ndokter/dsmr_parser/pull/33>`_).
+
+**0.12** (2018-09-23)
+
+- Add serial settings for DSMR v5.0 (`pull request #31 <https://github.com/ndokter/dsmr_parser/pull/31>`_).
+- Lux-creos-obis-1.8.0 (`pull request #32 <https://github.com/ndokter/dsmr_parser/pull/32>`_). 
+
+**0.11** (2017-09-18)
+
+- NULL value fix in checksum (`pull request #26 <https://github.com/ndokter/dsmr_parser/pull/26>`_)
+
+**0.10** (2017-06-05)
+
+- bugix: don't force full telegram signatures (`pull request #25 <https://github.com/ndokter/dsmr_parser/pull/25>`_)
+- removed unused code for automatic telegram detection as this needs reworking after the fix mentioned above
+- InvalidChecksumError's are logged as warning instead of error
+
+**0.9** (2017-05-12)
+
+- added DSMR v5 serial settings
 
 **0.8** (2017-01-26)
 

README.rst

@@ -54,6 +54,7 @@ into a dictionary.
      from dsmr_parser import telegram_specifications
      from dsmr_parser.parsers import TelegramParser
 
+     # String is formatted in separate lines for readability.
      telegram_str = (
          '/ISk5\2MT382-1000\r\n'
          '\r\n'

dsmr_parser/clients/__init__.py

@@ -1,5 +1,5 @@
 from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
-    SERIAL_SETTINGS_V4
+    SERIAL_SETTINGS_V4, SERIAL_SETTINGS_V5
 from dsmr_parser.clients.serial_ import SerialReader, AsyncSerialReader
 from dsmr_parser.clients.protocol import create_dsmr_protocol, \
     create_dsmr_reader, create_tcp_dsmr_reader

dsmr_parser/clients/protocol.py

@@ -8,10 +8,10 @@ from serial_asyncio import create_serial_connection
 
 from dsmr_parser import telegram_specifications
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
-from dsmr_parser.exceptions import ParseError
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 from dsmr_parser.parsers import TelegramParser
 from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
-    SERIAL_SETTINGS_V4
+    SERIAL_SETTINGS_V4, SERIAL_SETTINGS_V5
 
 
 def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
@@ -23,6 +23,9 @@ def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
     elif dsmr_version == '4':
         specification = telegram_specifications.V4
         serial_settings = SERIAL_SETTINGS_V4
+    elif dsmr_version == '5':
+        specification = telegram_specifications.V5
+        serial_settings = SERIAL_SETTINGS_V5
     else:
         raise NotImplementedError("No telegram parser found for version: %s",
                                   dsmr_version)
@@ -98,6 +101,8 @@ class DSMRProtocol(asyncio.Protocol):
 
         try:
             parsed_telegram = self.telegram_parser.parse(telegram)
+        except InvalidChecksumError as e:
+            self.log.warning(str(e))
         except ParseError:
             self.log.exception("failed to parse telegram")
         else:

dsmr_parser/clients/serial_.py

@@ -4,7 +4,7 @@ import serial
 import serial_asyncio
 
 from dsmr_parser.clients.telegram_buffer import TelegramBuffer
-from dsmr_parser.exceptions import ParseError
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 from dsmr_parser.parsers import TelegramParser
 
 
@@ -36,6 +36,8 @@ class SerialReader(object):
                 for telegram in self.telegram_buffer.get_all():
                     try:
                         yield self.telegram_parser.parse(telegram)
+                    except InvalidChecksumError as e:
+                        logger.warning(str(e))
                     except ParseError as e:
                         logger.error('Failed to parse telegram: %s', e)
 

dsmr_parser/clients/settings.py

@@ -20,3 +20,13 @@ SERIAL_SETTINGS_V4 = {
     'rtscts': 0,
     'timeout': 20
 }
+
+SERIAL_SETTINGS_V5 = {
+    'baudrate': 115200,
+    'bytesize': serial.EIGHTBITS,
+    'parity': serial.PARITY_NONE,
+    'stopbits': serial.STOPBITS_ONE,
+    'xonxoff': 0,
+    'rtscts': 0,
+    'timeout': 20
+}

dsmr_parser/clients/telegram_buffer.py

@@ -51,7 +51,7 @@ class TelegramBuffer(object):
         # - The checksum is optional '{0,4}' because not all telegram versions
         # support it.
         return re.findall(
-            r'\/[^\/]+?\![A-F0-9]{0,4}\r\n',
+            r'\/[^\/]+?\![A-F0-9]{0,4}\0?\r\n',
             self._buffer,
             re.DOTALL
         )

dsmr_parser/exceptions.py

@@ -4,7 +4,3 @@ class ParseError(Exception):
 
 class InvalidChecksumError(ParseError):
     pass
-
-
-class TelegramSpecificationMatchError(ParseError):
-    pass

dsmr_parser/obis_references.py

@@ -8,6 +8,7 @@ objects are introduced.
 """
 P1_MESSAGE_HEADER = r'\d-\d:0\.2\.8.+?\r\n'
 P1_MESSAGE_TIMESTAMP = r'\d-\d:1\.0\.0.+?\r\n'
+ELECTRICITY_IMPORTED_TOTAL = r'\d-\d:1\.8\.0.+?\r\n'
 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'
@@ -17,6 +18,7 @@ EQUIPMENT_IDENTIFIER = r'\d-\d:96\.1\.1.+?\r\n'
 CURRENT_ELECTRICITY_USAGE = r'\d-\d:1\.7\.0.+?\r\n'
 CURRENT_ELECTRICITY_DELIVERY = r'\d-\d:2\.7\.0.+?\r\n'
 LONG_POWER_FAILURE_COUNT = r'96\.7\.9.+?\r\n'
+SHORT_POWER_FAILURE_COUNT = r'96\.7\.21.+?\r\n'
 POWER_EVENT_FAILURE_LOG = r'99\.97\.0.+?\r\n'
 VOLTAGE_SAG_L1_COUNT = r'\d-\d:32\.32\.0.+?\r\n'
 VOLTAGE_SAG_L2_COUNT = r'\d-\d:52\.32\.0.+?\r\n'
@@ -24,6 +26,12 @@ VOLTAGE_SAG_L3_COUNT = r'\d-\d:72\.32\.0.+?\r\n'
 VOLTAGE_SWELL_L1_COUNT = r'\d-\d:32\.36\.0.+?\r\n'
 VOLTAGE_SWELL_L2_COUNT = r'\d-\d:52\.36\.0.+?\r\n'
 VOLTAGE_SWELL_L3_COUNT = r'\d-\d:72\.36\.0.+?\r\n'
+INSTANTANEOUS_VOLTAGE_L1 = r'\d-\d:32\.7\.0.+?\r\n'
+INSTANTANEOUS_VOLTAGE_L2 = r'\d-\d:52\.7\.0.+?\r\n'
+INSTANTANEOUS_VOLTAGE_L3 = r'\d-\d:72\.7\.0.+?\r\n'
+INSTANTANEOUS_CURRENT_L1 = r'\d-\d:31\.7\.0.+?\r\n'
+INSTANTANEOUS_CURRENT_L2 = r'\d-\d:51\.7\.0.+?\r\n'
+INSTANTANEOUS_CURRENT_L3 = r'\d-\d:71\.7\.0.+?\r\n'
 TEXT_MESSAGE_CODE = r'\d-\d:96\.13\.1.+?\r\n'
 TEXT_MESSAGE = r'\d-\d:96\.13\.0.+?\r\n'
 DEVICE_TYPE = r'\d-\d:24\.1\.0.+?\r\n'

dsmr_parser/parsers.py

@@ -4,18 +4,16 @@ import re
 from PyCRC.CRC16 import CRC16
 
 from dsmr_parser.objects import MBusObject, CosemObject
-from dsmr_parser.exceptions import ParseError, InvalidChecksumError, \
-    TelegramSpecificationMatchError
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
 
 logger = logging.getLogger(__name__)
 
 
 class TelegramParser(object):
 
-    def __init__(self, telegram_specification=None, apply_checksum_validation=True):
+    def __init__(self, telegram_specification, apply_checksum_validation=True):
         """
-        :param telegram_specification: determines how the telegram is parsed.
-            Will attempt to autodetect if omitted.
+        :param telegram_specification: determines how the telegram is parsed
         :param apply_checksum_validation: validate checksum if applicable for
             telegram DSMR version (v4 and up).
         :type telegram_specification: dict
@@ -41,10 +39,8 @@ class TelegramParser(object):
                 ..
             }
         :raises ParseError:
+        :raises InvalidChecksumError:
         """
-        if not self.telegram_specification:
-            self.telegram_specification = \
-                match_telegram_specification(telegram_data)
 
         if self.apply_checksum_validation \
                 and self.telegram_specification['checksum_support']:
@@ -55,12 +51,10 @@ class TelegramParser(object):
         for signature, parser in self.telegram_specification['objects'].items():
             match = re.search(signature, telegram_data, re.DOTALL)
 
-            # All telegram specification lines/signatures are expected to be
-            # present.
-            if not match:
-                raise ParseError('Telegram specification does not match '
-                                 'telegram data')
-            telegram[signature] = parser.parse(match.group(0))
+            # Some signatures are optional and may not be present,
+            # so only parse lines that match
+            if match:
+                telegram[signature] = parser.parse(match.group(0))
 
         return telegram
 
@@ -98,36 +92,6 @@ class TelegramParser(object):
             )
 
 
-def match_telegram_specification(telegram_data):
-    """
-    Find telegram specification that matches the telegram data by trying all
-    specifications.
-
-    Could be further optimized to check the actual 0.2.8 OBIS reference which
-    is available for DSMR version 4 and up.
-
-    :param str telegram_data: full telegram from start ('/') to checksum
-            ('!ABCD') including line endings in between the telegram's lines
-    :return: telegram specification
-    :rtype: dict
-    """
-    # Prevent circular import
-    from dsmr_parser import telegram_specifications
-
-    for specification in telegram_specifications.ALL:
-        try:
-            TelegramParser(specification).parse(telegram_data)
-        except ParseError:
-            pass
-        else:
-            return specification
-
-    raise TelegramSpecificationMatchError(
-        'Could automatically match telegram specification. Make sure the data'
-        'is not corrupt. Alternatively manually specify one.'
-    )
-
-
 class DSMRObjectParser(object):
     """
     Parses an object (can also be see as a 'line') from a telegram.
@@ -185,10 +149,11 @@ class CosemParser(DSMRObjectParser):
     1  23  45
 
     1) OBIS Reduced ID-code
-    2) Separator “(“, ASCII 28h
+    2) Separator "(", ASCII 28h
     3) COSEM object attribute value
-    4) Unit of measurement values (Unit of capture objects attribute) – only if applicable
-    5) Separator “)”, ASCII 29h
+    4) Unit of measurement values (Unit of capture objects attribute) - only if
+       applicable
+    5) Separator ")", ASCII 29h
     """
 
     def parse(self, line):

dsmr_parser/telegram_specifications.py

@@ -88,6 +88,7 @@ V5 = {
         obis.P1_MESSAGE_HEADER: CosemParser(ValueParser(str)),
         obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
         obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        obis.ELECTRICITY_IMPORTED_TOTAL: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_USED_TARIFF_1: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_USED_TARIFF_2: CosemParser(ValueParser(Decimal)),
         obis.ELECTRICITY_DELIVERED_TARIFF_1: CosemParser(ValueParser(Decimal)),
@@ -96,6 +97,7 @@ V5 = {
         obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
         obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
         obis.LONG_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
+        obis.SHORT_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
         # POWER_EVENT_FAILURE_LOG: ProfileGenericParser(), TODO
         obis.VOLTAGE_SAG_L1_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SAG_L2_COUNT: CosemParser(ValueParser(int)),
@@ -103,6 +105,12 @@ V5 = {
         obis.VOLTAGE_SWELL_L1_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SWELL_L2_COUNT: CosemParser(ValueParser(int)),
         obis.VOLTAGE_SWELL_L3_COUNT: CosemParser(ValueParser(int)),
+        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.TEXT_MESSAGE: CosemParser(ValueParser(str)),
         obis.DEVICE_TYPE: CosemParser(ValueParser(int)),
         obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: CosemParser(ValueParser(Decimal)),

setup.py

@@ -4,9 +4,9 @@ setup(
     name='dsmr-parser',
     description='Library to parse Dutch Smart Meter Requirements (DSMR)',
     author='Nigel Dokter',
-    author_email='nigeldokter@gmail.com',
+    author_email='nigel@nldr.net',
     url='https://github.com/ndokter/dsmr_parser',
-    version='0.9',
+    version='0.13',
     packages=find_packages(),
     install_requires=[
         'pyserial>=3,<4',

test/test_match_telegram_specification.py

@@ -1,29 +0,0 @@
-import unittest
-
-from dsmr_parser.exceptions import TelegramSpecificationMatchError
-from dsmr_parser.parsers import match_telegram_specification
-from dsmr_parser import telegram_specifications
-from test import example_telegrams
-
-
-class MatchTelegramSpecificationTest(unittest.TestCase):
-
-    def test_v2_2(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V2_2) \
-           == telegram_specifications.V2_2
-
-    def test_v3(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V3) \
-           == telegram_specifications.V3
-
-    def test_v4_2(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V4_2) \
-           == telegram_specifications.V4
-
-    def test_v5(self):
-        assert match_telegram_specification(example_telegrams.TELEGRAM_V5) \
-           == telegram_specifications.V5
-
-    def test_malformed_telegram(self):
-        with self.assertRaises(TelegramSpecificationMatchError):
-            match_telegram_specification(example_telegrams.TELEGRAM_V5[:-4])

test/test_parse_v2_2.py

@@ -12,15 +12,6 @@ from test.example_telegrams import TELEGRAM_V2_2
 class TelegramParserV2_2Test(unittest.TestCase):
     """ Test parsing of a DSMR v2.2 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V2_2)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V2_2
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V2_2)
         result = parser.parse(TELEGRAM_V2_2)

test/test_parse_v3.py

@@ -12,15 +12,6 @@ from test.example_telegrams import TELEGRAM_V3
 class TelegramParserV3Test(unittest.TestCase):
     """ Test parsing of a DSMR v3 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V3)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V3
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V3)
         result = parser.parse(TELEGRAM_V3)

test/test_parse_v4_2.py

@@ -15,15 +15,6 @@ from test.example_telegrams import TELEGRAM_V4_2
 class TelegramParserV4_2Test(unittest.TestCase):
     """ Test parsing of a DSMR v4.2 telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V4_2)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V4
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V4)
         result = parser.parse(TELEGRAM_V4_2)

test/test_parse_v5.py

@@ -16,15 +16,6 @@ from test.example_telegrams import TELEGRAM_V5
 class TelegramParserV5Test(unittest.TestCase):
     """ Test parsing of a DSMR v5.x telegram. """
 
-    def test_telegram_specification_matching(self):
-        parser = TelegramParser()
-        parser.parse(TELEGRAM_V5)
-
-        self.assertEqual(
-            parser.telegram_specification,
-            telegram_specifications.V5
-        )
-
     def test_parse(self):
         parser = TelegramParser(telegram_specifications.V5)
         result = parser.parse(TELEGRAM_V5)
@@ -96,6 +87,12 @@ class TelegramParserV5Test(unittest.TestCase):
         assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT].value, int)
         assert result[obis.LONG_POWER_FAILURE_COUNT].value == 0
 
+        # SHORT_POWER_FAILURE_COUNT (1-0:96.7.21)
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].unit is None
+        assert isinstance(result[obis.SHORT_POWER_FAILURE_COUNT].value, int)
+        assert result[obis.SHORT_POWER_FAILURE_COUNT].value == 13
+
         # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
         assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT], CosemObject)
         assert result[obis.VOLTAGE_SAG_L1_COUNT].unit is None
@@ -132,6 +129,42 @@ class TelegramParserV5Test(unittest.TestCase):
         assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT].value, int)
         assert result[obis.VOLTAGE_SWELL_L3_COUNT].value == 0
 
+        # 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('230.0')
+
+        # 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('230.0')
+
+        # 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('229.0')
+
+        # 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.48')
+
+        # 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.44')
+
+        # 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.86')
+
         # TEXT_MESSAGE (0-0:96.13.0)
         assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
         assert result[obis.TEXT_MESSAGE].unit is None