Revert "fix for empty parentheses in ProfileGenericParser"

preparation for v0.25
Merge branch 'master' of github.com:ndokter/dsmr_parser
2020-12-15 14:59:35 +01:00 · 2020-12-14 17:21:16 +01:00 · 2020-12-14 17:16:55 +01:00 · 2020-12-14 16:55:38 +01:00 · 2020-12-13 13:22:15 +01:00 · 2020-12-13 12:15:51 +00:00
34 changed files with 2813 additions and 319 deletions
@@ -0,0 +1,2 @@
+[run]
+branch = True
@@ -2,4 +2,13 @@
 *.pyc
 .tox
 .cache
+.venv
 *.egg-info
+/.project
+/.pydevproject
+/.coverage
+build/
+dist/
+venv/
+*.*~
+*~
@@ -1,10 +1,18 @@
 language: python
+
 python:
  - 2.7
-  - 3.4
  - 3.5
-install: pip install tox-travis
+  - 3.6
+  - 3.8
+  
+install: pip install tox-travis codecov
+
 script: tox
+
+after_success:
+  - codecov
+
 matrix:
  allow_failures:
    - python: 2.7
@@ -1,9 +1,126 @@
 Change Log
 ----------
+
+**0.25** (2020-12-14)
+- fix for empty parentheses in ProfileGenericParser (`pull request #57 <https://github.com/ndokter/dsmr_parser/pull/57>`_).
+
+**0.24** (2020-11-27)
+- Add Luxembourg equipment identifier (`pull request #62 <https://github.com/ndokter/dsmr_parser/pull/62>`_).
+
+**0.23** (2020-11-07)
+- Resolved issue with x-x:24.3.0 where it contains non-integer character (`pull request #61 <https://github.com/ndokter/dsmr_parser/pull/61>`_).
+- Tests are not installed anymore (`pull request #59 <https://github.com/ndokter/dsmr_parser/pull/59>`_).
+- Example telegram improvement (`pull request #58 <https://github.com/ndokter/dsmr_parser/pull/58>`_).
+
+**0.22** (2020-08-23)
+
+- CRC check speed is improved
+- Exception info improvement
+
+**0.21** (2020-05-25)
+
+- All objects can produce a json serialization of their state.
+
+**0.20** (2020-05-12)
+
+- All objects can now print their values
+- Add parser + object for generic profile
+
+**0.19** (2020-05-03)
+
+- Add following missing elements to telegram specification v4:
+    - SHORT_POWER_FAILURE_COUNT,
+    - INSTANTANEOUS_CURRENT_L1,
+    - INSTANTANEOUS_CURRENT_L2,
+    - INSTANTANEOUS_CURRENT_L3
+- Add missing tests + fix small test bugs
+- Complete telegram object v4 parse test
+
+**0.18** (2020-01-28)
+
+- PyCRC replacement (`pull request #48 <https://github.com/ndokter/dsmr_parser/pull/48>`_).
+
+**0.17** (2019-12-21)
+
+- Add a true telegram object (`pull request #40 <https://github.com/ndokter/dsmr_parser/pull/40>`_).
+
+**0.16** (2019-12-21)
+
+- Add support for Belgian and Smarty meters (`pull request #44 <https://github.com/ndokter/dsmr_parser/pull/44>`_).
+
+**0.15** (2019-12-12)
+
+- Fixed asyncio loop issue (`pull request #43 <https://github.com/ndokter/dsmr_parser/pull/43>`_).
+
+**0.14** (2019-10-08)
+
+- Changed serial reading to reduce CPU usage (`pull request #37 <https://github.com/ndokter/dsmr_parser/pull/37>`_).
+
+**0.13** (2019-03-04)
+
+- 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)
+
+- bugfix: 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)
+
+- added support for DSMR v3
+- added support for DSMR v5
+
+**IMPORTANT: this release has the following backwards incompatible changes:**
+
+- Removed TelegramParserV2_2 in favor of TelegramParser
+- Removed TelegramParserV4 in favor of TelegramParser
+
+**0.7** (2017-01-14)
+
+- Internal refactoring related to the way clients feed their data into the parse module. Clients can now supply the telegram data in single characters, lines (which was common) or complete telegram strings. (`pull request #17 <https://github.com/ndokter/dsmr_parser/pull/17>`_)
+
+**IMPORTANT: this release has the following backwards incompatible changes:**
+
+- Client related imports from dsmr_parser.serial and dsmr_parser.protocol have been moved to dsmr_parser.clients (import these from the clients/__init__.py module)
+- The .parse() method of TelegramParser, TelegramParserV2_2, TelegramParserV4 now accepts a string containing the entire telegram (including \r\n characters) and not a list
+
+
+**0.6** (2017-01-04)
+
+- Fixed bug in CRC checksum verification for the asyncio client (`pull request #15 <https://github.com/ndokter/dsmr_parser/pull/15>`_)
+- Support added for TCP connections using the asyncio client (`pull request #12 <https://github.com/ndokter/dsmr_parser/pull/12/>`_)
+
+**0.5** (2016-12-29)
+
+- CRC checksum verification for DSMR v4 telegrams (`issue #10 <https://github.com/ndokter/dsmr_parser/issues/10>`_)
+
+**0.4** (2016-11-21)
+
+- DSMR v2.2 serial settings now uses parity serial.EVEN by default (`pull request #5 <https://github.com/ndokter/dsmr_parser/pull/5>`_)
+- improved asyncio reader and improve it's error handling (`pull request #8 <https://github.com/ndokter/dsmr_parser/pull/8>`_)
+
+**0.3** (2016-11-12)
+
+- asyncio reader for non-blocking reads (`pull request #3 <https://github.com/ndokter/dsmr_parser/pull/3>`_)
+
 **0.2** (2016-11-08)

- User https://github.com/aequitas added support for DMSR version 2.2
+- support for DMSR version 2.2 (`pull request #2 <https://github.com/ndokter/dsmr_parser/pull/2>`_)

 **0.1** (2016-08-22)

- Initial version with a serial reader and support for DSMR version 4.x
+- initial version with a serial reader and support for DSMR version 4.x
@@ -4,51 +4,248 @@ DSMR Parser
 .. image:: https://img.shields.io/pypi/v/dsmr-parser.svg
    :target: https://pypi.python.org/pypi/dsmr-parser

+.. image:: https://travis-ci.org/ndokter/dsmr_parser.svg?branch=master
+    :target: https://travis-ci.org/ndokter/dsmr_parser
+
 A library for parsing Dutch Smart Meter Requirements (DSMR) telegram data. It
-also includes a serial client to directly read and parse smart meter data.
+also includes client implementation to directly read and parse smart meter data.


 Features
 --------

-DSMR Parser currently supports DSMR versions 2.2 and 4.x. It has been tested with Python 3.5
+DSMR Parser supports DSMR versions 2, 3, 4 and 5. It has been tested with Python 3.4, 3.5 and 3.6.


-Examples
--------
+Client module usage
+-------------------

-Using the serial reader to connect to your smart meter and parse it's telegrams:
+**Serial client**
+
+Read the serial port and work with the parsed telegrams. It should be run in a separate
+process because the code is blocking (not asynchronous):

 .. code-block:: python

+     from dsmr_parser import telegram_specifications
+     from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V4
+    
+     serial_reader = SerialReader(
+         device='/dev/ttyUSB0',
+         serial_settings=SERIAL_SETTINGS_V4,
+         telegram_specification=telegram_specifications.V4
+     )
+    
+     for telegram in serial_reader.read():
+         print(telegram)  # see 'Telegram object' docs below
+
+**AsyncIO client**
+
+To be documented.
+
+
+Parsing module usage
+--------------------
+The parsing module accepts complete unaltered telegram strings and parses these
+into a dictionary.
+
+.. code-block:: python
+
+     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'
+         '0-0:96.1.1(4B384547303034303436333935353037)\r\n'
+         '1-0:1.8.1(12345.678*kWh)\r\n'
+         '1-0:1.8.2(12345.678*kWh)\r\n'
+         '1-0:2.8.1(12345.678*kWh)\r\n'
+         '1-0:2.8.2(12345.678*kWh)\r\n'
+         '0-0:96.14.0(0002)\r\n'
+         '1-0:1.7.0(001.19*kW)\r\n'
+         '1-0:2.7.0(000.00*kW)\r\n'
+         '0-0:17.0.0(016*A)\r\n'
+         '0-0:96.3.10(1)\r\n'
+         '0-0:96.13.1(303132333435363738)\r\n'
+         '0-0:96.13.0(303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E'
+         '3F303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E3F30313233'
+         '3435363738393A3B3C3D3E3F)\r\n'
+         '0-1:96.1.0(3232323241424344313233343536373839)\r\n'
+         '0-1:24.1.0(03)\r\n'
+         '0-1:24.3.0(090212160000)(00)(60)(1)(0-1:24.2.1)(m3)\r\n'
+         '(00001.001)\r\n'
+         '0-1:24.4.0(1)\r\n'
+         '!\r\n'
+     )
+
+     parser = TelegramParser(telegram_specifications.V3)
+    
+     telegram = parser.parse(telegram_str)
+     print(telegram)  # see 'Telegram object' docs below
+
+Telegram dictionary
+-------------------
+
+A dictionary of which the key indicates the field type. These regex values
+correspond to one of dsmr_parser.obis_reference constants.
+
+The value is either a CosemObject or MBusObject. These have a 'value' and 'unit'
+property. MBusObject's additionally have a 'datetime' property. The 'value' can
+contain any python type (int, str, Decimal) depending on the field. The 'unit'
+contains 'kW', 'A', 'kWh' or 'm3'.
+
+.. code-block:: python
+
+    # Contents of a parsed DSMR v3 telegram
+    {'\\d-\\d:17\\.0\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39eb8>,
+     '\\d-\\d:1\\.7\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10f916390>,
+     '\\d-\\d:1\\.8\\.1.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39e10>,
+     '\\d-\\d:1\\.8\\.2.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39ef0>,
+     '\\d-\\d:24\\.1\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fbaef28>,
+     '\\d-\\d:24\\.3\\.0.+?\\r\\n.+?\\r\\n': <dsmr_parser.objects.MBusObject object at 0x10f9163c8>,
+     '\\d-\\d:24\\.4\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39f60>,
+     '\\d-\\d:2\\.7\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39fd0>,
+     '\\d-\\d:2\\.8\\.1.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fbaee10>,
+     '\\d-\\d:2\\.8\\.2.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39e80>,
+     '\\d-\\d:96\\.13\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39d30>,
+     '\\d-\\d:96\\.13\\.1.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fbaeeb8>,
+     '\\d-\\d:96\\.14\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fbaef98>,
+     '\\d-\\d:96\\.1\\.0.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fbaef60>,
+     '\\d-\\d:96\\.1\\.1.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39f98>,
+     '\\d-\\d:96\\.3\\.10.+?\\r\\n': <dsmr_parser.objects.CosemObject object at 0x10fc39dd8>}
+
+Example to get some of the values:
+
+.. code-block:: python
+
+    from dsmr_parser import obis_references
+
+     # The telegram message timestamp.
+     message_datetime = telegram[obis_references.P1_MESSAGE_TIMESTAMP]
+
+     # Using the active tariff to determine the electricity being used and
+     # delivered for the right tariff.
+     active_tariff = telegram[obis_references.ELECTRICITY_ACTIVE_TARIFF]
+     active_tariff = int(tariff.value)
+
+     electricity_used_total = telegram[obis_references.ELECTRICITY_USED_TARIFF_ALL[active_tariff - 1]]
+     electricity_delivered_total = telegram[obis_references.ELECTRICITY_DELIVERED_TARIFF_ALL[active_tariff - 1]]
+
+     gas_reading = telegram[obis_references.HOURLY_GAS_METER_READING]
+
+    # See dsmr_reader.obis_references for all readable telegram values.
+    # Note that the avilable values differ per DSMR version.
+
+Telegram as an Object
+---------------------
+An object version of the telegram is available as well.
+
+
+.. code-block:: python
+
+    # DSMR v4.2 p1 using dsmr_parser and telegram objects
+
    from dsmr_parser import telegram_specifications
-    from dsmr_parser.obis_references import P1_MESSAGE_TIMESTAMP
-    from dsmr_parser.serial import SerialReader, SERIAL_SETTINGS_V4
+    from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V5
+    from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+    from dsmr_parser.parsers import TelegramParser
+    import os

    serial_reader = SerialReader(
        device='/dev/ttyUSB0',
-        serial_settings=SERIAL_SETTINGS_V4,
+        serial_settings=SERIAL_SETTINGS_V5,
        telegram_specification=telegram_specifications.V4
    )

-    for telegram in serial_reader.read():
+    # telegram = next(serial_reader.read_as_object())
+    # print(telegram)

-        # The telegram message timestamp.
-        message_datetime = telegram[P1_MESSAGE_TIMESTAMP]
+    for telegram in serial_reader.read_as_object():
+        os.system('clear')
+        print(telegram)

-        # Using the active tariff to determine the electricity being used and
-        # delivered for the right tariff.
-        tariff = telegram[ELECTRICITY_ACTIVE_TARIFF]
-        tariff = int(tariff.value)
+Example of output of print of the telegram object:

-        electricity_used_total \
-            = telegram[ELECTRICITY_USED_TARIFF_ALL[tariff - 1]]
-        electricity_delivered_total = \
-            telegram[ELECTRICITY_DELIVERED_TARIFF_ALL[tariff - 1]]
+.. code-block:: console

-        gas_reading = telegram[HOURLY_GAS_METER_READING]
+    P1_MESSAGE_HEADER: 	 42 	[None]
+    P1_MESSAGE_TIMESTAMP: 	 2016-11-13 19:57:57+00:00 	[None]
+    EQUIPMENT_IDENTIFIER: 	 3960221976967177082151037881335713 	[None]
+    ELECTRICITY_USED_TARIFF_1: 	 1581.123 	[kWh]
+    ELECTRICITY_USED_TARIFF_2: 	 1435.706 	[kWh]
+    ELECTRICITY_DELIVERED_TARIFF_1: 	 0.000 	[kWh]
+    ELECTRICITY_DELIVERED_TARIFF_2: 	 0.000 	[kWh]
+    ELECTRICITY_ACTIVE_TARIFF: 	 0002 	[None]
+    CURRENT_ELECTRICITY_USAGE: 	 2.027 	[kW]
+    CURRENT_ELECTRICITY_DELIVERY: 	 0.000 	[kW]
+    LONG_POWER_FAILURE_COUNT: 	 7 	[None]
+    VOLTAGE_SAG_L1_COUNT: 	 0 	[None]
+    VOLTAGE_SAG_L2_COUNT: 	 0 	[None]
+    VOLTAGE_SAG_L3_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L1_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L2_COUNT: 	 0 	[None]
+    VOLTAGE_SWELL_L3_COUNT: 	 0 	[None]
+    TEXT_MESSAGE_CODE: 	 None 	[None]
+    TEXT_MESSAGE: 	 None 	[None]
+    DEVICE_TYPE: 	 3 	[None]
+    INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 	 0.170 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 	 1.247 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 	 0.209 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE: 	 0.000 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE: 	 0.000 	[kW]
+    INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE: 	 0.000 	[kW]
+    EQUIPMENT_IDENTIFIER_GAS: 	 4819243993373755377509728609491464 	[None]
+    HOURLY_GAS_METER_READING: 	 981.443 	[m3]

-        # See dsmr_reader.obis_references for all readable telegram values.
+Accessing the telegrams information as  attributes directly:
+
+.. code-block:: python
+
+    telegram
+    Out[3]: <dsmr_parser.objects.Telegram at 0x7f5e995d9898>
+    telegram.CURRENT_ELECTRICITY_USAGE
+    Out[4]: <dsmr_parser.objects.CosemObject at 0x7f5e98ae5ac8>
+    telegram.CURRENT_ELECTRICITY_USAGE.value
+    Out[5]: Decimal('2.027')
+    telegram.CURRENT_ELECTRICITY_USAGE.unit
+    Out[6]: 'kW'
+
+The telegram object has an iterator, can be used to find all the information elements in the current telegram:
+
+.. code-block:: python
+
+    [attr for attr, value in telegram]
+    Out[11]:
+    ['P1_MESSAGE_HEADER',
+     'P1_MESSAGE_TIMESTAMP',
+     'EQUIPMENT_IDENTIFIER',
+     'ELECTRICITY_USED_TARIFF_1',
+     'ELECTRICITY_USED_TARIFF_2',
+     'ELECTRICITY_DELIVERED_TARIFF_1',
+     'ELECTRICITY_DELIVERED_TARIFF_2',
+     'ELECTRICITY_ACTIVE_TARIFF',
+     'CURRENT_ELECTRICITY_USAGE',
+     'CURRENT_ELECTRICITY_DELIVERY',
+     'LONG_POWER_FAILURE_COUNT',
+     'VOLTAGE_SAG_L1_COUNT',
+     'VOLTAGE_SAG_L2_COUNT',
+     'VOLTAGE_SAG_L3_COUNT',
+     'VOLTAGE_SWELL_L1_COUNT',
+     'VOLTAGE_SWELL_L2_COUNT',
+     'VOLTAGE_SWELL_L3_COUNT',
+     'TEXT_MESSAGE_CODE',
+     'TEXT_MESSAGE',
+     'DEVICE_TYPE',
+     'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
+     'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
+     'EQUIPMENT_IDENTIFIER_GAS',
+     'HOURLY_GAS_METER_READING']


 Installation
@@ -60,10 +257,10 @@ To install DSMR Parser:

    $ pip install dsmr-parser

+Known issues
+------------

-TODO
----
-
- add unit tests
- verify telegram checksum
- improve ease of use
+If the serial settings SERIAL_SETTINGS_V2_2 or SERIAL_SETTINGS_V4 don't work.
+Make sure to try and replace the parity settings to EVEN or NONE.
+It's possible that alternative settings will be added in the future if these
+settings don't work for the majority of meters.
@@ -1,6 +1,9 @@
+from functools import partial
 import argparse
-from dsmr_parser.serial import SERIAL_SETTINGS_V2_2, SERIAL_SETTINGS_V4, SerialReader
-from dsmr_parser import telegram_specifications
+import asyncio
+import logging
+
+from dsmr_parser.clients import create_dsmr_reader, create_tcp_dsmr_reader


 def console():
@@ -9,24 +12,54 @@ def console():
    parser = argparse.ArgumentParser(description=console.__doc__)
    parser.add_argument('--device', default='/dev/ttyUSB0',
                        help='port to read DSMR data from')
+    parser.add_argument('--host', default=None,
+                        help='alternatively connect using TCP host.')
+    parser.add_argument('--port', default=None,
+                        help='TCP port to use for connection')
    parser.add_argument('--version', default='2.2', choices=['2.2', '4'],
                        help='DSMR version (2.2, 4)')
+    parser.add_argument('--verbose', '-v', action='count')

    args = parser.parse_args()

-    settings = {
-        '2.2': (SERIAL_SETTINGS_V2_2, telegram_specifications.V2_2),
-        '4': (SERIAL_SETTINGS_V4, telegram_specifications.V4),
-    }
+    if args.verbose:
+        level = logging.DEBUG
+    else:
+        level = logging.ERROR
+    logging.basicConfig(level=level)

-    serial_reader = SerialReader(
-        device=args.device,
-        serial_settings=settings[args.version][0],
-        telegram_specification=settings[args.version][1],
-    )
+    loop = asyncio.get_event_loop()

-    for telegram in serial_reader.read():
+    def print_callback(telegram):
+        """Callback that prints telegram values."""
        for obiref, obj in telegram.items():
            if obj:
                print(obj.value, obj.unit)
        print()
+
+    # create tcp or serial connection depending on args
+    if args.host and args.port:
+        create_connection = partial(create_tcp_dsmr_reader,
+                                    args.host, args.port, args.version,
+                                    print_callback, loop=loop)
+    else:
+        create_connection = partial(create_dsmr_reader,
+                                    args.device, args.version,
+                                    print_callback, loop=loop)
+
+    try:
+        # connect and keep connected until interrupted by ctrl-c
+        while True:
+            # create serial or tcp connection
+            conn = create_connection()
+            transport, protocol = loop.run_until_complete(conn)
+            # wait until connection it closed
+            loop.run_until_complete(protocol.wait_closed())
+            # wait 5 seconds before attempting reconnect
+            loop.run_until_complete(asyncio.sleep(5))
+    except KeyboardInterrupt:
+        # cleanup connection after user initiated shutdown
+        transport.close()
+        loop.run_until_complete(asyncio.sleep(0))
+    finally:
+        loop.close()
@@ -0,0 +1,5 @@
+from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
+    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
@@ -0,0 +1,171 @@
+import logging
+import fileinput
+import tailer
+
+from dsmr_parser.clients.telegram_buffer import TelegramBuffer
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
+from dsmr_parser.objects import Telegram
+from dsmr_parser.parsers import TelegramParser
+
+logger = logging.getLogger(__name__)
+
+
+class FileReader(object):
+    """
+     Filereader to read and parse raw telegram strings from a file and instantiate Telegram objects
+     for each read telegram.
+     Usage:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileReader
+
+        if __name__== "__main__":
+
+            infile = '/data/smartmeter/readings.txt'
+
+            file_reader = FileReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V4
+                )
+
+            for telegram in file_reader.read_as_object():
+                print(telegram)
+
+     The file can be created like:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V5
+
+        if __name__== "__main__":
+
+            outfile = '/data/smartmeter/readings.txt'
+
+            serial_reader = SerialReader(
+                device='/dev/ttyUSB0',
+                serial_settings=SERIAL_SETTINGS_V5,
+                telegram_specification=telegram_specifications.V4
+            )
+
+            for telegram in serial_reader.read_as_object():
+                f=open(outfile,"ab+")
+                f.write(telegram._telegram_data.encode())
+                f.close()
+     """
+
+    def __init__(self, file, telegram_specification):
+        self._file = file
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from a file and return a Telegram object.
+        :rtype: generator
+        """
+        with open(self._file, "rb") as file_handle:
+            while True:
+                data = file_handle.readline()
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield 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)
+
+
+class FileInputReader(object):
+    """
+     Filereader to read and parse raw telegram strings from stdin or files specified at the commandline
+     and instantiate Telegram objects for each read telegram.
+     Usage python script "syphon_smartmeter_readings_stdin.py":
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileInputReader
+
+        if __name__== "__main__":
+
+            fileinput_reader = FileReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V4
+                )
+
+            for telegram in fileinput_reader.read_as_object():
+                print(telegram)
+
+    Command line:
+        tail -f /data/smartmeter/readings.txt | python3 syphon_smartmeter_readings_stdin.py
+
+     """
+
+    def __init__(self, telegram_specification):
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from stdin of filearguments specified on teh command line
+        and return a Telegram object.
+        :rtype: generator
+        """
+        with fileinput.input(mode='rb') as file_handle:
+            while True:
+                data = file_handle.readline()
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield 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)
+
+
+class FileTailReader(object):
+    """
+      Filereader to read and parse raw telegram strings from the tail of a
+      given file and instantiate Telegram objects for each read telegram.
+      Usage python script "syphon_smartmeter_readings_stdin.py":
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.clients.filereader import FileTailReader
+
+        if __name__== "__main__":
+
+            infile = '/data/smartmeter/readings.txt'
+
+            filetail_reader = FileTailReader(
+                file = infile,
+                telegram_specification = telegram_specifications.V5
+                )
+
+            for telegram in filetail_reader.read_as_object():
+                print(telegram)
+      """
+
+    def __init__(self, file, telegram_specification):
+        self._file = file
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from a files tail and return a Telegram object.
+        :rtype: generator
+        """
+        with open(self._file, "rb") as file_handle:
+            for data in tailer.follow(file_handle):
+                str = data.decode()
+                self.telegram_buffer.append(str)
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield 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)
@@ -0,0 +1,122 @@
+"""Asyncio protocol implementation for handling telegrams."""
+
+from functools import partial
+import asyncio
+import logging
+
+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, InvalidChecksumError
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
+    SERIAL_SETTINGS_V4, SERIAL_SETTINGS_V5
+
+
+def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol."""
+
+    if dsmr_version == '2.2':
+        specification = telegram_specifications.V2_2
+        serial_settings = SERIAL_SETTINGS_V2_2
+    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
+    elif dsmr_version == '5B':
+        specification = telegram_specifications.BELGIUM_FLUVIUS
+        serial_settings = SERIAL_SETTINGS_V5
+    elif dsmr_version == "5L":
+        specification = telegram_specifications.LUXEMBOURG_SMARTY
+        serial_settings = SERIAL_SETTINGS_V5
+    else:
+        raise NotImplementedError("No telegram parser found for version: %s",
+                                  dsmr_version)
+
+    protocol = partial(DSMRProtocol, loop, TelegramParser(specification),
+                       telegram_callback=telegram_callback)
+
+    return protocol, serial_settings
+
+
+def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol coroutine using serial port."""
+    protocol, serial_settings = create_dsmr_protocol(
+        dsmr_version, telegram_callback, loop=None)
+    serial_settings['url'] = port
+
+    conn = create_serial_connection(loop, protocol, **serial_settings)
+    return conn
+
+
+def create_tcp_dsmr_reader(host, port, dsmr_version,
+                           telegram_callback, loop=None):
+    """Creates a DSMR asyncio protocol coroutine using TCP connection."""
+    if not loop:
+        loop = asyncio.get_event_loop()
+    protocol, _ = create_dsmr_protocol(
+        dsmr_version, telegram_callback, loop=loop)
+    conn = loop.create_connection(protocol, host, port)
+    return conn
+
+
+class DSMRProtocol(asyncio.Protocol):
+    """Assemble and handle incoming data into complete DSM telegrams."""
+
+    transport = None
+    telegram_callback = None
+
+    def __init__(self, loop, telegram_parser, telegram_callback=None):
+        """Initialize class."""
+        self.loop = loop
+        self.log = logging.getLogger(__name__)
+        self.telegram_parser = telegram_parser
+        # callback to call on complete telegram
+        self.telegram_callback = telegram_callback
+        # buffer to keep incomplete incoming data
+        self.telegram_buffer = TelegramBuffer()
+        # keep a lock until the connection is closed
+        self._closed = asyncio.Event()
+
+    def connection_made(self, transport):
+        """Just logging for now."""
+        self.transport = transport
+        self.log.debug('connected')
+
+    def data_received(self, data):
+        """Add incoming data to buffer."""
+        data = data.decode('ascii')
+        self.log.debug('received data: %s', data)
+        self.telegram_buffer.append(data)
+
+        for telegram in self.telegram_buffer.get_all():
+            self.handle_telegram(telegram)
+
+    def connection_lost(self, exc):
+        """Stop when connection is lost."""
+        if exc:
+            self.log.exception('disconnected due to exception', exc_info=exc)
+        else:
+            self.log.info('disconnected because of close/abort.')
+        self._closed.set()
+
+    def handle_telegram(self, telegram):
+        """Send off parsed telegram to handling callback."""
+        self.log.debug('got telegram: %s', telegram)
+
+        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:
+            self.telegram_callback(parsed_telegram)
+
+    @asyncio.coroutine
+    def wait_closed(self):
+        """Wait until connection is closed."""
+        yield from self._closed.wait()
@@ -0,0 +1,99 @@
+import asyncio
+import logging
+import serial
+import serial_asyncio
+
+from dsmr_parser.clients.telegram_buffer import TelegramBuffer
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.objects import Telegram
+
+
+logger = logging.getLogger(__name__)
+
+
+class SerialReader(object):
+    PORT_KEY = 'port'
+
+    def __init__(self, device, serial_settings, telegram_specification):
+        self.serial_settings = serial_settings
+        self.serial_settings[self.PORT_KEY] = device
+
+        self.telegram_parser = TelegramParser(telegram_specification)
+        self.telegram_buffer = TelegramBuffer()
+        self.telegram_specification = telegram_specification
+
+    def read(self):
+        """
+        Read complete DSMR telegram's from the serial interface and parse it
+        into CosemObject's and MbusObject's
+
+        :rtype: generator
+        """
+        with serial.Serial(**self.serial_settings) as serial_handle:
+            while True:
+                data = serial_handle.read(max(1, min(1024, serial_handle.in_waiting)))
+                self.telegram_buffer.append(data.decode('ascii'))
+
+                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)
+
+    def read_as_object(self):
+        """
+        Read complete DSMR telegram's from the serial interface and return a Telegram object.
+
+        :rtype: generator
+        """
+        with serial.Serial(**self.serial_settings) as serial_handle:
+            while True:
+                data = serial_handle.readline()
+                self.telegram_buffer.append(data.decode('ascii'))
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield 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)
+
+
+class AsyncSerialReader(SerialReader):
+    """Serial reader using asyncio pyserial."""
+
+    PORT_KEY = 'url'
+
+    @asyncio.coroutine
+    def read(self, queue):
+        """
+        Read complete DSMR telegram's from the serial interface and parse it
+        into CosemObject's and MbusObject's.
+
+        Instead of being a generator, values are pushed to provided queue for
+        asynchronous processing.
+
+        :rtype: None
+        """
+        # create Serial StreamReader
+        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
+        reader, _ = yield from conn
+
+        while True:
+            # Read line if available or give control back to loop until new
+            # data has arrived.
+            data = yield from reader.readline()
+            self.telegram_buffer.append(data.decode('ascii'))
+
+            for telegram in self.telegram_buffer.get_all():
+                try:
+                    # Push new parsed telegram onto queue.
+                    queue.put_nowait(
+                        self.telegram_parser.parse(telegram)
+                    )
+                except ParseError as e:
+                    logger.warning('Failed to parse telegram: %s', e)
@@ -0,0 +1,32 @@
+import serial
+
+
+SERIAL_SETTINGS_V2_2 = {
+    'baudrate': 9600,
+    'bytesize': serial.SEVENBITS,
+    'parity': serial.PARITY_EVEN,
+    'stopbits': serial.STOPBITS_ONE,
+    'xonxoff': 0,
+    'rtscts': 0,
+    'timeout': 20
+}
+
+SERIAL_SETTINGS_V4 = {
+    'baudrate': 115200,
+    'bytesize': serial.SEVENBITS,
+    'parity': serial.PARITY_EVEN,
+    'stopbits': serial.STOPBITS_ONE,
+    'xonxoff': 0,
+    '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
+}
@@ -0,0 +1,57 @@
+import re
+
+
+class TelegramBuffer(object):
+    """
+    Used as a buffer for a stream of telegram data. Constructs full telegram
+    strings from the buffered data and returns it.
+    """
+
+    def __init__(self):
+        self._buffer = ''
+
+    def get_all(self):
+        """
+        Remove complete telegrams from buffer and yield them.
+        :rtype generator:
+        """
+        for telegram in self._find_telegrams():
+            self._remove(telegram)
+            yield telegram
+
+    def append(self, data):
+        """
+        Add telegram data to buffer.
+        :param str data: chars, lines or full telegram strings of telegram data
+        """
+        self._buffer += data
+
+    def _remove(self, telegram):
+        """
+        Remove telegram from buffer and incomplete data preceding it. This
+        is easier than validating the data before adding it to the buffer.
+        :param str telegram:
+        :return:
+        """
+        # Remove data leading up to the telegram and the telegram itself.
+        index = self._buffer.index(telegram) + len(telegram)
+
+        self._buffer = self._buffer[index:]
+
+    def _find_telegrams(self):
+        """
+        Find complete telegrams in buffer from  start ('/') till ending
+        checksum ('!AB12\r\n').
+        :rtype: list
+        """
+        # - Match all characters after start of telegram except for the start
+        # itself again '^\/]+', which eliminates incomplete preceding telegrams.
+        # - Do non greedy match using '?' so start is matched up to the first
+        # checksum that's found.
+        # - The checksum is optional '{0,4}' because not all telegram versions
+        # support it.
+        return re.findall(
+            r'\/[^\/]+?\![A-F0-9]{0,4}\0?\r\n',
+            self._buffer,
+            re.DOTALL
+        )
@@ -1,2 +1,6 @@
 class ParseError(Exception):
    pass
+
+
+class InvalidChecksumError(ParseError):
+    pass
@@ -0,0 +1,58 @@
+from dsmr_parser import obis_references as obis
+
+"""
+dsmr_parser.obis_name_mapping
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This module contains a mapping of obis references to names.
+"""
+
+EN = {
+    obis.P1_MESSAGE_HEADER: 'P1_MESSAGE_HEADER',
+    obis.P1_MESSAGE_TIMESTAMP: 'P1_MESSAGE_TIMESTAMP',
+    obis.ELECTRICITY_IMPORTED_TOTAL: 'ELECTRICITY_IMPORTED_TOTAL',
+    obis.ELECTRICITY_USED_TARIFF_1: 'ELECTRICITY_USED_TARIFF_1',
+    obis.ELECTRICITY_USED_TARIFF_2: 'ELECTRICITY_USED_TARIFF_2',
+    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',
+    obis.EQUIPMENT_IDENTIFIER: 'EQUIPMENT_IDENTIFIER',
+    obis.CURRENT_ELECTRICITY_USAGE: 'CURRENT_ELECTRICITY_USAGE',
+    obis.CURRENT_ELECTRICITY_DELIVERY: 'CURRENT_ELECTRICITY_DELIVERY',
+    obis.LONG_POWER_FAILURE_COUNT: 'LONG_POWER_FAILURE_COUNT',
+    obis.SHORT_POWER_FAILURE_COUNT: 'SHORT_POWER_FAILURE_COUNT',
+    obis.POWER_EVENT_FAILURE_LOG: 'POWER_EVENT_FAILURE_LOG',
+    obis.VOLTAGE_SAG_L1_COUNT: 'VOLTAGE_SAG_L1_COUNT',
+    obis.VOLTAGE_SAG_L2_COUNT: 'VOLTAGE_SAG_L2_COUNT',
+    obis.VOLTAGE_SAG_L3_COUNT: 'VOLTAGE_SAG_L3_COUNT',
+    obis.VOLTAGE_SWELL_L1_COUNT: 'VOLTAGE_SWELL_L1_COUNT',
+    obis.VOLTAGE_SWELL_L2_COUNT: 'VOLTAGE_SWELL_L2_COUNT',
+    obis.VOLTAGE_SWELL_L3_COUNT: 'VOLTAGE_SWELL_L3_COUNT',
+    obis.INSTANTANEOUS_VOLTAGE_L1: 'INSTANTANEOUS_VOLTAGE_L1',
+    obis.INSTANTANEOUS_VOLTAGE_L2: 'INSTANTANEOUS_VOLTAGE_L2',
+    obis.INSTANTANEOUS_VOLTAGE_L3: 'INSTANTANEOUS_VOLTAGE_L3',
+    obis.INSTANTANEOUS_CURRENT_L1: 'INSTANTANEOUS_CURRENT_L1',
+    obis.INSTANTANEOUS_CURRENT_L2: 'INSTANTANEOUS_CURRENT_L2',
+    obis.INSTANTANEOUS_CURRENT_L3: 'INSTANTANEOUS_CURRENT_L3',
+    obis.TEXT_MESSAGE_CODE: 'TEXT_MESSAGE_CODE',
+    obis.TEXT_MESSAGE: 'TEXT_MESSAGE',
+    obis.DEVICE_TYPE: 'DEVICE_TYPE',
+    obis.INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
+    obis.INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
+    obis.INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE: 'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
+    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.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_HOURLY_GAS_METER_READING: 'BELGIUM_HOURLY_GAS_METER_READING',
+    obis.LUXEMBOURG_EQUIPMENT_IDENTIFIER: 'LUXEMBOURG_EQUIPMENT_IDENTIFIER',
+    obis.LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL: 'LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL',
+    obis.LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL: 'LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL'
+}
+
+REVERSE_EN = dict([(v, k) for k, v in EN.items()])
@@ -1,36 +1,56 @@
-P1_MESSAGE_HEADER = r'1-3:0\.2\.8'
-P1_MESSAGE_TIMESTAMP = r'0-0:1\.0\.0'
-ELECTRICITY_USED_TARIFF_1 = r'1-0:1\.8\.1'
-ELECTRICITY_USED_TARIFF_2 = r'1-0:1\.8\.2'
-ELECTRICITY_DELIVERED_TARIFF_1 = r'1-0:2\.8\.1'
-ELECTRICITY_DELIVERED_TARIFF_2 = r'1-0:2\.8\.2'
-ELECTRICITY_ACTIVE_TARIFF = r'0-0:96\.14\.0'
-EQUIPMENT_IDENTIFIER = r'0-0:96\.1\.1'
-CURRENT_ELECTRICITY_USAGE = r'1-0:1\.7\.0'
-CURRENT_ELECTRICITY_DELIVERY = r'1-0:2\.7\.0'
-LONG_POWER_FAILURE_COUNT = r'96\.7\.9'
-POWER_EVENT_FAILURE_LOG = r'99\.97\.0'
-VOLTAGE_SAG_L1_COUNT = r'1-0:32\.32\.0'
-VOLTAGE_SAG_L2_COUNT = r'1-0:52\.32\.0'
-VOLTAGE_SAG_L3_COUNT = r'1-0:72\.32\.0'
-VOLTAGE_SWELL_L1_COUNT = r'1-0:32\.36\.0'
-VOLTAGE_SWELL_L2_COUNT = r'1-0:52\.36\.0'
-VOLTAGE_SWELL_L3_COUNT = r'1-0:72\.36\.0'
-TEXT_MESSAGE_CODE = r'0-0:96\.13\.1'
-TEXT_MESSAGE = r'0-0:96\.13\.0'
-DEVICE_TYPE = r'0-\d:24\.1\.0'
-INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE = r'1-0:21\.7\.0'
-INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE = r'1-0:41\.7\.0'
-INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE = r'1-0:61\.7\.0'
-INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE = r'1-0:22\.7\.0'
-INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE = r'1-0:42\.7\.0'
-INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE = r'1-0:62\.7\.0'
-EQUIPMENT_IDENTIFIER_GAS = r'0-\d:96\.1\.0'
-HOURLY_GAS_METER_READING = r'0-1:24\.2\.1'
-GAS_METER_READING = r'0-\d:24\.3\.0'
-ACTUAL_TRESHOLD_ELECTRICITY = r'0-0:17\.0\.0'
-ACTUAL_SWITCH_POSITION = r'0-0:96\.3\.10'
-VALVE_POSITION_GAS = r'0-\d:24\.4\.0'
+"""
+Contains the signatures of each telegram line.
+
+Previously contained the channel + obis reference signatures, but has been
+refactored to full line signatures to maintain backwards compatibility.
+Might be refactored in a backwards incompatible way as soon as proper telegram
+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'
+ELECTRICITY_DELIVERED_TARIFF_2 = r'\d-\d:2\.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'
+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'
+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'
+INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE = r'\d-\d:21\.7\.0.+?\r\n'
+INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE = r'\d-\d:41\.7\.0.+?\r\n'
+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'
+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'
+GAS_METER_READING = r'\d-\d:24\.3\.0.+?\r\n.+?\r\n'
+ACTUAL_TRESHOLD_ELECTRICITY = r'\d-\d:17\.0\.0.+?\r\n'
+ACTUAL_SWITCH_POSITION = r'\d-\d:96\.3\.10.+?\r\n'
+VALVE_POSITION_GAS = r'\d-\d:24\.4\.0.+?\r\n'
+
+# TODO 17.0.0
+# TODO 96.3.10

 ELECTRICITY_USED_TARIFF_ALL = (
    ELECTRICITY_USED_TARIFF_1,
@@ -40,3 +60,9 @@ ELECTRICITY_DELIVERED_TARIFF_ALL = (
    ELECTRICITY_DELIVERED_TARIFF_1,
    ELECTRICITY_DELIVERED_TARIFF_2
 )
+
+# Alternate codes for foreign countries.
+BELGIUM_HOURLY_GAS_METER_READING = r'\d-\d:24\.2\.3.+?\r\n'  # Different code, same format.
+LUXEMBOURG_EQUIPMENT_IDENTIFIER = r'\d-\d:42\.0\.0.+?\r\n' # Logical device name
+LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL = r'\d-\d:1\.8\.0.+?\r\n'  # Total imported energy register (P+)
+LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL = r'\d-\d:2\.8\.0.+?\r\n'  # Total exported energy register (P-)
@@ -1,4 +1,67 @@
+import dsmr_parser.obis_name_mapping
+import datetime
+import json
+from decimal import Decimal
+
+
+class Telegram(object):
+    """
+    Container for raw and parsed telegram data.
+    Initializing:
+        from dsmr_parser import telegram_specifications
+        from dsmr_parser.exceptions import InvalidChecksumError, ParseError
+        from dsmr_parser.objects import CosemObject, MBusObject, Telegram
+        from dsmr_parser.parsers import TelegramParser
+        from test.example_telegrams import TELEGRAM_V4_2
+        parser = TelegramParser(telegram_specifications.V4)
+        telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+    Attributes can be accessed on a telegram object by addressing by their english name, for example:
+        telegram.ELECTRICITY_USED_TARIFF_1
+
+    All attributes in a telegram can be iterated over, for example:
+        [k for k,v in telegram]
+    yields:
+    ['P1_MESSAGE_HEADER',  'P1_MESSAGE_TIMESTAMP', 'EQUIPMENT_IDENTIFIER', ...]
+    """
+    def __init__(self, telegram_data, telegram_parser, telegram_specification):
+        self._telegram_data = telegram_data
+        self._telegram_specification = telegram_specification
+        self._telegram_parser = telegram_parser
+        self._obis_name_mapping = dsmr_parser.obis_name_mapping.EN
+        self._reverse_obis_name_mapping = dsmr_parser.obis_name_mapping.REVERSE_EN
+        self._dictionary = self._telegram_parser.parse(telegram_data)
+        self._item_names = self._get_item_names()
+
+    def __getattr__(self, name):
+        ''' will only get called for undefined attributes '''
+        obis_reference = self._reverse_obis_name_mapping[name]
+        value = self._dictionary[obis_reference]
+        setattr(self, name, value)
+        return value
+
+    def _get_item_names(self):
+        return [self._obis_name_mapping[k] for k, v in self._dictionary.items()]
+
+    def __iter__(self):
+        for attr in self._item_names:
+            value = getattr(self, attr)
+            yield attr, value
+
+    def __str__(self):
+        output = ""
+        for attr, value in self:
+            output += "{}: \t {}\n".format(attr, str(value))
+        return output
+
+    def to_json(self):
+        return json.dumps(dict([[attr, json.loads(value.to_json())] for attr, value in self]))
+
+
 class DSMRObject(object):
+    """
+    Represents all data from a single telegram line.
+    """

    def __init__(self, values):
        self.values = values
@@ -12,26 +75,43 @@ class MBusObject(DSMRObject):

    @property
    def value(self):
-        return self.values[1]['value']
+        # TODO temporary workaround for DSMR v2.2. Maybe use the same type of
+        # TODO object, but let the parse set them differently? So don't use
+        # TODO hardcoded indexes here.
+        if len(self.values) != 2:  # v2
+            return self.values[6]['value']
+        else:
+            return self.values[1]['value']

    @property
    def unit(self):
-        return self.values[1]['unit']
+        # TODO temporary workaround for DSMR v2.2. Maybe use the same type of
+        # TODO object, but let the parse set them differently? So don't use
+        # TODO hardcoded indexes here.
+        if len(self.values) != 2:  # v2
+            return self.values[5]['value']
+        else:
+            return self.values[1]['unit']

+    def __str__(self):
+        output = "{}\t[{}] at {}".format(str(self.value), str(self.unit), str(self.datetime.astimezone().isoformat()))
+        return output

-class MBusObjectV2_2(DSMRObject):
-
-    @property
-    def datetime(self):
-        return self.values[0]['value']
-
-    @property
-    def value(self):
-        return self.values[5]['value']
-
-    @property
-    def unit(self):
-        return self.values[4]['value']
+    def to_json(self):
+        timestamp = self.datetime
+        if isinstance(self.datetime, datetime.datetime):
+            timestamp = self.datetime.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,
+            'value': value,
+            'unit': self.unit
+        }
+        return json.dumps(output)


 class CosemObject(DSMRObject):
@@ -44,7 +124,84 @@ class CosemObject(DSMRObject):
    def unit(self):
        return self.values[0]['unit']

+    def __str__(self):
+        print_value = self.value
+        if isinstance(self.value, datetime.datetime):
+            print_value = self.value.astimezone().isoformat()
+        output = "{}\t[{}]".format(str(print_value), str(self.unit))
+        return output

-class ProfileGeneric(DSMRObject):
-    pass
-    # TODO implement
+    def to_json(self):
+        json_value = self.value
+        if isinstance(self.value, datetime.datetime):
+            json_value = self.value.astimezone().isoformat()
+        if isinstance(self.value, Decimal):
+            json_value = float(self.value)
+        output = {
+            'value': json_value,
+            'unit': self.unit
+        }
+        return json.dumps(output)
+
+
+class ProfileGenericObject(DSMRObject):
+    """
+    Represents all data in a GenericProfile value.
+    All buffer values are returned as a list of MBusObjects,
+    containing the datetime (timestamp) and the value.
+    """
+
+    def __init__(self, values):
+        super().__init__(values)
+        self._buffer_list = None
+
+    @property
+    def buffer_length(self):
+        return self.values[0]['value']
+
+    @property
+    def buffer_type(self):
+        return self.values[1]['value']
+
+    @property
+    def buffer(self):
+        if self._buffer_list is None:
+            self._buffer_list = []
+            values_offset = 2
+            for i in range(self.buffer_length):
+                offset = values_offset + i*2
+                self._buffer_list.append(MBusObject([self.values[offset], self.values[offset + 1]]))
+        return self._buffer_list
+
+    def __str__(self):
+        output = "\t buffer length: {}\n".format(self.buffer_length)
+        output += "\t buffer type: {}".format(self.buffer_type)
+        for buffer_value in self.buffer:
+            timestamp = buffer_value.datetime
+            if isinstance(timestamp, datetime.datetime):
+                timestamp = str(timestamp.astimezone().isoformat())
+            output += "\n\t event occured at: {}".format(timestamp)
+            output += "\t for: {} [{}]".format(buffer_value.value, buffer_value.unit)
+        return output
+
+    def to_json(self):
+        """
+        :return: A json of all values in the GenericProfileObject , with the following structure
+                 {'buffer_length': n,
+                  'buffer_type': obis_ref,
+                  'buffer': [{'datetime': d1,
+                              'value': v1,
+                              'unit': u1},
+                              ...
+                               {'datetime': dn,
+                              'value': vn,
+                              'unit': un}
+                              ]
+                  }
+        """
+        list = [['buffer_length', self.buffer_length]]
+        list.append(['buffer_type', self.buffer_type])
+        buffer_repr = [json.loads(buffer_item.to_json()) for buffer_item in self.buffer]
+        list.append(['buffer', buffer_repr])
+        output = dict(list)
+        return json.dumps(output)
@@ -1,90 +1,156 @@
 import logging
 import re

-from .objects import MBusObject, MBusObjectV2_2, CosemObject
-from .exceptions import ParseError
-from .obis_references import GAS_METER_READING
+from ctypes import c_ushort
+
+from dsmr_parser.objects import MBusObject, CosemObject, ProfileGenericObject
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError

 logger = logging.getLogger(__name__)


 class TelegramParser(object):

-    def __init__(self, telegram_specification):
+    crc16_tab = []
+
+    def __init__(self, telegram_specification, apply_checksum_validation=True):
        """
        :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
        """
        self.telegram_specification = telegram_specification
+        self.apply_checksum_validation = apply_checksum_validation

-    def _find_line_parser(self, line_value):
+    def parse(self, telegram_data):
+        """
+        Parse telegram from string to dict.

-        for obis_reference, parser in self.telegram_specification.items():
-            if re.search(obis_reference, line_value):
-                return obis_reference, parser
+        The telegram str type makes python 2.x integration easier.

-        return None, None
+        :param str telegram_data: full telegram from start ('/') to checksum
+            ('!ABCD') including line endings in between the telegram's lines
+        :rtype: dict
+        :returns: Shortened example:
+            {
+                ..
+                r'\d-\d:96\.1\.1.+?\r\n': <CosemObject>,  # EQUIPMENT_IDENTIFIER
+                r'\d-\d:1\.8\.1.+?\r\n': <CosemObject>,   # ELECTRICITY_USED_TARIFF_1
+                r'\d-\d:24\.3\.0.+?\r\n.+?\r\n': <MBusObject>,  # GAS_METER_READING
+                ..
+            }
+        :raises ParseError:
+        :raises InvalidChecksumError:
+        """
+
+        if self.apply_checksum_validation \
+                and self.telegram_specification['checksum_support']:
+            self.validate_checksum(telegram_data)

-    def parse(self, line_values):
        telegram = {}

-        for line_value in line_values:
-            obis_reference, dsmr_object = self.parse_line(line_value.strip())
+        for signature, parser in self.telegram_specification['objects'].items():
+            match = re.search(signature, telegram_data, re.DOTALL)

-            telegram[obis_reference] = dsmr_object
+            # 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

-    def parse_line(self, line_value):
-        logger.debug('Parsing line\'%s\'', line_value)
+    @staticmethod
+    def validate_checksum(telegram):
+        """
+        :param str telegram:
+        :raises ParseError:
+        :raises InvalidChecksumError:
+        """

-        obis_reference, parser = self._find_line_parser(line_value)
+        # Extract the part for which the checksum applies.
+        checksum_contents = re.search(r'\/.+\!', telegram, re.DOTALL)

-        if not parser:
-            logger.warning("No line class found for: '%s'", line_value)
-            return None, None
+        # Extract the hexadecimal checksum value itself.
+        # The line ending '\r\n' for the checksum line can be ignored.
+        checksum_hex = re.search(r'((?<=\!)[0-9A-Z]{4})+', telegram)

-        return obis_reference, parser.parse(line_value)
+        if not checksum_contents or not checksum_hex:
+            raise ParseError(
+                'Failed to perform CRC validation because the telegram is '
+                'incomplete. The checksum and/or content values are missing.'
+            )

+        calculated_crc = TelegramParser.crc16(checksum_contents.group(0))
+        expected_crc = int(checksum_hex.group(0), base=16)

-class TelegramParserV2_2(TelegramParser):
-    def parse(self, line_values):
-        """Join lines for gas meter."""
+        if calculated_crc != expected_crc:
+            raise InvalidChecksumError(
+                "Invalid telegram. The CRC checksum '{}' does not match the "
+                "expected '{}'".format(
+                    calculated_crc,
+                    expected_crc
+                )
+            )

-        def join_lines(line_values):
-            join_next = re.compile(GAS_METER_READING)
+    @staticmethod
+    def crc16(telegram):
+        """
+        Calculate the CRC16 value for the given telegram

-            join = None
-            for line_value in line_values:
-                if join:
-                    yield join.strip() + line_value
-                    join = None
-                elif join_next.match(line_value):
-                    join = line_value
-                else:
-                    yield line_value
+        :param str telegram:
+        """
+        crcValue = 0x0000

-        return super().parse(join_lines(line_values))
+        if len(TelegramParser.crc16_tab) == 0:
+            for i in range(0, 256):
+                crc = c_ushort(i).value
+                for j in range(0, 8):
+                    if (crc & 0x0001):
+                        crc = c_ushort(crc >> 1).value ^ 0xA001
+                    else:
+                        crc = c_ushort(crc >> 1).value
+                TelegramParser.crc16_tab.append(hex(crc))
+
+        for c in telegram:
+            d = ord(c)
+            tmp = crcValue ^ d
+            rotated = c_ushort(crcValue >> 8).value
+            crcValue = rotated ^ int(TelegramParser.crc16_tab[(tmp & 0x00ff)], 0)
+
+        return crcValue


 class DSMRObjectParser(object):
+    """
+    Parses an object (can also be see as a 'line') from a telegram.
+    """

    def __init__(self, *value_formats):
        self.value_formats = value_formats

+    def _is_line_wellformed(self, line, values):
+        # allows overriding by child class
+        return (values and (len(values) == len(self.value_formats)))
+
+    def _parse_values(self, values):
+        # allows overriding by child class
+        return [self.value_formats[i].parse(value)
+                for i, value in enumerate(values)]
+
    def _parse(self, line):
        # Match value groups, but exclude the parentheses
-        pattern = re.compile(r'((?<=\()[0-9a-zA-Z\.\*]{0,}(?=\)))+')
+        pattern = re.compile(r'((?<=\()[0-9a-zA-Z\.\*\-\:]{0,}(?=\)))')
+
        values = re.findall(pattern, line)

+        if not self._is_line_wellformed(line, values):
+            raise ParseError("Invalid '%s' line for '%s'", line, self)
+
        # Convert empty value groups to None for clarity.
        values = [None if value == '' else value for value in values]

-        if not values or len(values) != len(self.value_formats):
-            raise ParseError("Invalid '%s' line for '%s'", line, self)
-
-        return [self.value_formats[i].parse(value)
-                for i, value in enumerate(values)]
+        return self._parse_values(values)


 class MBusParser(DSMRObjectParser):
@@ -105,11 +171,7 @@ class MBusParser(DSMRObjectParser):
    """

    def parse(self, line):
-        values = self._parse(line)
-        if len(values) == 2:
-            return MBusObject(values)
-        else:
-            return MBusObjectV2_2(values)
+        return MBusObject(self._parse(line))


 class CosemParser(DSMRObjectParser):
@@ -125,10 +187,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):
@@ -156,12 +219,46 @@ class ProfileGenericParser(DSMRObjectParser):
    8) Buffer value 2 (oldest entry of buffer attribute without unit)
    9) Unit of buffer values (Unit of capture objects attribute)
    """
+    def __init__(self, buffer_types, head_parsers, parsers_for_unidentified):
+        self.value_formats = head_parsers
+        self.buffer_types = buffer_types
+        self.parsers_for_unidentified = parsers_for_unidentified
+
+    def _is_line_wellformed(self, line, values):
+        if values and (len(values) >= 2) and (values[0].isdigit()):
+            buffer_length = int(values[0])
+            return (buffer_length <= 10) and (len(values) == (buffer_length * 2 + 2))
+        else:
+            return False
+
+    def _parse_values(self, values):
+        buffer_length = int(values[0])
+        buffer_value_obis_ID = values[1]
+        if (buffer_length > 0):
+            if buffer_value_obis_ID in self.buffer_types:
+                bufferValueParsers = self.buffer_types[buffer_value_obis_ID]
+            else:
+                bufferValueParsers = self.parsers_for_unidentified
+        # add the parsers for the encountered value type z times
+        for _ in range(buffer_length):
+            self.value_formats.extend(bufferValueParsers)
+
+        return [self.value_formats[i].parse(value) for i, value in enumerate(values)]

    def parse(self, line):
-        raise NotImplementedError()
+        return ProfileGenericObject(self._parse(line))


 class ValueParser(object):
+    """
+    Parses a single value from DSMRObject's.
+
+    Example with coerce_type being int:
+        (002*A) becomes {'value': 1, 'unit': 'A'}
+
+    Example with coerce_type being str:
+        (42) becomes {'value': '42', 'unit': None}
+    """

    def __init__(self, coerce_type):
        self.coerce_type = coerce_type
@@ -0,0 +1,10 @@
+from dsmr_parser.parsers import ValueParser
+from dsmr_parser.value_types import timestamp
+
+PG_FAILURE_EVENT = r'0-0:96.7.19'
+
+PG_HEAD_PARSERS = [ValueParser(int), ValueParser(str)]
+PG_UNIDENTIFIED_BUFFERTYPE_PARSERS = [ValueParser(str), ValueParser(str)]
+BUFFER_TYPES = {
+    PG_FAILURE_EVENT:  [ValueParser(timestamp), ValueParser(int)]
+    }
@@ -1,69 +0,0 @@
-import serial
-
-from dsmr_parser.parsers import TelegramParser, TelegramParserV2_2
-
-SERIAL_SETTINGS_V2_2 = {
-    'baudrate': 9600,
-    'bytesize': serial.SEVENBITS,
-    'parity': serial.PARITY_NONE,
-    'stopbits': serial.STOPBITS_ONE,
-    'xonxoff': 0,
-    'rtscts': 0,
-    'timeout': 20
-}
-
-SERIAL_SETTINGS_V4 = {
-    'baudrate': 115200,
-    'bytesize': serial.SEVENBITS,
-    'parity': serial.PARITY_EVEN,
-    'stopbits': serial.STOPBITS_ONE,
-    'xonxoff': 0,
-    'rtscts': 0,
-    'timeout': 20
-}
-
-
-def is_start_of_telegram(line):
-    return line.startswith('/')
-
-
-def is_end_of_telegram(line):
-    return line.startswith('!')
-
-
-class SerialReader(object):
-
-    def __init__(self, device, serial_settings, telegram_specification):
-        self.serial_settings = serial_settings
-        self.serial_settings['port'] = device
-
-        if serial_settings is SERIAL_SETTINGS_V2_2:
-            telegram_parser = TelegramParserV2_2
-        else:
-            telegram_parser = TelegramParser
-        self.telegram_parser = telegram_parser(telegram_specification)
-
-    def read(self):
-        """
-        Read complete DSMR telegram's from the serial interface and parse it
-        into CosemObject's and MbusObject's
-
-        :rtype dict
-        """
-        with serial.Serial(**self.serial_settings) as serial_handle:
-            telegram = []
-
-            while True:
-                line = serial_handle.readline()
-                line = line.decode('ascii')
-
-                # Telegrams need to be complete because the values belong to a
-                # particular reading and can also be related to eachother.
-                if not telegram and not is_start_of_telegram(line):
-                    continue
-
-                telegram.append(line)
-
-                if is_end_of_telegram(line):
-                    yield self.telegram_parser.parse(telegram)
-                    telegram = []
@@ -1,9 +1,10 @@
 from decimal import Decimal
+from copy import deepcopy

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

 """
 dsmr_parser.telegram_specifications
@@ -14,60 +15,144 @@ how the telegram lines are parsed.
 """

 V2_2 = {
-    obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
-    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.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
-    obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
-    obis.ACTUAL_TRESHOLD_ELECTRICITY: CosemParser(ValueParser(Decimal)),
-    obis.ACTUAL_SWITCH_POSITION: CosemParser(ValueParser(str)),
-    obis.TEXT_MESSAGE_CODE: CosemParser(ValueParser(int)),
-    obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
-    obis.EQUIPMENT_IDENTIFIER_GAS: CosemParser(ValueParser(str)),
-    obis.DEVICE_TYPE: CosemParser(ValueParser(str)),
-    obis.VALVE_POSITION_GAS: CosemParser(ValueParser(str)),
-    obis.GAS_METER_READING: MBusParser(
-        ValueParser(timestamp),
-        ValueParser(int),
-        ValueParser(int),
-        ValueParser(int),
-        ValueParser(str),
-        ValueParser(Decimal),
-    ),
+    'checksum_support': False,
+    'objects': {
+        obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        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.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
+        obis.ACTUAL_TRESHOLD_ELECTRICITY: CosemParser(ValueParser(Decimal)),
+        obis.ACTUAL_SWITCH_POSITION: CosemParser(ValueParser(str)),
+        obis.TEXT_MESSAGE_CODE: CosemParser(ValueParser(int)),
+        obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
+        obis.EQUIPMENT_IDENTIFIER_GAS: CosemParser(ValueParser(str)),
+        obis.DEVICE_TYPE: CosemParser(ValueParser(str)),
+        obis.VALVE_POSITION_GAS: CosemParser(ValueParser(str)),
+        obis.GAS_METER_READING: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(str),  # changed to str see issue60
+            ValueParser(int),
+            ValueParser(int),
+            ValueParser(str),  # obis ref
+            ValueParser(str),  # unit, position 5
+            ValueParser(Decimal),  # meter reading, position 6
+        ),
+    }
 }

+V3 = V2_2
+
 V4 = {
-    obis.P1_MESSAGE_HEADER: 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.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
-    obis.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
-    obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
-    obis.LONG_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)),
-    obis.VOLTAGE_SAG_L3_COUNT: CosemParser(ValueParser(int)),
-    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.TEXT_MESSAGE_CODE: CosemParser(ValueParser(int)),
-    obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
-    obis.DEVICE_TYPE: CosemParser(ValueParser(int)),
-    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.EQUIPMENT_IDENTIFIER_GAS: CosemParser(ValueParser(str)),
-    obis.HOURLY_GAS_METER_READING: MBusParser(ValueParser(timestamp),
-                                              ValueParser(Decimal))
+    'checksum_support': True,
+    'objects': {
+        obis.P1_MESSAGE_HEADER: CosemParser(ValueParser(str)),
+        obis.P1_MESSAGE_TIMESTAMP: CosemParser(ValueParser(timestamp)),
+        obis.EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+        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.CURRENT_ELECTRICITY_USAGE: CosemParser(ValueParser(Decimal)),
+        obis.CURRENT_ELECTRICITY_DELIVERY: CosemParser(ValueParser(Decimal)),
+        obis.SHORT_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
+        obis.LONG_POWER_FAILURE_COUNT: CosemParser(ValueParser(int)),
+        obis.POWER_EVENT_FAILURE_LOG:
+            ProfileGenericParser(BUFFER_TYPES,
+                                 PG_HEAD_PARSERS,
+                                 PG_UNIDENTIFIED_BUFFERTYPE_PARSERS),
+        obis.VOLTAGE_SAG_L1_COUNT: CosemParser(ValueParser(int)),
+        obis.VOLTAGE_SAG_L2_COUNT: CosemParser(ValueParser(int)),
+        obis.VOLTAGE_SAG_L3_COUNT: CosemParser(ValueParser(int)),
+        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.TEXT_MESSAGE_CODE: CosemParser(ValueParser(int)),
+        obis.TEXT_MESSAGE: CosemParser(ValueParser(str)),
+        obis.DEVICE_TYPE: CosemParser(ValueParser(int)),
+        obis.INSTANTANEOUS_CURRENT_L1: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L2: CosemParser(ValueParser(Decimal)),
+        obis.INSTANTANEOUS_CURRENT_L3: 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.EQUIPMENT_IDENTIFIER_GAS: CosemParser(ValueParser(str)),
+        obis.HOURLY_GAS_METER_READING: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        )
+    }
 }
+
+V5 = {
+    'checksum_support': True,
+    'objects': {
+        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)),
+        obis.ELECTRICITY_DELIVERED_TARIFF_2: CosemParser(ValueParser(Decimal)),
+        obis.ELECTRICITY_ACTIVE_TARIFF: CosemParser(ValueParser(str)),
+        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)),
+        obis.POWER_EVENT_FAILURE_LOG:
+            ProfileGenericParser(BUFFER_TYPES,
+                                 PG_HEAD_PARSERS,
+                                 PG_UNIDENTIFIED_BUFFERTYPE_PARSERS),
+        obis.VOLTAGE_SAG_L1_COUNT: CosemParser(ValueParser(int)),
+        obis.VOLTAGE_SAG_L2_COUNT: CosemParser(ValueParser(int)),
+        obis.VOLTAGE_SAG_L3_COUNT: CosemParser(ValueParser(int)),
+        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)),
+        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.EQUIPMENT_IDENTIFIER_GAS: CosemParser(ValueParser(str)),
+        obis.HOURLY_GAS_METER_READING: MBusParser(
+            ValueParser(timestamp),
+            ValueParser(Decimal)
+        )
+    }
+}
+
+ALL = (V2_2, V3, V4, V5)
+
+
+BELGIUM_FLUVIUS = deepcopy(V5)
+BELGIUM_FLUVIUS['objects'].update({
+    obis.BELGIUM_HOURLY_GAS_METER_READING: MBusParser(
+        ValueParser(timestamp),
+        ValueParser(Decimal)
+    )
+})
+
+LUXEMBOURG_SMARTY = deepcopy(V5)
+LUXEMBOURG_SMARTY['objects'].update({
+    obis.LUXEMBOURG_EQUIPMENT_IDENTIFIER: CosemParser(ValueParser(str)),
+    obis.LUXEMBOURG_ELECTRICITY_USED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
+    obis.LUXEMBOURG_ELECTRICITY_DELIVERED_TARIFF_GLOBAL: CosemParser(ValueParser(Decimal)),
+})
@@ -4,8 +4,9 @@ import pytz


 def timestamp(value):
-
    naive_datetime = datetime.datetime.strptime(value[:-1], '%y%m%d%H%M%S')
+
+    # TODO comment on this exception
    if len(value) == 13:
        is_dst = value[12] == 'S'  # assume format 160322150000W
    else:
@@ -4,13 +4,15 @@ 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.2',
-    packages=find_packages(),
+    version='0.25',
+    packages=find_packages(exclude=('test', 'test.*')),
    install_requires=[
        'pyserial>=3,<4',
-        'pytz'
+        'pyserial-asyncio<1',
+        'pytz',
+        'Tailer==0.4.1'
    ],
    entry_points={
        'console_scripts': ['dsmr_console=dsmr_parser.__main__:console']
@@ -0,0 +1,130 @@
+TELEGRAM_V2_2 = (
+    '/ISk5\\2MT382-1004\r\n'
+    '\r\n'
+    '0-0:96.1.1(00000000000000)\r\n'
+    '1-0:1.8.1(00001.001*kWh)\r\n'
+    '1-0:1.8.2(00001.001*kWh)\r\n'
+    '1-0:2.8.1(00001.001*kWh)\r\n'
+    '1-0:2.8.2(00001.001*kWh)\r\n'
+    '0-0:96.14.0(0001)\r\n'
+    '1-0:1.7.0(0001.01*kW)\r\n'
+    '1-0:2.7.0(0000.00*kW)\r\n'
+    '0-0:17.0.0(0999.00*kW)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:96.13.1()\r\n'
+    '0-0:96.13.0()\r\n'
+    '0-1:24.1.0(3)\r\n'
+    '0-1:96.1.0(000000000000)\r\n'
+    '0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)\r\n'
+    '(00001.001)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '!\r\n'
+)
+
+TELEGRAM_V3 = (
+    '/ISk5\\2MT382-1000\r\n'
+    '\r\n'
+    '0-0:96.1.1(4B384547303034303436333935353037)\r\n'
+    '1-0:1.8.1(12345.678*kWh)\r\n'
+    '1-0:1.8.2(12345.678*kWh)\r\n'
+    '1-0:2.8.1(12345.678*kWh)\r\n'
+    '1-0:2.8.2(12345.678*kWh)\r\n'
+    '0-0:96.14.0(0002)\r\n'
+    '1-0:1.7.0(001.19*kW)\r\n'
+    '1-0:2.7.0(000.00*kW)\r\n'
+    '0-0:17.0.0(016*A)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:96.13.1(303132333435363738)\r\n'
+    '0-0:96.13.0(303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E'
+    '3F303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E3F30313233'
+    '3435363738393A3B3C3D3E3F)\r\n'
+    '0-1:96.1.0(3232323241424344313233343536373839)\r\n'
+    '0-1:24.1.0(03)\r\n'
+    '0-1:24.3.0(090212160000)(00)(60)(1)(0-1:24.2.1)(m3)\r\n'
+    '(00001.001)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '!\r\n'
+)
+
+TELEGRAM_V4_2 = (
+    '/KFM5KAIFA-METER\r\n'
+    '\r\n'
+    '1-3:0.2.8(42)\r\n'
+    '0-0:1.0.0(161113205757W)\r\n'
+    '0-0:96.1.1(3960221976967177082151037881335713)\r\n'
+    '1-0:1.8.1(001581.123*kWh)\r\n'
+    '1-0:1.8.2(001435.706*kWh)\r\n'
+    '1-0:2.8.1(000000.000*kWh)\r\n'
+    '1-0:2.8.2(000000.000*kWh)\r\n'
+    '0-0:96.14.0(0002)\r\n'
+    '1-0:1.7.0(02.027*kW)\r\n'
+    '1-0:2.7.0(00.000*kW)\r\n'
+    '0-0:96.7.21(00015)\r\n'
+    '0-0:96.7.9(00007)\r\n'
+    '1-0:99.97.0(3)(0-0:96.7.19)(000104180320W)(0000237126*s)(000101000001W)'
+    '(2147583646*s)(000102000003W)(2317482647*s)\r\n'
+    '1-0:32.32.0(00000)\r\n'
+    '1-0:52.32.0(00000)\r\n'
+    '1-0:72.32.0(00000)\r\n'
+    '1-0:32.36.0(00000)\r\n'
+    '1-0:52.36.0(00000)\r\n'
+    '1-0:72.36.0(00000)\r\n'
+    '0-0:96.13.1()\r\n'
+    '0-0:96.13.0()\r\n'
+    '1-0:31.7.0(000*A)\r\n'
+    '1-0:51.7.0(006*A)\r\n'
+    '1-0:71.7.0(002*A)\r\n'
+    '1-0:21.7.0(00.170*kW)\r\n'
+    '1-0:22.7.0(00.000*kW)\r\n'
+    '1-0:41.7.0(01.247*kW)\r\n'
+    '1-0:42.7.0(00.000*kW)\r\n'
+    '1-0:61.7.0(00.209*kW)\r\n'
+    '1-0:62.7.0(00.000*kW)\r\n'
+    '0-1:24.1.0(003)\r\n'
+    '0-1:96.1.0(4819243993373755377509728609491464)\r\n'
+    '0-1:24.2.1(161129200000W)(00981.443*m3)\r\n'
+    '!6796\r\n'
+)
+
+TELEGRAM_V5 = (
+    '/ISk5\\2MT382-1000\r\n'
+    '\r\n'
+    '1-3:0.2.8(50)\r\n'
+    '0-0:1.0.0(170102192002W)\r\n'
+    '0-0:96.1.1(4B384547303034303436333935353037)\r\n'
+    '1-0:1.8.1(000004.426*kWh)\r\n'
+    '1-0:1.8.2(000002.399*kWh)\r\n'
+    '1-0:2.8.1(000002.444*kWh)\r\n'
+    '1-0:2.8.2(000000.000*kWh)\r\n'
+    '0-0:96.14.0(0002)\r\n'
+    '1-0:1.7.0(00.244*kW)\r\n'
+    '1-0:2.7.0(00.000*kW)\r\n'
+    '0-0:96.7.21(00013)\r\n'
+    '0-0:96.7.9(00000)\r\n'
+    '1-0:99.97.0(0)(0-0:96.7.19)\r\n'
+    '1-0:32.32.0(00000)\r\n'
+    '1-0:52.32.0(00000)\r\n'
+    '1-0:72.32.0(00000)\r\n'
+    '1-0:32.36.0(00000)\r\n'
+    '1-0:52.36.0(00000)\r\n'
+    '1-0:72.36.0(00000)\r\n'
+    '0-0:96.13.0()\r\n'
+    '1-0:32.7.0(0230.0*V)\r\n'
+    '1-0:52.7.0(0230.0*V)\r\n'
+    '1-0:72.7.0(0229.0*V)\r\n'
+    '1-0:31.7.0(0.48*A)\r\n'
+    '1-0:51.7.0(0.44*A)\r\n'
+    '1-0:71.7.0(0.86*A)\r\n'
+    '1-0:21.7.0(00.070*kW)\r\n'
+    '1-0:41.7.0(00.032*kW)\r\n'
+    '1-0:61.7.0(00.142*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'
+    '0-1:24.1.0(003)\r\n'
+    '0-1:96.1.0(3232323241424344313233343536373839)\r\n'
+    '0-1:24.2.1(170102161005W)(00000.107*m3)\r\n'
+    '0-2:24.1.0(003)\r\n'
+    '0-2:96.1.0()\r\n'
+    '!6EEE\r\n'
+)
@@ -0,0 +1,8 @@
+from dsmr_parser import telegram_specifications
+from dsmr_parser.objects import Telegram
+from dsmr_parser.parsers import TelegramParser
+from example_telegrams import TELEGRAM_V4_2
+parser = TelegramParser(telegram_specifications.V4)
+telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+print(telegram)
@@ -1,40 +0,0 @@
-"""Test telegram parsing."""
-
-from dsmr_parser.parsers import TelegramParserV2_2
-from dsmr_parser import telegram_specifications
-from dsmr_parser.obis_references import CURRENT_ELECTRICITY_USAGE, GAS_METER_READING
-
-TELEGRAM_V2_2 = [
-    "/ISk5\2MT382-1004",
-    "",
-    "0-0:96.1.1(00000000000000)",
-    "1-0:1.8.1(00001.001*kWh)",
-    "1-0:1.8.2(00001.001*kWh)",
-    "1-0:2.8.1(00001.001*kWh)",
-    "1-0:2.8.2(00001.001*kWh)",
-    "0-0:96.14.0(0001)",
-    "1-0:1.7.0(0001.01*kW)",
-    "1-0:2.7.0(0000.00*kW)",
-    "0-0:17.0.0(0999.00*kW)",
-    "0-0:96.3.10(1)",
-    "0-0:96.13.1()",
-    "0-0:96.13.0()",
-    "0-1:24.1.0(3)",
-    "0-1:96.1.0(000000000000)",
-    "0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)",
-    "(00001.001)",
-    "0-1:24.4.0(1)",
-    "!",
-]
-
-
-def test_parse_v2_2():
-    """Test if telegram parsing results in correct results."""
-
-    parser = TelegramParserV2_2(telegram_specifications.V2_2)
-    result = parser.parse(TELEGRAM_V2_2)
-
-    assert float(result[CURRENT_ELECTRICITY_USAGE].value) == 1.01
-    assert result[CURRENT_ELECTRICITY_USAGE].unit == 'kW'
-    assert float(result[GAS_METER_READING].value) == 1.001
-    assert result[GAS_METER_READING].unit == 'm3'
@@ -0,0 +1,92 @@
+import unittest
+
+from decimal import Decimal
+
+from dsmr_parser.objects import MBusObject, CosemObject
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser import telegram_specifications
+from dsmr_parser import obis_references as obis
+from test.example_telegrams import TELEGRAM_V2_2
+
+
+class TelegramParserV2_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v2.2 telegram. """
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V2_2)
+        result = parser.parse(TELEGRAM_V2_2)
+
+        # 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('1.001')
+
+        # 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('1.001')
+
+        # 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('1.001')
+
+        # 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('1.001')
+
+        # 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'
+
+        # 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 == '00000000000000'
+
+        # 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('1.01')
+
+        # 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')
+
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        assert isinstance(result[obis.TEXT_MESSAGE_CODE], CosemObject)
+        assert result[obis.TEXT_MESSAGE_CODE].unit is None
+
+        # 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
+
+        # DEVICE_TYPE (0-x:24.1.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.DEVICE_TYPE].value, str)
+        assert result[obis.DEVICE_TYPE].value == '3'
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '000000000000'
+
+        # GAS_METER_READING (0-1:24.3.0)
+        assert isinstance(result[obis.GAS_METER_READING], MBusObject)
+        assert result[obis.GAS_METER_READING].unit == 'm3'
+        assert isinstance(result[obis.GAS_METER_READING].value, Decimal)
+        assert result[obis.GAS_METER_READING].value == Decimal('1.001')
@@ -0,0 +1,98 @@
+import unittest
+
+from decimal import Decimal
+
+from dsmr_parser.objects import CosemObject, MBusObject
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser import telegram_specifications
+from dsmr_parser import obis_references as obis
+from test.example_telegrams import TELEGRAM_V3
+
+
+class TelegramParserV3Test(unittest.TestCase):
+    """ Test parsing of a DSMR v3 telegram. """
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V3)
+        result = parser.parse(TELEGRAM_V3)
+
+        # 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('12345.678')
+
+        # 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('12345.678')
+
+        # 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('12345.678')
+
+        # 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('12345.678')
+
+        # 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 == '0002'
+
+        # 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 == '4B384547303034303436333935353037'
+
+        # 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('1.19')
+
+        # 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')
+
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        assert isinstance(result[obis.TEXT_MESSAGE_CODE], CosemObject)
+        assert result[obis.TEXT_MESSAGE_CODE].unit is None
+        assert isinstance(result[obis.TEXT_MESSAGE_CODE].value, int)
+        assert result[obis.TEXT_MESSAGE_CODE].value == 303132333435363738
+
+        # TEXT_MESSAGE (0-0:96.13.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.TEXT_MESSAGE].unit is None
+        assert isinstance(result[obis.TEXT_MESSAGE].value, str)
+        assert result[obis.TEXT_MESSAGE].value == \
+            '303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E3F' \
+            '303132333435363738393A3B3C3D3E3F303132333435363738393A3B3C3D3E3F' \
+            '303132333435363738393A3B3C3D3E3F'
+
+        # DEVICE_TYPE (0-x:24.1.0)
+        assert isinstance(result[obis.TEXT_MESSAGE], CosemObject)
+        assert result[obis.DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.DEVICE_TYPE].value, str)
+        assert result[obis.DEVICE_TYPE].value == '03'
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '3232323241424344313233343536373839'
+
+        # GAS_METER_READING (0-1:24.3.0)
+        assert isinstance(result[obis.GAS_METER_READING], MBusObject)
+        assert result[obis.GAS_METER_READING].unit == 'm3'
+        assert isinstance(result[obis.GAS_METER_READING].value, Decimal)
+        assert result[obis.GAS_METER_READING].value == Decimal('1.001')
@@ -0,0 +1,245 @@
+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
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_V4_2
+
+
+class TelegramParserV4_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v4.2 telegram. """
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V4)
+        result = parser.parse(TELEGRAM_V4_2)
+
+        # P1_MESSAGE_HEADER (1-3:0.2.8)
+        assert isinstance(result[obis.P1_MESSAGE_HEADER], CosemObject)
+        assert result[obis.P1_MESSAGE_HEADER].unit is None
+        assert isinstance(result[obis.P1_MESSAGE_HEADER].value, str)
+        assert result[obis.P1_MESSAGE_HEADER].value == '42'
+
+        # 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(2016, 11, 13, 19, 57, 57, 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('1581.123')
+
+        # 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('1435.706')
+
+        # 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')
+
+        # 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')
+
+        # 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 == '0002'
+
+        # 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 == '3960221976967177082151037881335713'
+
+        # 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('2.027')
+
+        # 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')
+
+        # 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 == 15
+
+        # LONG_POWER_FAILURE_COUNT (96.7.9)
+        assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.LONG_POWER_FAILURE_COUNT].unit is None
+        assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT].value, int)
+        assert result[obis.LONG_POWER_FAILURE_COUNT].value == 7
+
+        # 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
+        assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L1_COUNT].value == 0
+
+        # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].value == 0
+
+        # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L3_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L3_COUNT].value == 0
+
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        assert isinstance(result[obis.TEXT_MESSAGE_CODE], CosemObject)
+        assert result[obis.TEXT_MESSAGE_CODE].unit is None
+        assert result[obis.TEXT_MESSAGE_CODE].value is None
+
+        # 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
+
+        # 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')
+
+        # 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('6')
+
+        # 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('2')
+
+        # DEVICE_TYPE (0-x:24.1.0)
+        assert isinstance(result[obis.DEVICE_TYPE], CosemObject)
+        assert result[obis.DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.DEVICE_TYPE].value, int)
+        assert result[obis.DEVICE_TYPE].value == 3
+
+        # 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.170')
+
+        # 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('1.247')
+
+        # 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.209')
+
+        # 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')
+
+        # 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')
+
+        # 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')
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '4819243993373755377509728609491464'
+
+        # HOURLY_GAS_METER_READING (0-1:24.2.1)
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING], MBusObject)
+        assert result[obis.HOURLY_GAS_METER_READING].unit == 'm3'
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING].value, Decimal)
+        assert result[obis.HOURLY_GAS_METER_READING].value == Decimal('981.443')
+
+        # POWER_EVENT_FAILURE_LOG (99.97.0)
+        # TODO to be implemented
+
+        # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
+        # TODO to be implemented
+
+        # ACTUAL_SWITCH_POSITION (0-0:96.3.10)
+        # TODO to be implemented
+
+        # VALVE_POSITION_GAS (0-x:24.4.0)
+        # TODO to be implemented
+
+    def test_checksum_valid(self):
+        # No exception is raised.
+        TelegramParser.validate_checksum(TELEGRAM_V4_2)
+
+    def test_checksum_invalid(self):
+        # Remove the electricty used data value. This causes the checksum to
+        # not match anymore.
+        corrupted_telegram = TELEGRAM_V4_2.replace(
+            '1-0:1.8.1(001581.123*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_V4_2.replace('!6796\r\n', '')
+
+        with self.assertRaises(ParseError):
+            TelegramParser.validate_checksum(corrupted_telegram)
@@ -0,0 +1,247 @@
+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
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_V5
+
+
+class TelegramParserV5Test(unittest.TestCase):
+    """ Test parsing of a DSMR v5.x telegram. """
+
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V5)
+        result = parser.parse(TELEGRAM_V5)
+
+        # P1_MESSAGE_HEADER (1-3:0.2.8)
+        assert isinstance(result[obis.P1_MESSAGE_HEADER], CosemObject)
+        assert result[obis.P1_MESSAGE_HEADER].unit is None
+        assert isinstance(result[obis.P1_MESSAGE_HEADER].value, str)
+        assert result[obis.P1_MESSAGE_HEADER].value == '50'
+
+        # 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(2017, 1, 2, 18, 20, 2, 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('4.426')
+
+        # 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('2.399')
+
+        # 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('2.444')
+
+        # 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')
+
+        # 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 == '0002'
+
+        # 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 == '4B384547303034303436333935353037'
+
+        # 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.244')
+
+        # 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')
+
+        # LONG_POWER_FAILURE_COUNT (96.7.9)
+        assert isinstance(result[obis.LONG_POWER_FAILURE_COUNT], CosemObject)
+        assert result[obis.LONG_POWER_FAILURE_COUNT].unit is None
+        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
+        assert isinstance(result[obis.VOLTAGE_SAG_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L1_COUNT].value == 0
+
+        # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L2_COUNT].value == 0
+
+        # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SAG_L3_COUNT].value, int)
+        assert result[obis.VOLTAGE_SAG_L3_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L1_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L1_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].unit is None
+        assert isinstance(result[obis.VOLTAGE_SWELL_L2_COUNT].value, int)
+        assert result[obis.VOLTAGE_SWELL_L2_COUNT].value == 0
+
+        # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
+        assert isinstance(result[obis.VOLTAGE_SWELL_L3_COUNT], CosemObject)
+        assert result[obis.VOLTAGE_SWELL_L3_COUNT].unit is None
+        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
+        assert result[obis.TEXT_MESSAGE].value is None
+
+        # DEVICE_TYPE (0-x:24.1.0)
+        assert isinstance(result[obis.DEVICE_TYPE], CosemObject)
+        assert result[obis.DEVICE_TYPE].unit is None
+        assert isinstance(result[obis.DEVICE_TYPE].value, int)
+        assert result[obis.DEVICE_TYPE].value == 3
+
+        # 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.070')
+
+        # 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.032')
+
+        # 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.142')
+
+        # 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')
+
+        # 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')
+
+        # 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')
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS], CosemObject)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].unit is None
+        assert isinstance(result[obis.EQUIPMENT_IDENTIFIER_GAS].value, str)
+        assert result[obis.EQUIPMENT_IDENTIFIER_GAS].value == '3232323241424344313233343536373839'
+
+        # HOURLY_GAS_METER_READING (0-1:24.2.1)
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING], MBusObject)
+        assert result[obis.HOURLY_GAS_METER_READING].unit == 'm3'
+        assert isinstance(result[obis.HOURLY_GAS_METER_READING].value, Decimal)
+        assert result[obis.HOURLY_GAS_METER_READING].value == Decimal('0.107')
+
+    def test_checksum_valid(self):
+        # No exception is raised.
+        TelegramParser.validate_checksum(TELEGRAM_V5)
+
+    def test_checksum_invalid(self):
+        # Remove the electricty used data value. This causes the checksum to
+        # not match anymore.
+        corrupted_telegram = TELEGRAM_V5.replace(
+            '1-0:1.8.1(000004.426*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_V5.replace('!87B3\r\n', '')
+
+        with self.assertRaises(ParseError):
+            TelegramParser.validate_checksum(corrupted_telegram)
@@ -0,0 +1,54 @@
+from unittest.mock import Mock
+
+import unittest
+
+from dsmr_parser import obis_references as obis
+from dsmr_parser import telegram_specifications
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.clients.protocol import DSMRProtocol
+
+
+TELEGRAM_V2_2 = (
+    '/ISk5\2MT382-1004\r\n'
+    '\r\n'
+    '0-0:96.1.1(00000000000000)\r\n'
+    '1-0:1.8.1(00001.001*kWh)\r\n'
+    '1-0:1.8.2(00001.001*kWh)\r\n'
+    '1-0:2.8.1(00001.001*kWh)\r\n'
+    '1-0:2.8.2(00001.001*kWh)\r\n'
+    '0-0:96.14.0(0001)\r\n'
+    '1-0:1.7.0(0001.01*kW)\r\n'
+    '1-0:2.7.0(0000.00*kW)\r\n'
+    '0-0:17.0.0(0999.00*kW)\r\n'
+    '0-0:96.3.10(1)\r\n'
+    '0-0:96.13.1()\r\n'
+    '0-0:96.13.0()\r\n'
+    '0-1:24.1.0(3)\r\n'
+    '0-1:96.1.0(000000000000)\r\n'
+    '0-1:24.3.0(161107190000)(00)(60)(1)(0-1:24.2.1)(m3)\r\n'
+    '(00001.001)\r\n'
+    '0-1:24.4.0(1)\r\n'
+    '!\r\n'
+)
+
+
+class ProtocolTest(unittest.TestCase):
+
+    def setUp(self):
+        telegram_parser = TelegramParser(telegram_specifications.V2_2)
+        self.protocol = DSMRProtocol(None, telegram_parser,
+                                     telegram_callback=Mock())
+
+    def test_complete_packet(self):
+        """Protocol should assemble incoming lines into complete packet."""
+
+        self.protocol.data_received(TELEGRAM_V2_2.encode('ascii'))
+
+        telegram = self.protocol.telegram_callback.call_args_list[0][0][0]
+        assert isinstance(telegram, dict)
+
+        assert float(telegram[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
+        assert telegram[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+
+        assert float(telegram[obis.GAS_METER_READING].value) == 1.001
+        assert telegram[obis.GAS_METER_READING].unit == 'm3'
@@ -0,0 +1,322 @@
+import unittest
+import datetime
+import pytz
+
+from dsmr_parser import telegram_specifications
+from dsmr_parser import obis_name_mapping
+from dsmr_parser.objects import CosemObject
+from dsmr_parser.objects import MBusObject
+from dsmr_parser.objects import Telegram
+from dsmr_parser.objects import ProfileGenericObject
+from dsmr_parser.parsers import TelegramParser
+from test.example_telegrams import TELEGRAM_V4_2
+from decimal import Decimal
+
+
+class TelegramTest(unittest.TestCase):
+    """ Test instantiation of Telegram object """
+
+    def __init__(self, *args, **kwargs):
+        self.item_names_tested = []
+        super(TelegramTest, self).__init__(*args, **kwargs)
+
+    def verify_telegram_item(self, telegram, testitem_name, object_type, unit_val, value_type, value_val):
+        testitem = eval("telegram.{}".format(testitem_name))
+        assert isinstance(testitem, object_type)
+        assert testitem.unit == unit_val
+        assert isinstance(testitem.value, value_type)
+        assert testitem.value == value_val
+        self.item_names_tested.append(testitem_name)
+
+    def test_instantiate(self):
+        parser = TelegramParser(telegram_specifications.V4)
+        telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
+
+        # P1_MESSAGE_HEADER (1-3:0.2.8)
+        self.verify_telegram_item(telegram,
+                                  'P1_MESSAGE_HEADER',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='42')
+
+        # P1_MESSAGE_TIMESTAMP (0-0:1.0.0)
+        self.verify_telegram_item(telegram,
+                                  'P1_MESSAGE_TIMESTAMP',
+                                  CosemObject,
+                                  unit_val=None,
+                                  value_type=datetime.datetime,
+                                  value_val=datetime.datetime(2016, 11, 13, 19, 57, 57, tzinfo=pytz.UTC))
+
+        # ELECTRICITY_USED_TARIFF_1 (1-0:1.8.1)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_USED_TARIFF_1',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1581.123'))
+
+        # ELECTRICITY_USED_TARIFF_2 (1-0:1.8.2)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_USED_TARIFF_2',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1435.706'))
+
+        # ELECTRICITY_DELIVERED_TARIFF_1 (1-0:2.8.1)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_DELIVERED_TARIFF_1',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # ELECTRICITY_DELIVERED_TARIFF_2 (1-0:2.8.2)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_DELIVERED_TARIFF_2',
+                                  object_type=CosemObject,
+                                  unit_val='kWh',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # ELECTRICITY_ACTIVE_TARIFF (0-0:96.14.0)
+        self.verify_telegram_item(telegram,
+                                  'ELECTRICITY_ACTIVE_TARIFF',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='0002')
+
+        # EQUIPMENT_IDENTIFIER (0-0:96.1.1)
+        self.verify_telegram_item(telegram,
+                                  'EQUIPMENT_IDENTIFIER',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='3960221976967177082151037881335713')
+
+        # CURRENT_ELECTRICITY_USAGE (1-0:1.7.0)
+        self.verify_telegram_item(telegram,
+                                  'CURRENT_ELECTRICITY_USAGE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('2.027'))
+
+        # CURRENT_ELECTRICITY_DELIVERY (1-0:2.7.0)
+        self.verify_telegram_item(telegram,
+                                  'CURRENT_ELECTRICITY_DELIVERY',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # SHORT_POWER_FAILURE_COUNT (1-0:96.7.21)
+        self.verify_telegram_item(telegram,
+                                  'SHORT_POWER_FAILURE_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=15)
+
+        # LONG_POWER_FAILURE_COUNT (96.7.9)
+        self.verify_telegram_item(telegram,
+                                  'LONG_POWER_FAILURE_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=7)
+
+        # VOLTAGE_SAG_L1_COUNT (1-0:32.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L1_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SAG_L2_COUNT (1-0:52.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L2_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SAG_L3_COUNT (1-0:72.32.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SAG_L3_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L1_COUNT (1-0:32.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L1_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L2_COUNT (1-0:52.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L2_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # VOLTAGE_SWELL_L3_COUNT (1-0:72.36.0)
+        self.verify_telegram_item(telegram,
+                                  'VOLTAGE_SWELL_L3_COUNT',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=0)
+
+        # TEXT_MESSAGE_CODE (0-0:96.13.1)
+        self.verify_telegram_item(telegram,
+                                  'TEXT_MESSAGE_CODE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=type(None),
+                                  value_val=None)
+
+        # TEXT_MESSAGE (0-0:96.13.0)
+        self.verify_telegram_item(telegram,
+                                  'TEXT_MESSAGE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=type(None),
+                                  value_val=None)
+
+        # INSTANTANEOUS_CURRENT_L1 (1-0:31.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L1',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_CURRENT_L2 (1-0:51.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L2',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  value_type=Decimal,
+                                  value_val=Decimal('6'))
+
+        # INSTANTANEOUS_CURRENT_L3 (1-0:71.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_CURRENT_L3',
+                                  object_type=CosemObject,
+                                  unit_val='A',
+                                  value_type=Decimal,
+                                  value_val=Decimal('2'))
+
+        # DEVICE_TYPE (0-x:24.1.0)
+        self.verify_telegram_item(telegram,
+                                  'DEVICE_TYPE',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=int,
+                                  value_val=3)
+
+        # INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE (1-0:21.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L1_POSITIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0.170'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE (1-0:41.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L2_POSITIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('1.247'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE (1-0:61.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L3_POSITIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0.209'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE (1-0:22.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L1_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE (1-0:42.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L2_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE (1-0:62.7.0)
+        self.verify_telegram_item(telegram,
+                                  'INSTANTANEOUS_ACTIVE_POWER_L3_NEGATIVE',
+                                  object_type=CosemObject,
+                                  unit_val='kW',
+                                  value_type=Decimal,
+                                  value_val=Decimal('0'))
+
+        # EQUIPMENT_IDENTIFIER_GAS (0-x:96.1.0)
+        self.verify_telegram_item(telegram,
+                                  'EQUIPMENT_IDENTIFIER_GAS',
+                                  object_type=CosemObject,
+                                  unit_val=None,
+                                  value_type=str,
+                                  value_val='4819243993373755377509728609491464')
+
+        # HOURLY_GAS_METER_READING (0-1:24.2.1)
+        self.verify_telegram_item(telegram,
+                                  'HOURLY_GAS_METER_READING',
+                                  object_type=MBusObject,
+                                  unit_val='m3',
+                                  value_type=Decimal,
+                                  value_val=Decimal('981.443'))
+
+        # POWER_EVENT_FAILURE_LOG (1-0:99.97.0)
+        testitem_name = 'POWER_EVENT_FAILURE_LOG'
+        object_type = ProfileGenericObject
+        testitem = eval("telegram.{}".format(testitem_name))
+        assert isinstance(testitem, object_type)
+        assert testitem.buffer_length == 3
+        assert testitem.buffer_type == '0-0:96.7.19'
+        buffer = testitem.buffer
+        assert isinstance(testitem.buffer, list)
+        assert len(buffer) == 3
+        assert all([isinstance(item, MBusObject) for item in buffer])
+        date0 = datetime.datetime(2000, 1, 4, 17, 3, 20, tzinfo=datetime.timezone.utc)
+        date1 = datetime.datetime(1999, 12, 31, 23, 0, 1, tzinfo=datetime.timezone.utc)
+        date2 = datetime.datetime(2000, 1, 1, 23, 0, 3, tzinfo=datetime.timezone.utc)
+        assert buffer[0].datetime == date0
+        assert buffer[1].datetime == date1
+        assert buffer[2].datetime == date2
+        assert buffer[0].value == 237126
+        assert buffer[1].value == 2147583646
+        assert buffer[2].value == 2317482647
+        assert all([isinstance(item.value, int) for item in buffer])
+        assert all([isinstance(item.unit, str) for item in buffer])
+        assert all([(item.unit == 's') for item in buffer])
+        self.item_names_tested.append(testitem_name)
+
+        # check if all items in telegram V4 specification are covered
+        V4_name_list = [obis_name_mapping.EN[signature] for signature, parser in
+                        telegram_specifications.V4['objects'].items()]
+        V4_name_set = set(V4_name_list)
+        item_names_tested_set = set(self.item_names_tested)
+
+        assert item_names_tested_set == V4_name_set
@@ -0,0 +1,105 @@
+import unittest
+
+from dsmr_parser.clients.telegram_buffer import TelegramBuffer
+from test.example_telegrams import TELEGRAM_V2_2, TELEGRAM_V4_2
+
+
+class TelegramBufferTest(unittest.TestCase):
+
+    def setUp(self):
+        self.telegram_buffer = TelegramBuffer()
+
+    def test_v22_telegram(self):
+        self.telegram_buffer.append(TELEGRAM_V2_2)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V2_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_v42_telegram(self):
+        self.telegram_buffer.append(TELEGRAM_V4_2)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_multiple_mixed_telegrams(self):
+        self.telegram_buffer.append(
+            ''.join((TELEGRAM_V2_2, TELEGRAM_V4_2, TELEGRAM_V2_2))
+        )
+
+        telegrams = list(self.telegram_buffer.get_all())
+
+        self.assertListEqual(
+            telegrams,
+            [
+                TELEGRAM_V2_2,
+                TELEGRAM_V4_2,
+                TELEGRAM_V2_2
+            ]
+        )
+
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_v42_telegram_preceded_with_unclosed_telegram(self):
+        # There are unclosed telegrams at the start of the buffer.
+        incomplete_telegram = TELEGRAM_V4_2[:-1]
+
+        self.telegram_buffer.append(incomplete_telegram + TELEGRAM_V4_2)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_v42_telegram_preceded_with_unopened_telegram(self):
+        # There is unopened telegrams at the start of the buffer indicating that
+        # the buffer was being filled while the telegram was outputted halfway.
+        incomplete_telegram = TELEGRAM_V4_2[1:]
+
+        self.telegram_buffer.append(incomplete_telegram + TELEGRAM_V4_2)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_v42_telegram_trailed_by_unclosed_telegram(self):
+        incomplete_telegram = TELEGRAM_V4_2[:-1]
+
+        self.telegram_buffer.append(TELEGRAM_V4_2 + incomplete_telegram)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, incomplete_telegram)
+
+    def test_v42_telegram_trailed_by_unopened_telegram(self):
+        incomplete_telegram = TELEGRAM_V4_2[1:]
+
+        self.telegram_buffer.append(TELEGRAM_V4_2 + incomplete_telegram)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, incomplete_telegram)
+
+    def test_v42_telegram_adding_line_by_line(self):
+        for line in TELEGRAM_V4_2.splitlines(keepends=True):
+            self.telegram_buffer.append(line)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
+
+    def test_v42_telegram_adding_char_by_char(self):
+        for char in TELEGRAM_V4_2:
+            self.telegram_buffer.append(char)
+
+        telegram = next(self.telegram_buffer.get_all())
+
+        self.assertEqual(telegram, TELEGRAM_V4_2)
+        self.assertEqual(self.telegram_buffer._buffer, '')
@@ -1,16 +1,26 @@
 [tox]
-envlist = py34,py35
+envlist = py35,py36,py37,py38

 [testenv]
 deps=
  pytest
+  pytest-cov
  pylama
+  pytest-asyncio
+  pytest-catchlog
+  pytest-mock
 commands=
-  py.test test {posargs}
+  py.test --cov=dsmr_parser test {posargs}
  pylama dsmr_parser test

+[pylama:dsmr_parser/clients/__init__.py]
+ignore = W0611
+
+[pylama:dsmr_parser/parsers.py]
+ignore = W605
+
 [pylama:pylint]
-max_line_length = 100
+max_line_length = 120

 [pylama:pycodestyle]
-max_line_length = 100
+max_line_length = 120
Author	SHA1	Message	Date
Nigel	af9a99d995	Revert "fix for empty parentheses in ProfileGenericParser"	2020-12-15 14:59:35 +01:00
Nigel	a7b4929eab	preparation for v0.25	2020-12-14 17:21:16 +01:00
Nigel	8999b1c924	Merge branch 'master' of github.com:ndokter/dsmr_parser	2020-12-14 17:16:55 +01:00
Nigel	2391f38c4a	Merge pull request #57 from avandermeer/master fix for empty parentheses in ProfileGenericParser	2020-12-14 16:55:38 +01:00
Nigel	d1a6e15c68	Merge pull request #66 from GuyFoetz/foreign_name_mapping adding the # Alternate codes for foreign countries.	2020-12-13 13:22:15 +01:00
Guy Foetz	b7c8626d0c	adding the # Alternate codes for foreign countries.	2020-12-13 12:15:51 +00:00
Nigel	684023d0b6	Preparing for release 0.24	2020-11-27 21:18:59 +01:00
Nigel	1a886aa03b	Merge pull request #62 from RobBie1221/add_lux_eq Add Luxembourg equipment identifier	2020-11-12 17:10:54 +01:00
Nigel	1c7535448e	Updated changelog and version	2020-11-07 08:56:24 +01:00
Rob Bierbooms	2a95d33c02	Add Luxembourg equipment identifier	2020-11-04 20:42:38 +01:00
Nigel	de6725dff8	Merge pull request #58 from dunajski/master Corrects example telegrams.	2020-11-03 21:29:35 +01:00
Nigel	1b1a3f505e	Merge pull request #59 from scop/dont-install-tests Do not install tests	2020-11-03 21:27:21 +01:00
Nigel	ebea385753	Merge pull request #61 from lowdef/issue60 issue#60 resolved issue with x-x:24.3.0 where it contains non-integer…	2020-11-03 21:25:39 +01:00
Hans Erik van Elburg	700cf6a2b3	issue#60 resolved issue with x-x:24.3.0 where it contains non-integer characters, parse 2nd value as string instead of integer	2020-11-02 00:29:03 +01:00
Ville Skyttä	7a687a99a6	Do not install tests	2020-10-18 10:49:09 +03:00
dunajski	86d665df39	Change README.md according to change in `ec1d37e` In `ec1d37ea08` changed example telegrams, so example telegram from README.md should be corrected too.	2020-09-28 11:35:47 +02:00
dunajski	ec1d37ea08	Corrects example telegrams. In example telegrams there a few mistakes in header strings. Using '\' in strings have special feature to add to string some non-printable characters, for example to add new line we can add \n for tab \t etc. So whenever we want to just print backslash as normal character we have to add another '\' before. In short string "On\\Off" prints "On\Off" ascii string. In enquired telegrams there are few strings with \2 sign in header, '/ISk5\2MT382-1000\r\n' and when we calculate CRC for whole given telegram part of "..\2.." is interpreted as one character (value 0x02) instead of two characters ('\', '2'). I think in a header in the example enlosed in P1 DSMR Companion Standard /ISk5\2.. stand for printable '\' and '2' character instead of "converted" to special '\2' character.	2020-09-28 10:22:16 +02:00
albert	dc902a83e9	referring to parent method from _parse_values in ProfileGenericParser	2020-09-08 12:30:51 +02:00
albert	be4386bc59	tempfix for empty profileGenericParser	2020-09-07 18:15:49 +02:00
Nigel	0427ace079	Updated changelog	2020-08-23 09:36:31 +02:00
Nigel	addf9b590e	Merge pull request #55 from aequitas/exception Pass exception to log.exception as it is not called from within an ex…	2020-08-23 09:32:44 +02:00
Nigel	51f821a7fc	Merge pull request #49 from dupondje/fix_pycrc Improve CRC speed	2020-08-23 09:30:22 +02:00
Johan Bloemberg	5630520771	Pass exception to log.exception as it is not called from within an except: clause. Add Python 3.8 test support, drop Python 3.4 test support.	2020-07-21 10:31:40 +02:00
Nigel	f9e188812f	Merge pull request #54 from lowdef/fix_json_serialization Fix json serialization	2020-05-29 17:22:53 +02:00
Hans Erik van Elburg	837ba3b6f7	add json serialization	2020-05-25 01:38:14 +02:00
Hans Erik van Elburg	94447c3571	GenericProfileObject value: make embedded buffer items also appear as dicts	2020-05-17 16:58:28 +02:00
Hans Erik van Elburg	c2dea29c83	add a value property to GenericProfileObject, return a dict	2020-05-17 16:49:29 +02:00
Nigel	bb486fc76f	Merge pull request #53 from lowdef/profile_generic_parser Profile generic parser	2020-05-17 09:12:56 +02:00
Hans Erik van Elburg	789871899c	ProfileGeneric parser working, ProfileGenericObject implemented and Test for V4 telegram completed.	2020-05-17 01:25:02 +02:00
Hans Erik van Elburg	b6278a8991	ProfileGeneric parser working, TODO complete ProfileGenericObject + Test	2020-05-16 16:31:26 +02:00
Hans Erik van Elburg	a0ce89054a	make all objects able to print their own values	2020-05-12 23:45:16 +02:00
Hans Erik van Elburg	9610fbc3c1	Merge branch 'add_missing_elements_DSRM_Specification_4'	2020-05-11 22:22:00 +02:00
Hans Erik van Elburg	d1ad4fa585	igonre venv/	2020-05-11 21:08:20 +02:00
Hans Erik van Elburg	a44afb1a59	ignore .venv	2020-05-10 20:47:11 +02:00
Hans Erik van Elburg	d98c93a57f	modified changelog	2020-05-03 11:37:53 +02:00
Hans Erik van Elburg	fc4a96ebab	bump version	2020-05-03 11:18:08 +02:00
Hans Erik van Elburg	c4331f6cd6	add tests for the missing elements and correct some test bugs	2020-05-02 15:50:00 +02:00
Hans Erik van Elburg	88c9ccd83d	Add following missing signatures to the V4 telegram specification SHORT_POWER_FAILURE_COUNT, INSTANTANEOUS_CURRENT_L1, INSTANTANEOUS_CURRENT_L2, INSTANTANEOUS_CURRENT_L3.	2020-05-01 20:36:35 +02:00
Jean-Louis Dupond	78419f6cc7	Improve CRC speed	2020-02-16 09:31:06 +01:00
Nigel	d423070853	Merge pull request #45 from lowdef/extend_filereader Extend filereader	2020-02-03 17:31:15 +01:00
Nigel	987d35332a	Merge branch 'master' into extend_filereader	2020-02-03 17:29:39 +01:00
lowdef	fe710e9272	redo essential change	2020-02-02 22:54:21 +01:00
lowdef	a7b0b03391	remove conflicting entries	2020-02-02 22:52:06 +01:00
Hans Erik van Elburg	5d88284d8d	remove requires property again	2020-02-02 22:34:17 +01:00
Hans Erik van Elburg	b6537678a7	cleaned up based on pylama complaints / pinpointed to coverage version 4.5.4 as next version is incompatible	2020-02-02 22:12:25 +01:00
Hans Erik van Elburg	fee3f696c4	merged upstream 0.18 version and resolved conflict	2020-02-02 17:26:47 +01:00
Nigel	dc6c35a0b6	Updated changelog	2020-01-28 19:40:27 +01:00
Nigel	47c20e763f	Merge branch 'master' of github.com:ndokter/dsmr_parser	2020-01-28 19:36:23 +01:00
Nigel	e7164d9af7	Merge pull request #48 from dupondje/fix_pycrc Include needed PyCRC code	2020-01-28 19:35:42 +01:00
Jean-Louis Dupond	d714528c5a	Include needed PyCRC code	2020-01-28 17:26:45 +01:00
Hans Erik van Elburg	0675a6e2e7	add tailer dependency	2019-12-27 16:22:10 +01:00
Hans Erik van Elburg	e6625df4a7	add documentation to FileTailReader	2019-12-27 15:18:35 +01:00
Hans Erik van Elburg	8c2485d70f	added file tail reader	2019-12-24 00:57:44 +01:00
Nigel	eac9681e07	updated changelog	2019-12-21 17:37:50 +01:00
Nigel	659560222a	Merge pull request #40 from lowdef/add_a_true_telegram_object Add a true telegram object	2019-12-21 17:36:28 +01:00
Nigel	74fe1f2d1e	Merge branch 'master' into add_a_true_telegram_object	2019-12-21 17:34:58 +01:00
Nigel	a01e673646	updated changelog for new release	2019-12-21 15:02:13 +01:00
Nigel	09614860a6	Merge pull request #44 from dupondje/master Add support for Belgian and Smarty meters	2019-12-21 14:57:02 +01:00
Jean-Louis Dupond	3bfb555d0e	Add support for Belgian and Smarty meters	2019-12-21 14:53:26 +01:00
Hans Erik van Elburg	2d4b0d8e72	fix documentation FileInputReader	2019-12-16 15:41:24 +01:00
Hans Erik van Elburg	43500e6bc2	fix failing import	2019-12-16 15:36:13 +01:00
Hans Erik van Elburg	50cef2646b	add fileinputreader	2019-12-16 15:30:55 +01:00
Nigel	3a8b4d2458	Corrected changelog	2019-12-12 22:33:14 +01:00
Nigel	12aa003799	Updated version number	2019-12-12 22:29:18 +01:00
Nigel	86690ef44b	Merge pull request #43 from WoLpH/patch-1 `create_tcp_dsmr_reader` accepts `loop=None` but always expects a loop. Fixes: #36	2019-12-12 22:22:47 +01:00
Rick van Hattem	7c9c59308e	`create_tcp_dsmr_reader` accepts `loop=None` but always expects a loop. Fixes #36	2019-12-12 22:20:16 +01:00
Hans Erik van Elburg	c1d7ba151d	add some documentation for the file reader	2019-12-09 23:48:48 +01:00
Hans Erik van Elburg	a65949823d	fix filereader	2019-12-09 23:27:57 +01:00
Hans Erik van Elburg	3c78b0b6c4	add file reader	2019-12-09 22:36:46 +01:00
Hans Erik van Elburg	5313edd6cb	add file reader	2019-12-09 22:31:40 +01:00
Hans Erik van Elburg	aa4f9fb967	update version	2019-12-01 18:55:53 +01:00
Hans Erik van Elburg	ea804d485e	add some documentation for the use of the telegram as an object	2019-12-01 18:39:21 +01:00
Hans Erik van Elburg	1b522fc7f0	add some documentation for the use of the telegram as an object	2019-12-01 18:34:21 +01:00
Hans Erik van Elburg	a137ef0e02	add some documentation for the use of the telegram as an object	2019-12-01 17:47:22 +01:00
Hans Erik van Elburg	d712d468ac	remove useless space	2019-11-25 20:44:25 +01:00
Hans Erik van Elburg	95bab6a51a	Merge branch 'master' into add_a_true_telegram_object	2019-11-25 20:30:35 +01:00
Hans Erik van Elburg	49999618ea	Merge remote-tracking branch 'upstream/master'	2019-11-25 20:29:20 +01:00
Hans Erik van Elburg	8ba400800b	small fixes	2019-11-25 01:53:54 +01:00
Hans Erik van Elburg	f7ba363b93	small fixes	2019-11-25 01:37:48 +01:00
Nigel	b31bcd61fc	Updated version number	2019-10-08 22:13:58 +02:00
Hans Erik van Elburg	f9e9e70771	experimentation file	2019-10-03 21:33:11 +02:00
Nigel Dokter	50a5cb9203	Merge pull request #37 from tneele/master Improve performance: read more data from serial port at once	2019-07-29 10:13:13 +02:00
Thomas Neele	8388624721	Read more data from serial port at once A telegram can contain dozens of lines. Reading them one by one is somewhat inefficient. With this change, the client tries to read all data that is available. This significantly reduced CPU load for me.	2019-07-22 21:33:15 +02:00
Hans Erik van Elburg	c36f68a884	working version of the Telegram object	2019-06-06 05:41:55 +02:00
Hans Erik van Elburg	8bdf77c78d	ensure build and dist directories are not synced	2019-04-06 12:56:27 +02:00
Nigel	c04b0a5add	Updated version number	2019-03-04 20:31:51 +01:00
Nigel Dokter	ed2290a597	Merge pull request #33 from mleenaerts/patch-1 Fix DSMR v5.0 serial settings which were not used	2019-01-22 19:27:56 +01:00
Mark Leenaerts	85c67464a1	Fix DSMR v5.0 serial settings which were not used While analysing some CRC check errors I encounter within the home-assistant plugin (which uses this component) I encountered this oversight in the code.	2019-01-19 16:11:12 +01:00
Nigel Dokter	48783acc00	Update CHANGELOG.rst	2018-09-23 13:01:22 +02:00
Nigel Dokter	41f6a7ac16	Update CHANGELOG.rst	2018-09-23 13:01:04 +02:00
Nigel Dokter	59811dbf9f	Update setup.py	2018-09-23 12:59:02 +02:00
Nigel Dokter	9b09969763	Merge pull request #31 from tneele/master Add serial settings for DSMR v5.0	2018-09-23 12:50:01 +02:00
Nigel Dokter	64f5dc2e87	Merge pull request #32 from bossjl/master Lux-creos-obis-1.8.0	2018-09-23 12:49:42 +02:00
bossjl	887dd3a2aa	Lux-creos-obis-1.8.0	2018-09-21 18:37:32 +02:00
Thomas Neele	ad6ab304f5	Added serial settings for DSMR v5.0	2018-09-15 21:23:22 +02:00
Nigel Dokter	8582395017	Merge pull request #30 from jk-5/sagemcom-t210-d Added missing values for 3-phase sagemcom TD210-D meter	2018-09-12 23:45:29 +02:00
jk-5	3327c78c0e	Updated unittests	2018-09-06 15:49:11 +02:00
jk-5	472c54968e	Corrected meter types	2018-09-06 15:40:02 +02:00
jk-5	d534b1d8b0	Added missing values for 3-phase sagemcom TD210-D meter	2018-09-06 14:53:30 +02:00
Nigel Dokter	d94bc8de03	updated version	2017-09-18 12:02:36 +02:00
Nigel Dokter	41381f1705	Merge pull request #26 from vavdb/patch-1 Optional NUL after checksum	2017-09-18 11:55:31 +02:00
Vincent van den Braken	e3203a5334	Optional NUL after checksum My smart meter returns 00 0D 0A after the checksum, not just 0D 0A.	2017-09-15 13:48:10 +02:00
Nigel Dokter	c78ebe3e2d	fixed import errors	2017-06-05 21:06:48 +02:00
Nigel Dokter	d6e28db116	log checksum errors as warning; dont force full telegram signatures; removed unused code for automatic telegram version detection;	2017-06-05 21:02:59 +02:00
Nigel Dokter	5f1afeb1f8	Merge pull request #25 from AlexMekkering/optional_telegram_lines Support optional telegram signatures	2017-06-05 20:45:38 +02:00
Alex Mekkering	dcb59fddb1	Support optional telegram signatures	2017-06-05 09:07:47 +02:00
Nigel Dokter	9b0a85e84b	updated version	2017-05-12 21:37:54 +02:00
Nigel Dokter	1dca6ab396	Merge pull request #23 from aequitas/dsmr5 Add DSMR5 option to protocol.	2017-05-12 21:34:06 +02:00
Johan Bloemberg	efc09df71f	Add DSMR5 option to protocol.	2017-05-12 20:30:53 +02:00
Nigel Dokter	de5c884d8d	Small comment improvement	2017-02-27 20:44:18 +01:00
Nigel Dokter	d2f57a8926	fixed pep8	2017-02-27 20:35:19 +01:00
Nigel Dokter	3d64fea247	Updated README	2017-02-27 20:26:15 +01:00
Nigel Dokter	46860e04c1	Formatting	2017-02-03 22:42:31 +01:00
Nigel Dokter	148bdabc12	Updated docs	2017-02-03 22:40:39 +01:00
Nigel Dokter	9d20bb8ad5	experimenting with version detection	2017-01-28 17:01:33 +01:00
Nigel Dokter	24ab9aa712	experimenting with version detection	2017-01-28 17:01:02 +01:00
Nigel Dokter	0c40070752	fixed changelog date	2017-01-26 21:18:56 +01:00
Nigel Dokter	6c8a9dcbdb	added python 3.6 support	2017-01-26 19:06:03 +01:00
Nigel Dokter	c1a6b930c8	try python 3.6 support	2017-01-26 19:04:01 +01:00
Nigel Dokter	9e74c4c23c	adjusting supported python versions	2017-01-26 19:02:15 +01:00
Nigel Dokter	b4a520c8b4	updated readme	2017-01-26 19:00:31 +01:00
Nigel Dokter	a88dfe1a41	added DSMR v3 specification; updated changelog;	2017-01-26 18:50:30 +01:00
Nigel Dokter	c4dcc73191	added DSMR v3 specification	2017-01-26 18:02:21 +01:00
Nigel Dokter	c4caf54576	pep8	2017-01-25 19:34:38 +01:00
Nigel Dokter	8a868ce826	pep8	2017-01-25 19:33:42 +01:00
Nigel Dokter	9623f3b092	added unit test for DSMR v5 parsing	2017-01-25 19:32:30 +01:00
Nigel Dokter	adcfdfe2ae	fixed v2 specification typo; fixed wrongly edited obis reference;	2017-01-22 16:42:02 +01:00
Nigel Dokter	45ee8dbb32	added basic config for DSMR v5 specification; added DSMR v5 example telegram for testing;	2017-01-22 16:39:16 +01:00
Nigel Dokter	7a4c204850	added code comments	2017-01-21 10:42:17 +01:00
Nigel Dokter	45f5fe2c36	define checksum support in telegram specification; moved telegram v2 exception temporarily from parser to MBUSObject;	2017-01-21 10:33:17 +01:00
Nigel Dokter	07634abed1	Progress on removing TelegramParserV2_2 and TelegramParserV4 in favor of a generic TelegramParser	2017-01-20 23:02:19 +01:00
Nigel Dokter	e2e4bb36a2	updated changelog	2017-01-14 20:10:42 +01:00
Nigel Dokter	4eeefec426	update version number to 0.7	2017-01-11 17:44:48 +01:00
Nigel Dokter	f3d8311ac2	updated readme and changelog for upcoming breaking API changes; skip pylama check for unused imports in clients module;	2017-01-11 17:40:25 +01:00
Nigel Dokter	9b488e74f8	renamed serial.py to serial_.py	2017-01-10 20:57:50 +01:00
Nigel Dokter	fadf206715	moved serial clients to own package	2017-01-10 20:09:33 +01:00
Nigel Dokter	e97ab7c7ea	import issues	2017-01-09 21:47:51 +01:00
Nigel Dokter	759e0a0d92	removed absolute imports back to relative due to serial.py importing from serial	2017-01-09 21:31:08 +01:00
Nigel Dokter	21334e5a0a	changed relative imports to absolute; renamed TelegramBuffer.put to TelegramBuffer.append;	2017-01-09 20:15:55 +01:00
Nigel Dokter	11672d0512	pep8	2017-01-08 11:44:20 +01:00
Nigel Dokter	87a5a2d2fa	dev progress	2017-01-08 11:28:15 +01:00
Nigel Dokter	663024239f	dev progress	2017-01-08 11:24:04 +01:00
Nigel Dokter	0e7819b535	dev progress	2017-01-07 22:29:02 +01:00
Nigel Dokter	60317a0dc5	dev progress	2017-01-07 21:26:21 +01:00
Nigel Dokter	d990a316ad	finishing implementation of TelegramBuffer	2017-01-07 11:25:43 +01:00
Nigel Dokter	f10032f701	refactored TelegramParser.parse to accept a str instead of list	2017-01-05 21:24:41 +01:00
Nigel Dokter	1373d570d2	updated version number	2017-01-04 20:06:09 +01:00
Nigel Dokter	29fc97a65c	updated changelog	2017-01-04 20:02:08 +01:00
Nigel Dokter	3b43cbf841	all tests are written using unittest.TestCase now	2017-01-04 19:55:54 +01:00
Nigel Dokter	9d8cad8b46	Merge pull request #15 from AlexMekkering/telegram_pass Pass lines to parser including line endings	2017-01-04 19:19:07 +01:00
Nigel Dokter	0d6c763e86	Merge pull request #12 from aequitas/tcp Add support for TCP connections	2017-01-04 19:16:26 +01:00
Alex Mekkering	8b60d48edd	pycodestyle fixes	2017-01-04 15:01:20 +01:00
Alex Mekkering	03b761e15b	Pass lines to parser including line endings	2017-01-04 14:49:18 +01:00
Nigel Dokter	061334f702	Merge pull request #14 from ndokter/revert-13-crc Revert "Fixed CRC calculation"	2017-01-04 11:58:19 +01:00
Nigel Dokter	920c9aedc2	Revert "Fixed CRC calculation"	2017-01-04 11:58:03 +01:00
Nigel Dokter	991dd09e2a	Merge pull request #13 from AlexMekkering/crc Fixed CRC calculation	2017-01-04 11:07:45 +01:00
Alex Mekkering	ce4d5b0e62	Corrected unit test for failing CRC	2017-01-04 10:51:29 +01:00
Alex Mekkering	e512456cc2	Fixed CRC calculation	2017-01-04 10:21:47 +01:00
Johan Bloemberg	3c9db523fa	Fix tpyo.	2017-01-03 22:27:39 +01:00
Johan Bloemberg	763237ef1d	Add TCP arguments to console. Implement reconnect logic in protocol.	2017-01-03 21:27:10 +01:00
Johan Bloemberg	cdc9e395aa	Add support for TCP connections.	2017-01-03 17:56:24 +01:00
Nigel Dokter	6dec45ae2c	Merge branch 'crc_check'	2016-12-29 19:32:24 +01:00
Nigel Dokter	c2a67bff6d	version v0.5 changelog	2016-12-29 19:30:35 +01:00
Nigel Dokter	b3014823c1	bugfix; updated async client to CRC check	2016-12-29 19:20:50 +01:00
Nigel Dokter	4b392522c3	Removed todo list from readme	2016-12-29 10:08:07 +01:00
Nigel Dokter	1c69b4e9ee	added telegram CRC verification	2016-12-28 20:29:34 +01:00
Nigel Dokter	bbea9de445	Merge pull request #9 from dennissiemensma/code-coverage Code coverage (Tox, Travis & Codecov.io)	2016-11-27 21:01:27 +01:00
Dennis Siemensma	19d3f60aec	Ignore .coverage file	2016-11-27 20:40:52 +01:00
Dennis Siemensma	b228bd524b	Add code coverage with Codecov in Travis	2016-11-27 20:29:49 +01:00
Dennis Siemensma	220db73fbe	Add code coverage with pytest-cov	2016-11-27 20:07:13 +01:00
Nigel Dokter	81fd581e57	pep8	2016-11-26 15:58:24 +01:00
Nigel Dokter	4df6ba75a2	used python unittest for the tests	2016-11-26 15:33:58 +01:00
Nigel Dokter	819d0d0696	updated version number	2016-11-22 19:54:19 +01:00
Nigel Dokter	a3685f0310	added Travis CI badge	2016-11-21 22:31:22 +01:00
Nigel Dokter	5ae6ad4156	typo	2016-11-21 21:49:17 +01:00
Nigel Dokter	e330e9db21	updated changelog	2016-11-21 21:48:17 +01:00
Nigel Dokter	0ac2990df2	accepted changed from pull request instead	2016-11-21 21:46:21 +01:00
Nigel Dokter	e0d91f1ec4	Merge pull request #5 from aequitas/master Even parity offers better compatibility for v2.2.	2016-11-21 21:45:38 +01:00
Nigel Dokter	c058feca5f	make serial.EVEN the default parity for DSMR v2.2	2016-11-21 21:30:56 +01:00
Nigel Dokter	6f3c74ce7c	Merge pull request #8 from aequitas/async_protocol Async protocol	2016-11-21 20:39:57 +01:00
Nigel Dokter	43a3cb7a96	Merge pull request #7 from aequitas/error_handling Add error handling to async serial.	2016-11-21 20:28:11 +01:00
Johan Bloemberg	5e88182301	Complete telegram handling logic.	2016-11-21 17:02:32 +01:00
Johan Bloemberg	e3569e0719	Add asyncio protocol implementation.	2016-11-21 15:48:29 +01:00
Johan Bloemberg	f8a3c76c68	wip async test	2016-11-21 14:35:35 +01:00
Johan Bloemberg	a1d077d6f2	Fix style.	2016-11-21 14:19:12 +01:00
Johan Bloemberg	616db8b1cc	Add error handling to async serial.	2016-11-21 14:11:30 +01:00
Nigel Dokter	927a4bc8e7	added DSMR v4 parsing unit test; added alternative serial settings for DSMR v2 and v4;	2016-11-20 12:44:45 +01:00
Johan Bloemberg	e7ff8f2444	Even parity offers better compatibility for v2.2.	2016-11-15 23:00:59 +01:00
Nigel Dokter	f41fe0894c	changelog	2016-11-12 10:56:16 +01:00
Nigel Dokter	59dd0893a4	Merge pull request #3 from aequitas/asyncio Add asyncio reader.	2016-11-12 10:51:10 +01:00
Johan Bloemberg	e3c8c92198	Linting and tpyo	2016-11-12 01:36:36 +01:00
Johan Bloemberg	9363840042	Project maintenance.	2016-11-12 01:34:32 +01:00
Johan Bloemberg	4afab70dc0	Add asyncio reader.	2016-11-12 01:25:56 +01:00