dsmr_parser/serial.py at 60317a0dc52cc63918e9b884fc1ebcbad99ea4ef

 import asyncio
 import logging
 import re
 import serial
 import serial_asyncio
 from dsmr_parser.exceptions import ParseError
 from dsmr_parser.parsers import TelegramParser, TelegramParserV2_2, \
     TelegramParserV4
 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):
     """
     :param bytes line: series of bytes representing a line.
         Example: b'/KFM5KAIFA-METER\r\n'
     """
     return line.startswith('/')
 def is_end_of_telegram(line):
     """
     :param bytes line: series of bytes representing a line.
         Example: b'!7B05\r\n'
     """
     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
         elif serial_settings is SERIAL_SETTINGS_V4:
             telegram_parser = TelegramParserV4
         else:
             telegram_parser = TelegramParser
         self.telegram_parser = telegram_parser(telegram_specification)
         self.telegram_buffer = TelegramBuffer(self.handle_telegram)
     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'))
     def handle_telegram(self, telegram):
         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'))
             # TODO
             # 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)
 class TelegramBuffer(object):
     """
     Used as a buffer for a stream or telegram data. Returns telegram from buffer
     when complete.
     """
     def __init__(self, callback):
         self._buffer = ''
         self._callback = callback
     def append(self, data):
         """
         Add telegram data to buffer.
         :param str data: chars, lines or full telegram strings of telegram data
         """
         self._buffer += data
         for telegram in self._find_telegrams():
             self._callback(telegram)
             self._remove(telegram)
     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 from 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
         )

No results found.