fixed changelog date

added python 3.6 support
try python 3.6 support
2017-01-26 21:18:56 +01:00 · 2017-01-26 19:06:03 +01:00 · 2017-01-26 19:04:01 +01:00 · 2017-01-26 19:02:15 +01:00 · 2017-01-26 19:00:31 +01:00 · 2017-01-26 18:50:30 +01:00
28 changed files with 1469 additions and 642 deletions
@@ -0,0 +1,2 @@
+[run]
+branch = True
@@ -3,3 +3,6 @@
 .tox
 .cache
 *.egg-info
+/.project
+/.pydevproject
+/.coverage
@@ -1,10 +1,18 @@
 language: python
+
 python:
  - 2.7
  - 3.4
  - 3.5
-install: pip install tox-travis
+  - 3.6
+  
+install: pip install tox-travis codecov
+
 script: tox
+
+after_success:
+  - codecov
+
 matrix:
  allow_failures:
    - python: 2.7
@@ -1,6 +1,35 @@
 Change Log
 ----------

+**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>`_)
@@ -8,7 +37,7 @@ Change Log

 **0.3** (2016-11-12)

- asyncio reader for non-blocking reads. (`pull request #3 <https://github.com/ndokter/dsmr_parser/pull/3>`_)
+- asyncio reader for non-blocking reads (`pull request #3 <https://github.com/ndokter/dsmr_parser/pull/3>`_)

 **0.2** (2016-11-08)

@@ -14,7 +14,7 @@ also includes a serial client 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.4 and 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
@@ -26,7 +26,7 @@ Using the serial reader to connect to your smart meter and parse it's telegrams:

    from dsmr_parser import telegram_specifications
    from dsmr_parser import obis_references
-    from dsmr_parser.serial import SerialReader, SERIAL_SETTINGS_V4
+    from dsmr_parser.clients import SerialReader, SERIAL_SETTINGS_V4

    serial_reader = SerialReader(
        device='/dev/ttyUSB0',
@@ -70,9 +70,3 @@ 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.
-
-TODO
----
-
- verify telegram checksum
- improve ease of use
@@ -1,8 +1,9 @@
+from functools import partial
 import argparse
 import asyncio
 import logging

-from .protocol import create_dsmr_reader
+from dsmr_parser.clients import create_dsmr_reader, create_tcp_dsmr_reader


 def console():
@@ -11,6 +12,10 @@ 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')
@@ -32,7 +37,29 @@ def console():
                print(obj.value, obj.unit)
        print()

-    conn = create_dsmr_reader(args.device, args.version, print_callback, loop=loop)
+    # 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)

-    loop.create_task(conn)
-    loop.run_forever()
+    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
+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,109 @@
+"""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
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.clients.settings import SERIAL_SETTINGS_V2_2, \
+    SERIAL_SETTINGS_V4
+
+
+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
+    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."""
+    protocol, _ = create_dsmr_protocol(
+        dsmr_version, telegram_callback, loop=None)
+    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')
+        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 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,76 @@
+import asyncio
+import logging
+import serial
+import serial_asyncio
+
+from dsmr_parser.clients.telegram_buffer import TelegramBuffer
+from dsmr_parser.exceptions import ParseError
+from dsmr_parser.parsers import TelegramParser
+
+
+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()
+
+    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.readline()
+                self.telegram_buffer.append(data.decode('ascii'))
+
+                for telegram in self.telegram_buffer.get_all():
+                    try:
+                        yield self.telegram_parser.parse(telegram)
+                    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,22 @@
+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
+}
@@ -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}\r\n',
+            self._buffer,
+            re.DOTALL
+        )
@@ -1,2 +1,6 @@
 class ParseError(Exception):
    pass
+
+
+class InvalidChecksumError(ParseError):
+    pass
@@ -1,36 +1,48 @@
-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_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'
+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'
+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,
@@ -12,26 +12,23 @@ 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[5]['value']
+        else:
+            return self.values[1]['value']

    @property
    def unit(self):
-        return self.values[1]['unit']
-
-
-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']
+        # 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[4]['value']
+        else:
+            return self.values[1]['unit']


 class CosemObject(DSMRObject):
@@ -46,5 +43,4 @@ class CosemObject(DSMRObject):


 class ProfileGeneric(DSMRObject):
-    pass
-    # TODO implement
+    pass  # TODO implement
@@ -1,73 +1,99 @@
 import logging
 import re

-from .objects import MBusObject, MBusObjectV2_2, CosemObject
-from .exceptions import ParseError
-from .obis_references import GAS_METER_READING
+from PyCRC.CRC16 import CRC16
+
+from dsmr_parser.objects import MBusObject, CosemObject
+from dsmr_parser.exceptions import ParseError, InvalidChecksumError

 logger = logging.getLogger(__name__)


 class TelegramParser(object):

-    def __init__(self, telegram_specification):
+    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: full telegram from start ('/') to checksum
+            ('!ABCD') including line endings inbetween 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
+            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 = CRC16().calculate(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."""
-
-        def join_lines(line_values):
-            join_next = re.compile(GAS_METER_READING)
-
-            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
-
-        return super().parse(join_lines(line_values))
+        if calculated_crc != expected_crc:
+            raise InvalidChecksumError(
+                "Invalid telegram. The CRC checksum '{}' does not match the "
+                "expected '{}'".format(
+                    calculated_crc,
+                    expected_crc
+                )
+            )


 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
@@ -105,11 +131,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):
@@ -162,6 +184,15 @@ class ProfileGenericParser(DSMRObjectParser):


 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
@@ -1,97 +0,0 @@
-"""Asyncio protocol implementation for handling telegrams."""
-
-import asyncio
-import logging
-from functools import partial
-
-from serial_asyncio import create_serial_connection
-
-from . import telegram_specifications
-from .exceptions import ParseError
-from .parsers import TelegramParser, TelegramParserV2_2
-from .serial import (SERIAL_SETTINGS_V2_2, SERIAL_SETTINGS_V4,
-                     is_end_of_telegram, is_start_of_telegram)
-
-
-def create_dsmr_reader(port, dsmr_version, telegram_callback, loop=None):
-    """Creates a DSMR asyncio protocol coroutine."""
-
-    if dsmr_version == '2.2':
-        specifications = telegram_specifications.V2_2
-        telegram_parser = TelegramParserV2_2
-        serial_settings = SERIAL_SETTINGS_V2_2
-    elif dsmr_version == '4':
-        specifications = telegram_specifications.V4
-        telegram_parser = TelegramParser
-        serial_settings = SERIAL_SETTINGS_V4
-
-    serial_settings['url'] = port
-
-    protocol = partial(DSMRProtocol, loop, telegram_parser(specifications),
-                       telegram_callback=telegram_callback)
-
-    conn = create_serial_connection(loop, protocol, **serial_settings)
-
-    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 incoming telegram lines
-        self.telegram = []
-        # buffer to keep incomplete incoming data
-        self.buffer = ''
-
-    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()
-        self.log.debug('received data: %s', data.strip())
-        self.buffer += data
-        self.handle_lines()
-
-    def handle_lines(self):
-        """Assemble incoming data into single lines."""
-        while "\r\n" in self.buffer:
-            line, self.buffer = self.buffer.split("\r\n", 1)
-            self.log.debug('got line: %s', line)
-
-            # Telegrams need to be complete because the values belong to a
-            # particular reading and can also be related to eachother.
-            if not self.telegram and not is_start_of_telegram(line):
-                continue
-
-            self.telegram.append(line)
-            if is_end_of_telegram(line):
-                try:
-                    parsed_telegram = self.telegram_parser.parse(self.telegram)
-                    self.handle_telegram(parsed_telegram)
-                except ParseError:
-                    self.log.exception("failed to parse telegram")
-                self.telegram = []
-
-    def connection_lost(self, exc):
-        """Stop when connection is lost."""
-        self.log.error('disconnected')
-
-    def handle_telegram(self, telegram):
-        """Send off parsed telegram to handling callback."""
-        self.log.debug('got telegram: %s', telegram)
-
-        if self.telegram_callback:
-            self.telegram_callback(telegram)
@@ -1,125 +0,0 @@
-import asyncio
-import logging
-
-import serial
-
-import serial_asyncio
-from dsmr_parser.exceptions import ParseError
-from dsmr_parser.parsers import TelegramParser, TelegramParserV2_2
-
-logger = logging.getLogger(__name__)
-
-
-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
-}
-
-
-def is_start_of_telegram(line):
-    return line.startswith('/')
-
-
-def is_end_of_telegram(line):
-    return line.startswith('!')
-
-
-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
-
-        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 = []
-
-
-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 Generator/Async
-        """
-        # create Serial StreamReader
-        conn = serial_asyncio.open_serial_connection(**self.serial_settings)
-        reader, _ = yield from conn
-
-        telegram = []
-
-        while True:
-            # read line if available or give control back to loop until
-            # new data has arrived
-            line = yield from reader.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):
-                try:
-                    parsed_telegram = self.telegram_parser.parse(telegram)
-                    # push new parsed telegram onto queue
-                    queue.put_nowait(parsed_telegram)
-                except ParseError:
-                    logger.exception("failed to parse telegram")
-
-                telegram = []
@@ -1,8 +1,8 @@
 from decimal import Decimal

-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
+from dsmr_parser.value_types import timestamp


 """
@@ -14,60 +14,134 @@ 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(int),
+            ValueParser(int),
+            ValueParser(int),
+            ValueParser(str),
+            ValueParser(Decimal),
+        ),
+    }
+}
+
+V3 = {
+    '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(int),
+            ValueParser(int),
+            ValueParser(int),
+            ValueParser(str),
+            ValueParser(Decimal),
+        ),
+    }
 }

 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.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)
+        )
+    }
+}
+
+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_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)),
+        # 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: 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)
+        )
+    }
 }
@@ -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:
@@ -6,12 +6,13 @@ setup(
    author='Nigel Dokter',
    author_email='nigeldokter@gmail.com',
    url='https://github.com/ndokter/dsmr_parser',
-    version='0.4',
+    version='0.8',
    packages=find_packages(),
    install_requires=[
        'pyserial>=3,<4',
        'pyserial-asyncio<1',
-        'pytz'
+        'pytz',
+        'PyCRC>=1.2,<2'
    ],
    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'
+    '!87B3\r\n'
+)
@@ -1,41 +1,92 @@
-"""Test parsing of a DSMR v2.2 telegram."""
+import unittest

-from dsmr_parser.parsers import TelegramParserV2_2
+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
-
-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)",
-    "!",
-]
+from test.example_telegrams import TELEGRAM_V2_2


-def test_parse():
-    """Test if telegram parsing results in correct results."""
+class TelegramParserV2_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v2.2 telegram. """

-    parser = TelegramParserV2_2(telegram_specifications.V2_2)
-    result = parser.parse(TELEGRAM_V2_2)
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V2_2)
+        result = parser.parse(TELEGRAM_V2_2)

-    assert float(result[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
-    assert result[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+        # 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')

-    assert float(result[obis.GAS_METER_READING].value) == 1.001
-    assert result[obis.GAS_METER_READING].unit == 'm3'
+        # 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')
@@ -1,232 +1,221 @@
-"""Test parsing of a DSMR v4.2 telegram."""
-import datetime
 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
-
-TELEGRAM_V4_2 = [
-    '1-3:0.2.8(42)',
-    '0-0:1.0.0(161113205757W)',
-    '0-0:96.1.1(1231231231231231231231231231231231)',
-    '1-0:1.8.1(001511.267*kWh)',
-    '1-0:1.8.2(001265.173*kWh)',
-    '1-0:2.8.1(000000.000*kWh)',
-    '1-0:2.8.2(000000.000*kWh)',
-    '0-0:96.14.0(0001)',
-    '1-0:1.7.0(00.235*kW)',
-    '1-0:2.7.0(00.000*kW)',
-    '0-0:96.7.21(00015)',
-    '0-0:96.7.9(00007)',
-    ('1-0:99.97.0(3)(0-0:96.7.19)(000103180420W)(0000237126*s)'
-     '(000101000001W)(2147483647*s)(000101000001W)(2147483647*s)'),
-    '1-0:32.32.0(00000)',
-    '1-0:52.32.0(00000)',
-    '1-0:72.32.0(00000)',
-    '1-0:32.36.0(00000)',
-    '1-0:52.36.0(00000)',
-    '1-0:72.36.0(00000)',
-    '0-0:96.13.1()',
-    '0-0:96.13.0()',
-    '1-0:31.7.0(000*A)',
-    '1-0:51.7.0(000*A)',
-    '1-0:71.7.0(000*A)',
-    '1-0:21.7.0(00.095*kW)',
-    '1-0:22.7.0(00.000*kW)',
-    '1-0:41.7.0(00.025*kW)',
-    '1-0:42.7.0(00.000*kW)',
-    '1-0:61.7.0(00.115*kW)',
-    '1-0:62.7.0(00.000*kW)',
-    '0-1:24.1.0(003)',
-    '0-1:96.1.0(3404856892390357246729543587524029)',
-    '0-1:24.2.1(161113200000W)(00915.219*m3)',
-    '!5D83',
-]
+from test.example_telegrams import TELEGRAM_V4_2


-def test_parse():
-    parser = TelegramParser(telegram_specifications.V4)
-    result = parser.parse(TELEGRAM_V4_2)
+class TelegramParserV4_2Test(unittest.TestCase):
+    """ Test parsing of a DSMR v4.2 telegram. """

-    # 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'
+    def test_parse(self):
+        parser = TelegramParser(telegram_specifications.V4)
+        result = parser.parse(TELEGRAM_V4_2)

-    # 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)
+        # 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'

-    # 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('1511.267')
+        # 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_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('1265.173')
+        # 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_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_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_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_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_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'
+        # 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')

-    # 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 == '1231231231231231231231231231231231'
+        # 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'

-    # 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.235')
+        # 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_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')
+        # 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')

-    # 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
+        # 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')

-    # 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
+        # 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_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_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_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_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_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_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_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_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_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
+        # 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

-    # 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
+        # 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 (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
+        # 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

-    # 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, int)
-    assert result[obis.DEVICE_TYPE].value == 3
+        # 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_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.095')
+        # 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, int)
+        assert result[obis.DEVICE_TYPE].value == 3

-    # 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.025')
+        # 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_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.115')
+        # 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_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_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_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_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_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')
+        # 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')

-    # 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 == '3404856892390357246729543587524029'
+        # 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')

-    # 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('915.219')
+        # 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'

-    # POWER_EVENT_FAILURE_LOG (99.97.0)
-    # TODO to be implemented
+        # 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')

-    # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
-    # TODO to be implemented
+        # POWER_EVENT_FAILURE_LOG (99.97.0)
+        # TODO to be implemented

-    # ACTUAL_SWITCH_POSITION (0-0:96.3.10)
-    # TODO to be implemented
+        # ACTUAL_TRESHOLD_ELECTRICITY (0-0:17.0.0)
+        # TODO to be implemented

-    # VALVE_POSITION_GAS (0-x:24.4.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,205 @@
+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
+
+        # 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 (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, 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)
@@ -1,39 +1,54 @@
-"""Test DSMR serial protocol."""
-
 from unittest.mock import Mock

-import pytest
+import unittest
+
 from dsmr_parser import obis_references as obis
 from dsmr_parser import telegram_specifications
-from dsmr_parser.parsers import TelegramParserV2_2
-from dsmr_parser.protocol import DSMRProtocol
-
-from .test_parse_v2_2 import TELEGRAM_V2_2
+from dsmr_parser.parsers import TelegramParser
+from dsmr_parser.clients.protocol import DSMRProtocol


-@pytest.fixture
-def protocol():
-    """DSMRprotocol instance with mocked telegram_callback."""
-
-    parser = TelegramParserV2_2
-    specification = telegram_specifications.V2_2
-
-    telegram_parser = parser(specification)
-    return DSMRProtocol(None, telegram_parser,
-                        telegram_callback=Mock())
+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'
+)


-def test_complete_packet(protocol):
-    """Protocol should assemble incoming lines into complete packet."""
+class ProtocolTest(unittest.TestCase):

-    for line in TELEGRAM_V2_2:
-        protocol.data_received(bytes(line + '\r\n', 'ascii'))
+    def setUp(self):
+        telegram_parser = TelegramParser(telegram_specifications.V2_2)
+        self.protocol = DSMRProtocol(None, telegram_parser,
+                                     telegram_callback=Mock())

-    telegram = protocol.telegram_callback.call_args_list[0][0][0]
-    assert isinstance(telegram, dict)
+    def test_complete_packet(self):
+        """Protocol should assemble incoming lines into complete packet."""

-    assert float(telegram[obis.CURRENT_ELECTRICITY_USAGE].value) == 1.01
-    assert telegram[obis.CURRENT_ELECTRICITY_USAGE].unit == 'kW'
+        self.protocol.data_received(TELEGRAM_V2_2.encode('ascii'))

-    assert float(telegram[obis.GAS_METER_READING].value) == 1.001
-    assert telegram[obis.GAS_METER_READING].unit == 'm3'
+        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,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,17 +1,22 @@
 [tox]
-envlist = py34,py35
+envlist = py34,py35,p36

 [testenv]
 deps=
  pytest
+  pytest-cov
  pylama
  pytest-asyncio
  pytest-catchlog
  pytest-mock
+  PyCRC
 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:pylint]
 max_line_length = 100
Author	SHA1	Message	Date
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