diff --git a/.gitignore b/.gitignore
index 894b10a..90d1a19 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,6 @@
 /MANIFEST
 /dist/
 __pycache__/
+.cache
+build
+*.egg-info/
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..1948c7f
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,14 @@
+language: python
+
+python:
+  - 3.4
+  - 3.5
+  - 3.6
+
+install:
+  - pip install -r test-requirements.txt
+
+script:
+  - py.test
+  - python setup.py bdist_wheel
+  - pip install ./dist/glucometerutils-*.whl
diff --git a/README b/README
index d87f3b8..0d90ea2 100644
--- a/README
+++ b/README
@@ -13,26 +13,41 @@ follows:
  * `datetime` reads or updates the date and time of the device clock.
  * `zero` deletes all the recorded readings (only implemented for few devices).
 
+## Example Usage
+
+Most of the drivers require optional dependencies, and those are listed in the
+table below. If you do not want to install the dependencies manually, you should
+be able to set this up using `virtualenv` and `pip`:
+
+```shell
+$ python3 -m venv $(pwd)/glucometerutils-venv
+$ . glucometerutils-venv/bin/activate
+(glucometerutils-venv) $ DRIVER=myglucometer-driver  # see table below
+(glucometerutils-venv) $ pip install "git+https://github.com/Flameeyes/glucometerutils.git#egg=project[${DRIVER}]"
+(glucometerutils-venv) $ glucometer --driver ${DRIVER} help
+```
+
 ## Supported devices
 
 Please see the following table for the driver for each device that is known and
 supported.
 
-| Manufacturer | Model Name              | Driver             | Dependencies  |
-| ---          | ---                     | ---                | ---           |
-| LifeScan     | OneTouch Ultra 2        | `otultra2`         | [pyserial]    |
-| LifeScan     | OneTouch Ultra Easy     | `otultraeasy`      | [pyserial]    |
-| LifeScan     | OneTouch Ultra Mini     | `otultraeasy`      | [pyserial]    |
-| LifeScan     | OneTouch Verio (USB)    | `otverio2015`      | [python-scsi] |
-| LifeScan     | OneTouch Select Plus    | `otverio2015`      | [python-scsi] |
-| Abbott       | FreeStyle InsuLinx†     | `fsinsulinx`       | [hidapi]‡     |
-| Abbott       | FreeStyle Libre         | `fslibre`          | [hidapi]‡     |
-| Abbott       | FreeStyle Optium        | `fsoptium`         | [pyserial]    |
-| Abbott       | FreeStyle Precision Neo | `fsprecisionneo`   | [hidapi]‡     |
-| Abbott       | FreeStyle Optium Neo    | `fsprecisionneo`   | [hidapi]‡     |
-| Abbott       | FreeStyle Optium Neo H  | `fsprecisionneo`   | [hidapi]‡     |
-| Roche        | Accu-Chek Mobile        | `accuchek_reports` |               |
-| SD Biosensor | SD CodeFree             | `sdcodefree`       | [pyserial]    |
+| Manufacturer | Model Name              | Driver             | Dependencies              |
+| ---          | ---                     | ---                | ---                       |
+| LifeScan     | OneTouch Ultra 2        | `otultra2`         | [pyserial]                |
+| LifeScan     | OneTouch Ultra Easy     | `otultraeasy`      | [construct] [pyserial]    |
+| LifeScan     | OneTouch Ultra Mini     | `otultraeasy`      | [construct] [pyserial]    |
+| LifeScan     | OneTouch Verio IQ       | `otverioiq`        | [construct] [pyserial]    |
+| LifeScan     | OneTouch Verio (USB)    | `otverio2015`      | [construct] [python-scsi] |
+| LifeScan     | OneTouch Select Plus    | `otverio2015`      | [construct] [python-scsi] |
+| Abbott       | FreeStyle InsuLinx†     | `fsinsulinx`       | [construct] [hidapi]‡     |
+| Abbott       | FreeStyle Libre         | `fslibre`          | [construct] [hidapi]‡     |
+| Abbott       | FreeStyle Optium        | `fsoptium`         | [pyserial]                |
+| Abbott       | FreeStyle Precision Neo | `fsprecisionneo`   | [construct] [hidapi]‡     |
+| Abbott       | FreeStyle Optium Neo    | `fsprecisionneo`   | [construct] [hidapi]‡     |
+| Abbott       | FreeStyle Optium Neo H  | `fsprecisionneo`   | [construct] [hidapi]‡     |
+| Roche        | Accu-Chek Mobile        | `accuchek_reports` |                           |
+| SD Biosensor | SD CodeFree             | `sdcodefree`       | [construct] [pyserial]    |
 
 † Untested.
 ‡ Optional dependency on Linux; required on other operating systems.
@@ -46,6 +61,7 @@ If you have knowledge of a protocol of a glucometer you would have supported,
 please provide a reference, possibly by writing a specification and contribute
 it to https://github.com/Flameeyes/glucometer-protocols/.
 
+[construct]: https://construct.readthedocs.io/en/latest/
 [pyserial]: https://pythonhosted.org/pyserial/
 [python-scsi]: https://github.com/rosjat/python-scsi
 [hidapi]: https://pypi.python.org/pypi/hidapi
diff --git a/glucometer.py b/glucometer.py
index abed647..3b8bf70 100755
--- a/glucometer.py
+++ b/glucometer.py
@@ -1,150 +1,7 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""Utility to manage glucometers' data."""
+# -*- python -*-
 
-__author__ = 'Diego Elio Pettenò'
-__email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2013-2017, Diego Elio Pettenò'
-__license__ = 'MIT'
-
-import argparse
-import importlib
-import inspect
-import logging
-import sys
-
-from glucometerutils import common
-from glucometerutils import exceptions
-
-def main():
-  if sys.version_info < (3, 4):
-    raise Exception(
-      'Unsupported Python version, please use at least Python 3.4')
-
-  parser = argparse.ArgumentParser()
-  subparsers = parser.add_subparsers(dest="action")
-
-  parser.add_argument(
-    '--driver', action='store', required=True,
-    help='Select the driver to use for connecting to the glucometer.')
-  parser.add_argument(
-    '--device', action='store', required=False,
-    help=('Select the path to the glucometer device. Some devices require this '
-          'argument, others will try autodetection.'))
-
-  parser.add_argument(
-    '--vlog', action='store', required=False, type=int,
-    help=('Python logging level. See the levels at '
-          'https://docs.python.org/3/library/logging.html#logging-levels'))
-
-  subparsers.add_parser(
-    'help', help=('Display a description of the driver, including supported '
-                  'features and known quirks.'))
-  subparsers.add_parser(
-    'info', help='Display information about the meter.')
-  subparsers.add_parser(
-    'zero', help='Zero out the data log of the meter.')
-
-  parser_dump = subparsers.add_parser(
-    'dump', help='Dump the readings stored in the device.')
-  parser_dump.add_argument(
-    '--unit', action='store',
-    choices=[unit.value for unit in common.Unit],
-    help='Select the unit to use for the dumped data.')
-  parser_dump.add_argument(
-    '--sort-by', action='store', default='timestamp',
-    choices=common._ReadingBase._fields,
-    help='Field to order the dumped data by.')
-  parser_dump.add_argument(
-    '--with-ketone', action='store_true', default=False,
-    help='Enable ketone reading if available on the glucometer.')
-
-  parser_date = subparsers.add_parser(
-    'datetime', help='Reads or sets the date and time of the glucometer.')
-  parser_date.add_argument(
-    '--set', action='store', nargs='?', const='now', default=None,
-    help='Set the date rather than just reading it from the device.')
-
-  args = parser.parse_args()
-
-  logging.basicConfig(level=args.vlog)
-
-  try:
-    driver = importlib.import_module('glucometerutils.drivers.' + args.driver)
-  except ImportError as e:
-    logging.error(
-      'Error importing driver "%s", please check your --driver parameter:\n%s',
-      args.driver, e)
-    return 1
-
-  # This check needs to happen before we try to initialize the device, as the
-  # help action does not require a --device at all.
-  if args.action == 'help':
-    print(inspect.getdoc(driver))
-    return 0
-
-  device = driver.Device(args.device)
-
-  device.connect()
-  device_info = device.get_meter_info()
-
-  try:
-    if args.action == 'info':
-      try:
-        time_str = device.get_datetime()
-      except NotImplementedError:
-        time_str = 'N/A'
-      print("{device_info}Time: {time}".format(
-        device_info=str(device_info), time=time_str))
-    elif args.action == 'dump':
-      unit = args.unit
-      if unit is None:
-        unit = device_info.native_unit
-
-      readings = device.get_readings()
-
-      if not args.with_ketone:
-        readings = (reading for reading in readings
-                    if not isinstance(reading, common.KetoneReading))
-
-      if args.sort_by is not None:
-        readings = sorted(
-          readings, key=lambda reading: getattr(reading, args.sort_by))
-
-      for reading in readings:
-        print(reading.as_csv(unit))
-    elif args.action == 'datetime':
-      if args.set == 'now':
-        print(device.set_datetime())
-      elif args.set:
-        try:
-          from dateutil import parser as date_parser
-          new_date = date_parser.parse(args.set)
-        except ImportError:
-          logging.error(
-            'Unable to import module "dateutil", please install it.')
-          return 1
-        except ValueError:
-          logging.error('%s: not a valid date', args.set)
-          return 1
-        print(device.set_datetime(new_date))
-      else:
-        print(device.get_datetime())
-    elif args.action == 'zero':
-      confirm = input('Delete the device data log? (y/N) ')
-      if confirm.lower() in ['y', 'ye', 'yes']:
-        device.zero_log()
-        print('\nDevice data log zeroed.')
-      else:
-        print('\nDevice data log not zeroed.')
-        return 1
-    else:
-      return 1
-  except exceptions.Error as err:
-    print('Error while executing \'%s\': %s' % (args.action, str(err)))
-    return 1
-
-  device.disconnect()
+from glucometerutils import glucometer
 
 if __name__ == "__main__":
-    main()
+    glucometer.main()
diff --git a/glucometerutils/common.py b/glucometerutils/common.py
index 318fc86..ba4f018 100644
--- a/glucometerutils/common.py
+++ b/glucometerutils/common.py
@@ -149,4 +149,4 @@ def __str__(self):
       Native Unit: {native_unit}
       """).format(model=self.model, serial_number=self.serial_number,
                   version_information_string=version_information_string,
-                  native_unit=self.native_unit)
+                  native_unit=self.native_unit.value)
diff --git a/glucometerutils/drivers/fslite.py b/glucometerutils/drivers/fslite.py
new file mode 100644
index 0000000..fd4a461
--- /dev/null
+++ b/glucometerutils/drivers/fslite.py
@@ -0,0 +1,369 @@
+# -*- coding: utf-8 -*-
+"""Driver for FreeStyle Lite devices.
+
+Supported features:
+    - get readings (ignores ketone results);
+    - use the glucose unit preset on the device by default;
+    - get and set date and time;
+    - get serial number and software version.
+
+Expected device path: /dev/ttyUSB0 or similar serial port device.
+
+Further information on the device protocol can be found at
+
+http://www.flupzor.nl/protocol.html
+"""
+
+__author__ = 'Diego Elio Pettenò, William Garber'
+__email__ = 'flameeyes@flameeyes.eu, william.garber@att.net'
+__copyright__ = 'Copyright © 2016-2017, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import datetime
+import logging
+import re
+
+from glucometerutils import common
+from glucometerutils import exceptions
+from glucometerutils.support import serial
+
+
+_CLOCK_RE = re.compile(
+  r'^(?P<month>[A-Z][a-z]{2})  (?P<day>[0-9]{2}) (?P<year>[0-9]{4}) '
+  r'(?P<time>[0-9]{2}:[0-9]{2}:[0-9]{2})$')
+
+_EMPTY_RE = re.compile(r'^(?P<empty>Log Empty END)$')
+_COUNT_RE = re.compile(r'^(?P<nrresults>[0-9]{3})$')
+
+# The reading can be HI (padded to three-characters by a space) if the value was
+# over what the meter was supposed to read. Unlike the "Clock:" line, the months
+# of June and July are written in full, everything else is truncated to three
+# characters, so accept a space or 'e'/'y' at the end of the month name. Also,
+# the time does *not* include seconds.
+_READING_RE = re.compile(
+  r'^(?P<reading>|[0-9]{3})  (?P<month>[A-Z][a-z]{2})  (?P<day>[0-9]{2}) '
+  r'(?P<year>[0-9]{4}) (?P<time>[0-9]{2}:[0-9]{2}) '
+  r'(?P<type>[0-9]{2}) (?P<sentinel>0x0[01])$')
+
+_CHECKSUM_RE = re.compile(
+  r'^(?P<checksum>0x[0-9A-F]{4})  END$')
+
+# There are two date format used by the device. One uses three-letters month
+# names, and that's easy enough. The other uses three-letters month names,
+# except for (at least) July. So ignore the fourth character.
+# explicit mapping. Note that the mapping *requires* a trailing whitespace.
+_MONTH_MATCHES = {
+  'Jan': 1,
+  'Feb': 2,
+  'Mar': 3,
+  'Apr': 4,
+  'May': 5,
+  'Jun': 6,
+  'Jul': 7,
+  'Aug': 8,
+  'Sep': 9,
+  'Oct': 10,
+  'Nov': 11,
+  'Dec': 12
+  }
+
+_INFO_KEYS = [
+  'device_version_',
+  'software_revision_',
+  'device_serialno_',
+  'device_glucose_unit_',
+  'device_current_date_time_',
+  'device_nrresults_'
+]
+
+_READING_KEYS = [
+  'reading',
+  'month',
+  'day',
+  'year',
+  'time',
+  'type',
+  'sentinel'
+]
+
+_INFO_SIZE = 5
+
+def _parse_clock(datestr):
+  """Convert the date/time string used by the the device into a datetime.
+
+  Args:
+    datestr: a string as returned by the device during information handling.
+  """
+  match = _CLOCK_RE.match(datestr)
+  if not match:
+    raise exceptions.InvalidResponse(datestr)
+  # int() parses numbers in decimal, so we don't have to worry about '08'
+  day = int(match.group('day'))
+  month = _MONTH_MATCHES[match.group('month')]
+  year = int(match.group('year'))
+  time = match.group('time')
+  hour, minute, second = map(int, time.split(':'))
+  return datetime.datetime(year, month, day, hour, minute, second)
+
+def _parse_nrresults(countstr):
+  """Convert the count string used by the device into number of results.
+
+  Args:
+    countstr:  a string as returned by the device during information handling.
+    Special case:  no results ('Log Empty END') returns 0.
+  """
+  match_empty = _EMPTY_RE.match(countstr)
+  match_count = _COUNT_RE.match(countstr)
+  if match_empty:
+    return 0
+  elif match_count:
+    return int(countstr)
+  else:
+    raise exceptions.InvalidResponse(countstr)
+
+def _parse_info(data):
+  info = {}
+  if len(data) < _INFO_SIZE:
+    msg = '_parse_info:  len(data)=%d < %d lines:  ' % (len(data),_INFO_SIZE)
+    logging.debug(msg + '%r', data)
+    raise exceptions.InvalidResponse('\n'.join(data))
+  if data[0] != '':
+    msg = '_parse_info:  first line not blank:  '
+    logging.debug(msg + '%r', data)
+    raise exceptions.InvalidResponse('\n'.join(data))
+  info['device_version_']           = data[1]
+  info['software_revision_']        = data[2]
+  info['device_serialno_']          = 'N/A'
+  info['device_glucose_unit_']      = common.Unit.MG_DL
+  # info['device_glucose_unit_']    = common.Unit.MMOL_L
+  info['device_current_date_time_'] = _parse_clock(data[3])
+  info['device_nrresults_']         = _parse_nrresults(data[4])
+  return info
+
+def _parse_resline(line, j):
+  match = _READING_RE.match(line)
+  if not match:
+    raise exceptions.InvalidResponse('error line %d = %s' % (j, line))
+  READING  = match.group('reading')
+  MONTH    = match.group('month')
+  DAY      = match.group('day')
+  YEAR     = match.group('year')
+  TIME     = match.group('time')
+  TYPE     = match.group('type')
+  SENTINEL = match.group('sentinel')
+  if TYPE != '00':
+    logging.warning('TYPE == %s  NORMALLY type == 00' % TYPE)
+  if READING == 'HI ':
+    value = float("inf")
+  else:
+    value = float(READING)
+  month = _MONTH_MATCHES[MONTH]
+  day = int(DAY)
+  year = int(YEAR)
+  hour, minute = map(int, TIME.split(':'))
+  timestamp = datetime.datetime(year, month, day, hour, minute)
+  # The reading, if present, is always in mg/dL even if the glucometer is
+  # set to mmol/L.
+  # fixme
+  return { 'value'     : value,
+           'day'       : day,
+           'month'     : month,
+           'year'      : year,
+           'hour'      : hour,
+           'minute'    : minute,
+           'timestamp' : timestamp,
+           'READING'   : READING,
+           'TYPE'      : TYPE,
+           'SENTINEL'  : SENTINEL
+}
+
+def _parse_checksum(line):
+  match = _CHECKSUM_RE.match(line)
+  if not match:
+    raise exceptions.InvalidResponse('\n'.join(line))
+  checksum_str = match.group('checksum')
+  checksum = int(checksum_str, 16)
+  return checksum
+
+def _parse_result(data):
+  """\
+  I assume empty meter has final line "Log Empty END"
+  and no trailing empty line:
+  blank, dev, soft, date, "Log Empty END"
+  I assume non-empty meter has lines:
+  blank, dev, soft, date, count, blank line, result*count, checksum
+  """
+  info = _parse_info(data)
+  n = info['device_nrresults_']
+  if n == 0:
+    len_data1 = _INFO_SIZE
+  else:
+    len_data1 = _INFO_SIZE + n + 2
+    if data[_INFO_SIZE] != '':
+      logging.debug('_parse_result:  last line not blank:  %r', data)
+      raise exceptions.InvalidResponse('\n'.join(data))
+  if len(data) != len_data1:
+    msg = '_parse_result:  len(data)= %d correct len_data= %d  ' % (len(data), len_data1)
+    logging.debug(msg + '%r', data)
+    raise exceptions.InvalidResponse('\n'.join(data))
+  j1 = _INFO_SIZE + 1
+  j2 = _INFO_SIZE + 1 + n
+  reslog = [_parse_resline(data[j],j) for j in range(j1, j2)]
+  if n > 0:
+    checksum = _parse_checksum(data[j2])
+  return { 'info' : info, 'reslog' : reslog, 'checksum' : checksum }
+
+class Device(serial.SerialDevice):
+  BAUDRATE = 19200
+  DEFAULT_CABLE_ID = '1a61:3410'
+
+  def _send_command(self, command):
+    cmd_bytes = bytes('$%s\r\n' % command, 'ascii')
+    logging.debug('Sending command: %r', cmd_bytes)
+
+    self.serial_.write(cmd_bytes)
+    self.serial_.flush()
+
+    response = self.serial_.readlines()
+
+    logging.debug('Received response: %r', response)
+
+    # We always want to decode the output, and remove stray \r\n. Any failure in
+    # decoding means the output is invalid anyway.
+    decoded_response = [line.decode('ascii').rstrip('\r\n')
+                        for line in response]
+    return decoded_response
+
+  def connect(self):
+    # self._send_command('x') # ignore output this time
+    # self._send_command('mem') # ignore output this time
+    self._fetch_device_information()
+
+  def disconnect(self):
+    return
+
+  def _fetch_device_information(self):
+    data = self._send_command('mem')
+    res = _parse_result(data)
+    self.info_                     = res['info']
+    self.device_results_           = res['reslog']
+    self.device_checksum_          = res['checksum']
+    self.device_version_           = self.info_['device_version_']
+    self.software_revision_        = self.info_['software_revision_']
+    self.device_serialno_          = self.info_['device_serialno_']
+    self.device_glucose_unit_      = self.info_['device_glucose_unit_']
+    self.device_current_date_time_ = self.info_['device_current_date_time_']
+    self.device_nrresults_         = self.info_['device_nrresults_']
+    # exclude the last line which is the checksum itself.
+    # every  line is ended with a windows end-of-line \r\n
+    # except line 6  ends  with a linux   end-of-line \n
+    n = self.device_nrresults_
+    if n > 0:
+      wnl = (ord('\r') + ord('\n')) * (_INFO_SIZE + n) # windows end of line
+      lnl = ord('\n') # linux end of line
+      ce = self.device_checksum_ # expected
+      cg = (sum(ord(c) for c in ''.join(data[:-1])) + wnl + lnl) % (2 ** 16) # gotten
+      if ce != cg:
+        raise exceptions.InvalidChecksum(ce, cg)
+
+  def get_meter_info(self):
+    """Fetch and parses the device information.
+
+    Returns:
+      A common.MeterInfo object.
+    """
+    return common.MeterInfo(
+      'Freestyle Lite glucometer',
+      serial_number=self.get_serial_number(),
+      version_info=('Software version: ' + self.get_software_revision(),
+                    'Hardware version: ' + self.get_version()),
+      native_unit=self.get_glucose_unit()
+    )
+
+  def get_version(self):
+    """Returns an identifier of the firmware version of the glucometer.
+
+    Returns:
+      The hardware version returned by the glucometer, such as "0.22"
+    """
+    return self.device_version_
+
+  def get_software_revision(self):
+    """Returns an identifier of the software version of the glucometer.
+
+    Returns:
+      The software version returned by the glucometer, such as "0.22"
+    """
+    return self.software_revision_
+
+  def get_serial_number(self):
+    """Retrieve the serial number of the device.
+
+    Returns:
+      A string representing the serial number of the device.
+    """
+    return self.device_serialno_
+
+  def get_glucose_unit(self):
+    """Returns a constant representing the unit displayed by the meter.
+
+    Returns:
+      common.Unit.MG_DL: if the glucometer displays in mg/dL
+      common.Unit.MMOL_L: if the glucometer displays in mmol/L
+    """
+    return self.device_glucose_unit_
+
+  def get_datetime(self):
+    """Returns the current date and time for the glucometer.
+
+    Returns:
+      A datetime object built according to the returned response.
+    """
+    return self.device_current_date_time_
+
+  def set_datetime(self, date=datetime.datetime.now()):
+    """Sets the date and time of the glucometer.
+
+    Args:
+      date: The value to set the date/time of the glucometer to. If none is
+        given, the current date and time of the computer is used.
+
+    Returns:
+      A datetime object built according to the returned response.
+    """
+    raise NotImplementedError
+
+  def zero_log(self):
+    """Zeros out the data log of the device.
+
+    This function will clear the memory of the device deleting all the readings
+    in an irrecoverable way.
+    """
+    raise NotImplementedError
+
+  def get_readings(self):
+    """Iterates over the reading values stored in the glucometer.
+
+    Args:
+      unit: The glucose unit to use for the output.
+
+    Yields:
+      A tuple (date, value) of the readings in the glucometer. The value is a
+      floating point in the unit specified; if no unit is specified, the default
+      unit in the glucometer will be used.
+
+    Raises:
+      exceptions.InvalidResponse: if the response does not match what expected.
+    """
+    for line in self.device_results_:
+        value     = line['value']
+        day       = line['day']
+        month     = line['month']
+        year      = line['year']
+        hour      = line['hour']
+        minute    = line['minute']
+        timestamp = line['timestamp']
+        # fixme
+        # The reading, if present, is always in mg/dL even if the glucometer is
+        # set to mmol/L.
+        yield common.GlucoseReading(timestamp, value)
diff --git a/glucometerutils/drivers/fsoptium.py b/glucometerutils/drivers/fsoptium.py
index 5c57ae3..1e1a319 100644
--- a/glucometerutils/drivers/fsoptium.py
+++ b/glucometerutils/drivers/fsoptium.py
@@ -90,11 +90,15 @@ class Device(serial.SerialDevice):
 
   def _send_command(self, command):
     cmd_bytes = bytes('$%s\r\n' % command, 'ascii')
+    logging.debug('Sending command: %r', cmd_bytes)
+
     self.serial_.write(cmd_bytes)
     self.serial_.flush()
 
     response = self.serial_.readlines()
 
+    logging.debug('Received response: %r', response)
+
     # We always want to decode the output, and remove stray \r\n. Any failure in
     # decoding means the output is invalid anyway.
     decoded_response = [line.decode('ascii').rstrip('\r\n')
diff --git a/glucometerutils/drivers/fsprecisionneo.py b/glucometerutils/drivers/fsprecisionneo.py
index cb58263..1153908 100644
--- a/glucometerutils/drivers/fsprecisionneo.py
+++ b/glucometerutils/drivers/fsprecisionneo.py
@@ -81,7 +81,11 @@ def get_readings(self):
 
             # Build a _reading object by parsing each of the entries in the raw
             # record
-            values = [int(v) for v in record]
+            values = []
+            for v in record:
+                if v == "HI":
+                    v = float("inf")
+                values.append(int(v))
             raw_reading = _NeoReading._make(values[:len(_NeoReading._fields)])
 
             timestamp = datetime.datetime(
diff --git a/glucometerutils/drivers/otultraeasy.py b/glucometerutils/drivers/otultraeasy.py
index 0538dac..f0e16a7 100644
--- a/glucometerutils/drivers/otultraeasy.py
+++ b/glucometerutils/drivers/otultraeasy.py
@@ -15,308 +15,222 @@
 
 __author__ = 'Diego Elio Pettenò'
 __email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2014-2017, Diego Elio Pettenò'
+__copyright__ = 'Copyright © 2014-2018, Diego Elio Pettenò'
 __license__ = 'MIT'
 
-import array
+import binascii
 import datetime
 import logging
-import re
-import struct
-import time
+
+import construct
 
 from glucometerutils import common
-from glucometerutils import exceptions
+from glucometerutils.support import construct_extras
 from glucometerutils.support import lifescan
+from glucometerutils.support import lifescan_binary_protocol
 from glucometerutils.support import serial
 
-_STX = 0x02
-_ETX = 0x03
-
-_IDX_STX = 0
-_IDX_LENGTH = 1
-_IDX_CONTROL = 2
-_IDX_DATA = 3
-_IDX_ETX = -3
-_IDX_CHECKSUM = -2
-
-_BIT_SENT_COUNTER = 0x01
-_BIT_EXPECT_RECEIVE = 0x02
-_BIT_ACK = 0x04
-_BIT_DISCONNECT = 0x08
-_BIT_MORE = 0x10
-
-_READ_SERIAL_NUMBER = b'\x05\x0B\x02\x00\x00\x00\x00\x84\x6A\xE8\x73\x00'
-_READ_VERSION = b'\x05\x0D\x02'
-_READ_GLUCOSE_UNIT = b'\x05\x09\x02\x09\x00\x00\x00\x00'
-_DELETE_RECORDS = b'\x05\x1A'
-_READ_DATETIME = b'\x05\x20\x02\x00\x00\x00\x00'
-_WRITE_DATETIME = b'\x05\x20\x01'
-_READ_RECORD = b'\x05\x1F'
+_PACKET = lifescan_binary_protocol.LifeScanPacket(
+    0x05, True)
 
 _INVALID_RECORD = 501
 
-_STRUCT_TIMESTAMP = struct.Struct('<I')
-_STRUCT_RECORDID = struct.Struct('<H')
-
-
-class UnsetPacketError(LookupError):
-  pass
-
-
-def _convert_timestamp(timestamp_bytes):
-  timestamp, = _STRUCT_TIMESTAMP.unpack(timestamp_bytes)
-
-  return datetime.datetime.fromtimestamp(timestamp)
-
-
-class _Packet(object):
-  _STRUCT = struct.Struct('<H')
-
-  def __init__(self):
-    self.cmd = array.array('B')
-
-  def read_from(self, serial):
-    self.cmd.extend(serial.read(3))
-
-    if self.cmd[_IDX_STX] != _STX:
-      raise lifescan.MalformedCommand(
-        'at position %s expected %02x, received %02x' % (
-          _IDX_STX, _STX, self.cmd[_IDX_STX]))
-
-    # the length includes prelude and appendix, which are six bytes total.
-    if self.length > 6:
-      self.cmd.extend(serial.read(self.length - 6))
-
-    self.cmd.extend(serial.read(3))
-
-    if self.cmd[_IDX_ETX] != _ETX:
-      raise lifescan.MalformedCommand(
-        'at position %s expected %02x, received %02x' % (
-          _IDX_ETX, _ETX, self.cmd[_IDX_ETX]))
-
-  def build_command(self, cmd_bytes):
-    self.cmd.append(_STX)
-    self.cmd.append(6 + len(cmd_bytes))
-    self.cmd.append(0x00)  # link control
-    self.cmd.extend(cmd_bytes)
-    self.cmd.extend([_ETX, 0x00, 0x00])
-
-  @property
-  def length(self):
-    if not self.cmd:
-      return None
+_VERSION_REQUEST = construct.Const(b'\x0d\x02')
 
-    return self.cmd[_IDX_LENGTH]
+_VERSION_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'version' / construct.PascalString(construct.Byte, encoding='ascii'),
+)
 
-  def __is_in_control(self, bitmask):
-    if not self.cmd:
-      return None
+_SERIAL_NUMBER_REQUEST = construct.Const(
+    b'\x0B\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00')
 
-    return bool(self.cmd[_IDX_CONTROL] & bitmask)
+_SERIAL_NUMBER_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'serial_number' / construct.GreedyString(encoding='ascii'),
+)
 
-  def __set_in_control(self, bitmask, value):
-    if not self.cmd:
-      return None
+_DATETIME_REQUEST = construct.Struct(
+    construct.Const(b'\x20'),  # 0x20 is the datetime
+    'request_type' / construct.Enum(construct.Byte, write=0x01, read=0x02),
+    'timestamp' / construct.Default(
+        construct_extras.Timestamp(construct.Int32ul),
+        datetime.datetime(1970, 1, 1, 0, 0)),
+)
 
-    if value:
-      self.cmd[_IDX_CONTROL] |= bitmask
-    else:
-      self.cmd[_IDX_CONTROL] &= (~bitmask) & 0xFF
+_DATETIME_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'timestamp' / construct_extras.Timestamp(construct.Int32ul),
+)
 
-    return value
+_GLUCOSE_UNIT_REQUEST = construct.Const(
+    b'\x09\x02\x09\x00\x00\x00\x00')
 
-  @property
-  def sent_counter(self):
-    return self.__is_in_control(_BIT_SENT_COUNTER)
 
-  @sent_counter.setter
-  def sent_counter(self, value):
-    self.__set_in_control(_BIT_SENT_COUNTER, value)
+_GLUCOSE_UNIT_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'unit' / lifescan_binary_protocol.GLUCOSE_UNIT,
+    construct.Padding(3),
+)
 
-  @property
-  def expect_receive(self):
-    return self.__is_in_control(_BIT_EXPECT_RECEIVE)
+_MEMORY_ERASE_REQUEST = construct.Const(b'\x1A')
 
-  @expect_receive.setter
-  def expect_receive(self, value):
-    self.__set_in_control(_BIT_EXPECT_RECEIVE, value)
+_READING_COUNT_RESPONSE = construct.Struct(
+    construct.Const(b'\x0f'),
+    'count' / construct.Int16ul,
+)
 
-  @property
-  def checksum(self):
-    return lifescan.crc_ccitt(self.cmd[:_IDX_CHECKSUM].tobytes())
-
-  @property
-  def acknowledge(self):
-    return self.__is_in_control(_BIT_ACK)
-
-  @acknowledge.setter
-  def acknowledge(self, value):
-    self.__set_in_control(_BIT_ACK, value)
-
-  @property
-  def disconnect(self):
-    return self.__is_in_control(_BIT_DISCONNECT)
-
-  @disconnect.setter
-  def disconnect(self, value):
-    self.__set_in_control(_BIT_DISCONNECT, value)
-
-  @property
-  def more(self):
-    return self.__is_in_control(_BIT_MORE)
-
-  @more.setter
-  def more(self, value):
-    self.__set_in_control(_BIT_MORE, value)
-
-  def validate_checksum(self):
-    expected_checksum = self.checksum
-    received_checksum = self._STRUCT.unpack(self.cmd[_IDX_CHECKSUM:])[0]
-    if received_checksum != expected_checksum:
-      raise exceptions.InvalidChecksum(expected_checksum, received_checksum)
-
-  def update_checksum(self):
-    self._STRUCT.pack_into(self.cmd, _IDX_CHECKSUM, self.checksum)
-
-  def tobytes(self):
-    return self.cmd.tobytes()
-
-  @property
-  def data(self):
-    return self.cmd[_IDX_DATA:_IDX_ETX]
+_READ_RECORD_REQUEST = construct.Struct(
+    construct.Const(b'\x1f'),
+    'record_id' / construct.Int16ul,
+)
 
+_READING_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'timestamp' / construct_extras.Timestamp(construct.Int32ul),
+    'value' / construct.Int32ul,
+)
 
 class Device(serial.SerialDevice):
-  BAUDRATE = 9600
-  DEFAULT_CABLE_ID = '067b:2303'  # Generic PL2303 cable.
-
-  def __init__(self, device):
-    super(Device, self).__init__(device)
-
-    self.sent_counter_ = False
-    self.expect_receive_ = False
-
-  def connect(self):
-    self._send_command('', disconnect=True)
-
-  def disconnect(self):
-    self.connect()
-
-  def _read_response(self):
-    response = _Packet()
-
-    response.read_from(self.serial_)
-
-    if not response.disconnect and response.sent_counter != self.expect_receive_:
-      raise lifescan.MalformedCommand(
-        'at position 2[0b] expected %02x, received %02x' % (
-          self.expect_receive_, response.expect_receive))
-
-    if not response.acknowledge:
-      self.expect_receive_ = not self.expect_receive_
-
-    response.validate_checksum()
-
-    if not response.acknowledge:
-      self._send_command('', acknowledge=True)
-
-    return response
-
-  def _send_command(self, cmd_bytes, acknowledge=False, disconnect=False):
-    cmd = _Packet()
-
-    # set the proper expectations
-    cmd.build_command(cmd_bytes)
-    cmd.sent_counter = self.sent_counter_
-    cmd.expect_receive = self.expect_receive_
-    cmd.acknowledge = acknowledge
-    cmd.disconnect = disconnect
-
-    cmd.update_checksum()
-
-    self.serial_.write(cmd.tobytes())
-    self.serial_.flush()
-
-    if not acknowledge:
-      self.sent_counter_ = not self.sent_counter_
-      result = self._read_response()
-      return result
-
-  def get_meter_info(self):
-    return common.MeterInfo(
-      'OneTouch Ultra Easy glucometer',
-      serial_number=self.get_serial_number(),
-      version_info=(
-        'Software version: ' + self.get_version(),),
-      native_unit=self.get_glucose_unit())
-
-  def get_version(self):
-    result = self._send_command(_READ_VERSION)
-
-    response = self._read_response()
-
-    return response.data[3:].tobytes().decode('ascii')
-
-  def get_serial_number(self):
-    result = self._send_command(_READ_SERIAL_NUMBER)
-
-    response = self._read_response()
-
-    return response.data[2:].tobytes().decode('ascii')
-
-  def get_datetime(self):
-    result = self._send_command(_READ_DATETIME)
-    response = self._read_response()
-
-    return _convert_timestamp(response.data[2:6])
-
-  def set_datetime(self, date=datetime.datetime.now()):
-    epoch = datetime.datetime.utcfromtimestamp(0)
-    delta = date - epoch
-    timestamp = int(delta.total_seconds())
-
-    timestamp_bytes = _STRUCT_TIMESTAMP.pack(timestamp)
-
-    result = self._send_command(_WRITE_DATETIME + timestamp_bytes)
-
-    response = self._read_response()
-    return _convert_timestamp(response.data[2:6])
-
-  def zero_log(self):
-    result = self._send_command(_DELETE_RECORDS)
-    response = self._read_response()
-
-    if response.data.tobytes() != b'\x05\x06':
-      raise exceptions.InvalidResponse(response.data)
-
-  def get_glucose_unit(self):
-    result = self._send_command(_READ_GLUCOSE_UNIT)
-    response = self._read_response()
-
-    if response.data[2] == 0:
-      return common.Unit.MG_DL
-    elif response.data[2] == 1:
-      return common.Unit.MMOL_L
-    else:
-      raise lifescan.MalformedCommand(
-        'at position PM1 invalid value %02x for unit' % response.data[2])
-
-  def _get_reading(self, record_id):
-    id_bytes = _STRUCT_RECORDID.pack(record_id)
-
-    result = self._send_command(_READ_RECORD + id_bytes)
-    return self._read_response()
-
-  def get_readings(self):
-    count_response = self._get_reading(_INVALID_RECORD)
-
-    record_count, = _STRUCT_RECORDID.unpack_from(count_response.data, 2)
+    BAUDRATE = 9600
+    DEFAULT_CABLE_ID = '067b:2303'  # Generic PL2303 cable.
+    TIMEOUT = 0.5
+
+    def __init__(self, device):
+        super(Device, self).__init__(device)
+
+        self.sent_counter_ = False
+        self.expect_receive_ = False
+        self.buffered_reader_ = construct.Rebuffered(
+            _PACKET, tailcutoff=1024)
+
+    def connect(self):
+        try:
+            self._send_packet(b'', disconnect=True)
+            self._read_ack()
+        except construct.ConstructError as e:
+            raise lifescan.MalformedCommand(str(e))
+
+    def disconnect(self):
+        self.connect()
+
+    def _send_packet(self, message, acknowledge=False, disconnect=False):
+        pkt = _PACKET.build(
+            {'data': {'value': {
+                'message': message,
+                'link_control': {
+                    'sequence_number': self.sent_counter_,
+                    'expect_receive': self.expect_receive_,
+                    'acknowledge': acknowledge,
+                    'disconnect': disconnect,
+                },
+            }}})
+        logging.debug('sending packet: %s', binascii.hexlify(pkt))
+
+        self.serial_.write(pkt)
+        self.serial_.flush()
+
+    def _read_packet(self):
+        raw_pkt = self.buffered_reader_.parse_stream(self.serial_).data
+        logging.debug('received packet: %r', raw_pkt)
+
+        # discard the checksum and copy
+        pkt = raw_pkt.value
+
+        if not pkt.link_control.disconnect and (
+                pkt.link_control.sequence_number != self.expect_receive_):
+            raise lifescan.MalformedCommand(
+                'at position 2[0b] expected %02x, received %02x' % (
+                    self.expect_receive_, pkt.link_connect.sequence_count))
+
+        return pkt
+
+    def _send_ack(self):
+        self._send_packet(b'', acknowledge=True, disconnect=False)
+
+    def _read_ack(self):
+        pkt = self._read_packet()
+        assert pkt.link_control.acknowledge
+
+    def _send_request(self, request_format, request_obj, response_format):
+        try:
+            request = request_format.build(request_obj)
+            self._send_packet(request, acknowledge=False, disconnect=False)
+
+            self.sent_counter_ = not self.sent_counter_
+            self._read_ack()
+
+            response_pkt = self._read_packet()
+            assert not response_pkt.link_control.acknowledge
+
+            self.expect_receive_ = not self.expect_receive_
+            self._send_ack()
+
+            return response_format.parse(response_pkt.message)
+        except construct.ConstructError as e:
+            raise lifescan.MalformedCommand(str(e))
+
+    def get_meter_info(self):
+        return common.MeterInfo(
+            'OneTouch Ultra Easy glucometer',
+            serial_number=self.get_serial_number(),
+            version_info=(
+                'Software version: ' + self.get_version(),),
+            native_unit=self.get_glucose_unit())
+
+    def get_version(self):
+        response = self._send_request(
+            _VERSION_REQUEST, None, _VERSION_RESPONSE)
+
+        return response.version
+
+    def get_serial_number(self):
+        response = self._send_request(
+            _SERIAL_NUMBER_REQUEST, None, _SERIAL_NUMBER_RESPONSE)
+
+        return response.serial_number
+
+    def get_datetime(self):
+        response = self._send_request(
+            _DATETIME_REQUEST, {'request_type': 'read'},
+            _DATETIME_RESPONSE)
+
+        return response.timestamp
+
+    def set_datetime(self, date=datetime.datetime.now()):
+        response = self._send_request(
+            _DATETIME_REQUEST, {
+                'request_type': 'write',
+                'timestamp': date,
+            }, _DATETIME_RESPONSE)
+
+        return response.timestamp
+
+    def zero_log(self):
+        self._send_request(
+            _MEMORY_ERASE_REQUEST, None,
+            lifescan_binary_protocol.COMMAND_SUCCESS)
+
+    def get_glucose_unit(self):
+        response = self._send_request(
+            _GLUCOSE_UNIT_REQUEST, None, _GLUCOSE_UNIT_RESPONSE)
+
+        return response.unit
+
+    def _get_reading_count(self):
+        response = self._send_request(
+            _READ_RECORD_REQUEST, {'record_id': _INVALID_RECORD},
+            _READING_COUNT_RESPONSE)
+        return response.count
 
-    for record_id in range(record_count):
-      record_response = self._get_reading(record_id)
+    def _get_reading(self, record_id):
+        response = self._send_request(
+            _READ_RECORD_REQUEST, {'record_id': record_id}, _READING_RESPONSE)
 
-      timestamp = _convert_timestamp(record_response.data[2:6])
-      value, = _STRUCT_TIMESTAMP.unpack_from(record_response.data, 6)
+        return common.GlucoseReading(
+            response.timestamp, float(response.value))
 
-      yield common.GlucoseReading(timestamp, float(value))
+    def get_readings(self):
+        record_count = self._get_reading_count()
+        for record_id in range(record_count):
+            yield self._get_reading(record_id)
diff --git a/glucometerutils/drivers/otverio2015.py b/glucometerutils/drivers/otverio2015.py
index 5925a58..a7cadf5 100644
--- a/glucometerutils/drivers/otverio2015.py
+++ b/glucometerutils/drivers/otverio2015.py
@@ -22,252 +22,221 @@
 
 __author__ = 'Diego Elio Pettenò'
 __email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2016-2017, Diego Elio Pettenò'
+__copyright__ = 'Copyright © 2016-2018, Diego Elio Pettenò'
 __license__ = 'MIT'
 
 import binascii
 import datetime
 import logging
-import struct
 
+import construct
 from pyscsi.pyscsi.scsi import SCSI
 from pyscsi.pyscsi.scsi_device import SCSIDevice
 
 from glucometerutils import common
 from glucometerutils import exceptions
 from glucometerutils.support import lifescan
-
-# Match the same values in the otultraeasy driver.
-_STX = 0x02
-_ETX = 0x03
+from glucometerutils.support import lifescan_binary_protocol
 
 # This device uses SCSI blocks as registers.
 _REGISTER_SIZE = 512
 
-_STRUCT_PREAMBLE = struct.Struct('<BH')
-_STRUCT_CODA = _STRUCT_PREAMBLE  # they are actually the same, mirrored.
-
-_STRUCT_UINT16 = struct.Struct('<H')
-_STRUCT_UINT32 = struct.Struct('<I')
-
-_STRUCT_CHECKSUM = _STRUCT_UINT16
-_STRUCT_TIMESTAMP = _STRUCT_UINT32
-_STRUCT_RECORDID = _STRUCT_UINT16
-_STRUCT_READING = _STRUCT_UINT32
-_STRUCT_RECORD = struct.Struct('<BBHBHIHBBBBB')
-
-_QUERY_REQUEST = b'\x04\xe6\x02'
-_QUERY_KEY_SERIAL = b'\x00'
-_QUERY_KEY_MODEL = b'\x01'
-_QUERY_KEY_SOFTWARE = b'\x02'
-
-_READ_PARAMETER_REQUEST = b'\x04'
-_PARAMETER_KEY_UNIT = b'\x04'
-
-_READ_RTC_REQUEST = b'\x04\x20\x02'
-_WRITE_RTC_REQUEST = b'\x04\x20\x01'
-# All timestamp reported by this device are seconds since this date.
-_EPOCH_BASE = 946684800  # 2010-01-01 00:00
-
-_READ_RECORD_COUNT_REQUEST = b'\x04\x27\x00'
-_READ_RECORD_REQUEST_PREFIX = b'\x04\x31\x02'
-_READ_RECORD_REQUEST_SUFFIX = b'\x00'
-
-_MEMORY_ERASE_REQUEST = b'\x04\x1a'
-
-_MEAL_CODES = {
-  0x00: common.Meal.NONE,
-  0x01: common.Meal.BEFORE,
-  0x02: common.Meal.AFTER,
+_PACKET = construct.Padded(
+    _REGISTER_SIZE,
+        lifescan_binary_protocol.LifeScanPacket(0x03, False))
+
+_QUERY_REQUEST = construct.Struct(
+    construct.Const(b'\xe6\x02'),
+    'selector' / construct.Enum(
+        construct.Byte, serial=0x00, model=0x01, software=0x02),
+)
+
+_QUERY_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'value' / construct.CString(encoding='utf-16-le'),
+)
+
+_READ_PARAMETER_REQUEST = construct.Struct(
+    'selector' / construct.Enum(
+        construct.Byte, unit=0x04),
+)
+
+_READ_UNIT_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'unit' / lifescan_binary_protocol.GLUCOSE_UNIT,
+    construct.Padding(3),
+)
+
+_READ_RTC_REQUEST = construct.Const(b'\x20\x02')
+
+_READ_RTC_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+)
+
+_WRITE_RTC_REQUEST = construct.Struct(
+    construct.Const(b'\x20\x01'),
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+)
+
+_MEMORY_ERASE_REQUEST = construct.Const(b'\x1a')
+
+_READ_RECORD_COUNT_REQUEST = construct.Const(b'\x27\x00')
+
+_READ_RECORD_COUNT_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'count' / construct.Int16ul,
+)
+
+_READ_RECORD_REQUEST = construct.Struct(
+    construct.Const(b'\x31\x02'),
+    'record_id' / construct.Int16ul,
+    construct.Const(b'\x00'),
+)
+
+_MEAL_FLAG = {
+    common.Meal.NONE: 0x00,
+    common.Meal.BEFORE: 0x01,
+    common.Meal.AFTER: 0x02,
 }
 
-def _extract_message(register):
-  """Parse the message preamble and verify checksums."""
-  stx, length = _STRUCT_PREAMBLE.unpack_from(register)
-  if stx != _STX:
-    raise lifescan.MalformedCommand(
-      'invalid STX byte: %02x' % stx)
-  if length > _REGISTER_SIZE:
-    raise lifescan.MalformedCommand(
-      'invalid length: %d > REGISTER_SIZE' % length)
-
-  # 2 is the length of the checksum, so it should be ignored.
-  calculated_checksum = lifescan.crc_ccitt(register[:(length-2)])
-
-  coda_offset = length - _STRUCT_CODA.size
-  etx, encoded_checksum = _STRUCT_CODA.unpack_from(register[coda_offset:])
-  if etx != _ETX:
-    raise lifescan.MalformedCommand(
-      'invalid ETX byte: %02x' % etx)
-  if encoded_checksum != calculated_checksum:
-    raise exceptions.InvalidChecksum(encoded_checksum, calculated_checksum)
-
-  response = register[_STRUCT_PREAMBLE.size:coda_offset]
-
-  logging.debug('Read packet: %s' % binascii.hexlify(response))
-  return response
-
-def _encode_message(cmd):
-  """Add message preamble and calculate checksum, add padding."""
-  length = len(cmd) + _STRUCT_PREAMBLE.size + _STRUCT_CODA.size
-  preamble = _STRUCT_PREAMBLE.pack(_STX, length)
-  message = preamble + cmd + bytes((_ETX,))
-  checksum = _STRUCT_CHECKSUM.pack(lifescan.crc_ccitt(message))
-  message += checksum
-
-  logging.debug('Sending packet: %s' % binascii.hexlify(message))
-
-  # Pad the message to match the size of the register.
-  return message + bytes(_REGISTER_SIZE - len(message))
-
-def _convert_timestamp(timestamp):
-  return datetime.datetime.utcfromtimestamp(timestamp + _EPOCH_BASE)
+_READ_RECORD_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'inverse_counter' / construct.Int16ul,
+    construct.Padding(1),
+    'lifetime_counter' / construct.Int16ul,
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+    'value' / construct.Int16ul,
+    'meal' / construct.Mapping(
+        construct.Byte, _MEAL_FLAG),
+    construct.Padding(4),
+)
 
 class Device(object):
-  def __init__(self, device):
-    if not device:
-      raise exceptions.CommandLineError(
-        '--device parameter is required, should point to the disk device '
-        'representing the meter.')
-
-    self.device_name_ = device
-    self.scsi_device_ = SCSIDevice(device, readwrite=True)
-    self.scsi_ = SCSI(self.scsi_device_)
-    self.scsi_.blocksize = _REGISTER_SIZE
-
-  def _send_message(self, cmd, lba):
-    """Send a request to the meter, and read its response.
-
-    Args:
-      cmd: (bytes) the raw command to send the device, without
-        preamble or checksum.
-      lba: (int) the address of the block register to use, known
-        valid addresses are 3, 4 and 5.
-
-    Returns:
-      (bytes) The raw response from the meter. No preamble or coda is
-      present, and the checksum has already been validated.
-    """
-    self.scsi_.write10(lba, 1, _encode_message(cmd))
-    response = self.scsi_.read10(lba, 1)
-    # TODO: validate that the response is valid.
-    return _extract_message(response.datain)
-
-  def connect(self):
-    inq = self.scsi_.inquiry()
-    vendor = inq.result['t10_vendor_identification'][:32]
-    if vendor != b'LifeScan':
-      raise exceptions.ConnectionFailed(
-        'Device %s is not a LifeScan glucometer.' % self.device_name_)
-
-  def disconnect(self):
-    return
-
-  def get_meter_info(self):
-    return common.MeterInfo(
-      'OneTouch %s glucometer' % self._query_string(_QUERY_KEY_MODEL),
-      serial_number=self.get_serial_number(),
-      version_info=(
-        'Software version: ' + self.get_version(),),
-      native_unit=self.get_glucose_unit())
-
-  def _query_string(self, query_key):
-    response = self._send_message(_QUERY_REQUEST + query_key, 3)
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-    # Strings are encoded in wide characters (LE), but they should
-    # only contain ASCII characters. Note that the string is
-    # null-terminated, so the last character should be dropped.
-    return response[2:].decode('utf-16-le')[:-1]
-
-  def _read_parameter(self, parameter_key):
-    response = self._send_message(
-      _READ_PARAMETER_REQUEST + parameter_key, 4)
-    if response[0:2] != b'\x03\x06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 03 06, received %02x %02x' % (
-          response[0], response[1]))
-    return response[2:]
-
-  def get_serial_number(self):
-    return self._query_string(_QUERY_KEY_SERIAL)
-
-  def get_version(self):
-    return self._query_string(_QUERY_KEY_SOFTWARE)
-
-  def get_datetime(self):
-    response = self._send_message(_READ_RTC_REQUEST, 3)
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-    (timestamp,) = _STRUCT_TIMESTAMP.unpack(response[2:])
-    return _convert_timestamp(timestamp)
-
-  def set_datetime(self, date=datetime.datetime.now()):
-    epoch = datetime.datetime.utcfromtimestamp(_EPOCH_BASE)
-    delta = date - epoch
-    timestamp = int(delta.total_seconds())
-
-    timestamp_bytes = _STRUCT_TIMESTAMP.pack(timestamp)
-    response = self._send_message(_WRITE_RTC_REQUEST + timestamp_bytes, 3)
-
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-
-    # The device does not return the new datetime, so confirm by
-    # calling READ RTC again.
-    return self.get_datetime()
-
-  def zero_log(self):
-    response = self._send_message(_MEMORY_ERASE_REQUEST, 3)
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-
-  def _get_reading_count(self):
-    response = self._send_message(_READ_RECORD_COUNT_REQUEST, 3)
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-
-    (record_count,) = _STRUCT_RECORDID.unpack(response[2:])
-    return record_count
-
-  def get_glucose_unit(self):
-    unit_value = self._read_parameter(_PARAMETER_KEY_UNIT)
-    if unit_value == b'\x00\x00\x00\x00':
-      return common.Unit.MG_DL
-    elif unit_value == b'\x01\x00\x00\x00':
-      return common.Unit.MMOL_L
-    else:
-      raise exceptions.InvalidGlucoseUnit('%r' % unit_value)
-
-  def _get_reading(self, record_number):
-    request = (_READ_RECORD_REQUEST_PREFIX +
-               _STRUCT_RECORDID.pack(record_number) +
-               _READ_RECORD_REQUEST_SUFFIX)
-    response = self._send_message(request, 3)
-    if response[0:2] != b'\x04\06':
-      raise lifescan.MalformedCommand(
-        'invalid response, expected 04 06, received %02x %02x' % (
-          response[0], response[1]))
-
-    (unused_const1, unused_const2, unused_counter, unused_const3,
-     unused_counter2, timestamp, value, meal_flag, unused_const4, unused_flags,
-     unused_const5, unused_const6) = _STRUCT_RECORD.unpack(
-       response)
-
-    return common.GlucoseReading(
-      _convert_timestamp(timestamp), float(value), meal=_MEAL_CODES[meal_flag])
-
-  def get_readings(self):
-    record_count = self._get_reading_count()
-    for record_number in range(record_count):
-      yield self._get_reading(record_number)
+    def __init__(self, device):
+        if not device:
+            raise exceptions.CommandLineError(
+                '--device parameter is required, should point to the disk '
+                'device representing the meter.')
+
+        self.device_name_ = device
+        self.scsi_device_ = SCSIDevice(device, readwrite=True)
+        self.scsi_ = SCSI(self.scsi_device_)
+        self.scsi_.blocksize = _REGISTER_SIZE
+
+    def connect(self):
+        inq = self.scsi_.inquiry()
+        logging.debug('Device connected: %r', inq.result)
+        vendor = inq.result['t10_vendor_identification'][:32]
+        if vendor != b'LifeScan':
+            raise exceptions.ConnectionFailed(
+                'Device %s is not a LifeScan glucometer.' % self.device_name_)
+
+    def disconnect(self):
+        return
+
+    def _send_request(self, lba, request_format, request_obj, response_format):
+        """Send a request to the meter, and read its response.
+
+        Args:
+          lba: (int) the address of the block register to use, known
+            valid addresses are 3, 4 and 5.
+          request_format: a construct format identifier of the request to send
+          request_obj: the object to format with the provided identifier
+          response_format: a construct format identifier to parse the returned
+            message with.
+
+        Returns:
+          The Container object parsed from the response received by the meter.
+
+        Raises:
+          lifescan.MalformedCommand if Construct fails to build the request or
+            parse the response.
+
+        """
+        try:
+            request = request_format.build(request_obj)
+            request_raw = _PACKET.build({'data': {'value': {
+                'message': request,
+            }}})
+            logging.debug(
+                'Request sent: %s', binascii.hexlify(request_raw))
+            self.scsi_.write10(lba, 1, request_raw)
+
+            response_raw = self.scsi_.read10(lba, 1)
+            logging.debug(
+                'Response received: %s', binascii.hexlify(response_raw.datain))
+            response_pkt = _PACKET.parse(response_raw.datain).data
+            logging.debug('Response packet: %r', response_pkt)
+
+            response = response_format.parse(response_pkt.value.message)
+            logging.debug('Response parsed: %r', response)
+
+            return response
+        except construct.ConstructError as e:
+            raise lifescan.MalformedCommand(str(e))
+
+    def _query_string(self, selector):
+        response = self._send_request(
+            3, _QUERY_REQUEST, {'selector': selector}, _QUERY_RESPONSE)
+
+        # Unfortunately the CString implementation in construct does not support
+        # multi-byte encodings, so we need to discard the terminating null byte
+        # ourself.
+        return response.value[:-1]
+
+    def get_meter_info(self):
+        return common.MeterInfo(
+            'OneTouch %s glucometer' % self._query_string('model'),
+            serial_number=self.get_serial_number(),
+            version_info=(
+                'Software version: ' + self.get_version(),),
+            native_unit=self.get_glucose_unit())
+
+    def get_serial_number(self):
+        return self._query_string('serial')
+
+    def get_version(self):
+        return self._query_string('software')
+
+    def get_datetime(self):
+        response = self._send_request(
+            3, _READ_RTC_REQUEST, None, _READ_RTC_RESPONSE)
+        return response.timestamp
+
+    def set_datetime(self, date=datetime.datetime.now()):
+        self._send_request(
+            3, _WRITE_RTC_REQUEST, {'timestamp': date},
+            lifescan_binary_protocol.COMMAND_SUCCESS)
+
+        # The device does not return the new datetime, so confirm by calling
+        # READ RTC again.
+        return self.get_datetime()
+
+    def zero_log(self):
+        self._send_request(
+            3, _MEMORY_ERASE_REQUEST, None,
+            lifescan_binary_protocol.COMMAND_SUCCESS)
+
+    def get_glucose_unit(self):
+        response = self._send_request(
+            4, _READ_PARAMETER_REQUEST, {'selector': 'unit'},
+            _READ_UNIT_RESPONSE)
+        return response.unit
+
+    def _get_reading_count(self):
+        response = self._send_request(
+            3, _READ_RECORD_COUNT_REQUEST, None, _READ_RECORD_COUNT_RESPONSE)
+        return response.count
+
+    def _get_reading(self, record_id):
+        response = self._send_request(
+            3, _READ_RECORD_REQUEST, {'record_id': record_id},
+            _READ_RECORD_RESPONSE)
+        return common.GlucoseReading(
+            response.timestamp, float(response.value), meal=response.meal)
+
+    def get_readings(self):
+        record_count = self._get_reading_count()
+        for record_id in range(record_count):
+            yield self._get_reading(record_id)
diff --git a/glucometerutils/drivers/otverioiq.py b/glucometerutils/drivers/otverioiq.py
new file mode 100644
index 0000000..ead19a9
--- /dev/null
+++ b/glucometerutils/drivers/otverioiq.py
@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""Driver for LifeScan OneTouch Verio IQ devices.
+
+Supported features:
+    - get readings, including pre-/post-meal notes;
+    - use the glucose unit preset on the device by default;
+    - get and set date and time;
+    - get serial number and software version;
+    - memory reset (caution!)
+
+Expected device path: /dev/ttyUSB0 or similar serial port device. Device will be
+auto-detected.
+
+"""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2018, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import binascii
+import datetime
+import logging
+
+import construct
+
+from glucometerutils import common
+from glucometerutils.support import construct_extras
+from glucometerutils.support import lifescan
+from glucometerutils.support import lifescan_binary_protocol
+from glucometerutils.support import serial
+
+_PACKET = lifescan_binary_protocol.LifeScanPacket(
+    0x03, False)
+
+_VERSION_REQUEST = construct.Const(b'\x0d\x01')
+
+_VERSION_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'version' / construct.PascalString(construct.Byte, encoding='ascii'),
+    # NULL-termination is not included in string length.
+    construct.Const(b'\x00'),
+)
+
+_SERIAL_NUMBER_REQUEST = construct.Const(
+    b'\x0b\x01\x02')
+
+_SERIAL_NUMBER_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'serial_number' / construct.CString(encoding='ascii'),
+)
+
+_READ_RTC_REQUEST = construct.Const(b'\x20\x02')
+
+_READ_RTC_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+)
+
+_WRITE_RTC_REQUEST = construct.Struct(
+    construct.Const(b'\x20\x01'),
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+)
+
+_GLUCOSE_UNIT_REQUEST = construct.Const(
+    b'\x09\x02\x02')
+
+
+_GLUCOSE_UNIT_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'unit' / lifescan_binary_protocol.GLUCOSE_UNIT,
+    construct.Padding(3),
+)
+
+_MEMORY_ERASE_REQUEST = construct.Const(b'\x1a')
+
+_READ_RECORD_COUNT_REQUEST = construct.Const(b'\x27\x00')
+
+_READ_RECORD_COUNT_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'count' / construct.Int16ul,
+)
+
+_READ_RECORD_REQUEST = construct.Struct(
+    construct.Const(b'\x21'),
+    'record_id' / construct.Int16ul,
+)
+
+_MEAL_FLAG = {
+    common.Meal.NONE: 0x00,
+    common.Meal.BEFORE: 0x01,
+    common.Meal.AFTER: 0x02,
+}
+
+_READING_RESPONSE = construct.Struct(
+    lifescan_binary_protocol.COMMAND_SUCCESS,
+    'timestamp' / lifescan_binary_protocol.VERIO_TIMESTAMP,
+    'value' / construct.Int16ul,
+    'control_test' / construct.Flag,
+    'meal' / construct.Mapping(
+        construct.Byte, _MEAL_FLAG),
+    construct.Padding(2),  # unknown
+)
+
+
+class Device(serial.SerialDevice):
+    BAUDRATE = 38400
+    DEFAULT_CABLE_ID = '10c4:85a7'  # Specific ID for embedded cp210x
+    TIMEOUT = 0.5
+
+    def __init__(self, device):
+        super(Device, self).__init__(device)
+        self.buffered_reader_ = construct.Rebuffered(_PACKET, tailcutoff=1024)
+
+    def connect(self):
+        pass
+
+    def disconnect(self):
+        pass
+
+    def _send_packet(self, message):
+        pkt = _PACKET.build(
+            {'data': {'value': {
+                'message': message,
+            }}})
+        logging.debug('sending packet: %s', binascii.hexlify(pkt))
+
+        self.serial_.write(pkt)
+        self.serial_.flush()
+
+    def _read_packet(self):
+        raw_pkt = self.buffered_reader_.parse_stream(self.serial_).data
+        logging.debug('received packet: %r', raw_pkt)
+
+        # discard the checksum and copy
+        pkt = raw_pkt.value
+
+        return pkt
+
+    def _send_request(self, request_format, request_obj, response_format):
+        try:
+            request = request_format.build(request_obj)
+            self._send_packet(request)
+
+            response_pkt = self._read_packet()
+
+            return response_format.parse(response_pkt.message)
+        except construct.ConstructError as e:
+            raise lifescan.MalformedCommand(str(e))
+
+    def get_meter_info(self):
+        return common.MeterInfo(
+            'OneTouch Verio IQ glucometer',
+            serial_number=self.get_serial_number(),
+            version_info=(
+                'Software version: ' + self.get_version(),),
+            native_unit=self.get_glucose_unit())
+
+    def get_version(self):
+        response = self._send_request(
+            _VERSION_REQUEST, None, _VERSION_RESPONSE)
+
+        return response.version
+
+    def get_serial_number(self):
+        response = self._send_request(
+            _SERIAL_NUMBER_REQUEST, None, _SERIAL_NUMBER_RESPONSE)
+
+        return response.serial_number
+
+    def get_datetime(self):
+        response = self._send_request(
+            _READ_RTC_REQUEST, None, _READ_RTC_RESPONSE)
+
+        return response.timestamp
+
+    def set_datetime(self, date=datetime.datetime.now()):
+        response = self._send_request(
+            _WRITE_RTC_REQUEST, {
+                'timestamp': date,
+            }, lifescan_binary_protocol.COMMAND_SUCCESS)
+
+        # The device does not return the new datetime, so confirm by calling
+        # READ RTC again.
+        return self.get_datetime()
+
+    def zero_log(self):
+        self._send_request(
+            _MEMORY_ERASE_REQUEST, None,
+            lifescan_binary_protocol.COMMAND_SUCCESS)
+
+    def get_glucose_unit(self):
+        response = self._send_request(
+            _GLUCOSE_UNIT_REQUEST, None, _GLUCOSE_UNIT_RESPONSE)
+
+        return response.unit
+
+    def _get_reading_count(self):
+        response = self._send_request(
+            _READ_RECORD_COUNT_REQUEST, None, _READ_RECORD_COUNT_RESPONSE)
+        return response.count
+
+    def _get_reading(self, record_id):
+        response = self._send_request(
+            _READ_RECORD_REQUEST, {'record_id': record_id}, _READING_RESPONSE)
+
+        if response.control_test:
+            logging.debug('control solution test, ignoring.')
+            return None
+
+        return common.GlucoseReading(
+            response.timestamp, float(response.value), meal=response.meal)
+
+    def get_readings(self):
+        record_count = self._get_reading_count()
+        for record_id in range(record_count):
+            reading = self._get_reading(record_id)
+            if reading:
+                yield reading
diff --git a/glucometerutils/drivers/sdcodefree.py b/glucometerutils/drivers/sdcodefree.py
index 4a375bd..4636d2a 100644
--- a/glucometerutils/drivers/sdcodefree.py
+++ b/glucometerutils/drivers/sdcodefree.py
@@ -19,96 +19,84 @@
 __copyright__ = 'Copyright © 2017, Diego Elio Pettenò'
 __license__ = 'MIT'
 
-import array
-import collections
+import binascii
 import datetime
+import enum
 import functools
 import logging
 import operator
-import struct
-import time
+
+import construct
 
 from glucometerutils import common
 from glucometerutils import exceptions
 from glucometerutils.support import serial
 
-_STX = 0x53    # Not really 'STX'
-_ETX = 0xAA    # Not really 'ETX'
-
-_DIR_IN = 0x20
-_DIR_OUT = 0x10
-
-_IDX_STX = 0
-_IDX_DIRECTION = 1
-_IDX_LENGTH = 2
-_IDX_CHECKSUM = -2
-_IDX_ETX = -1
+def xor_checksum(msg):
+    return functools.reduce(operator.xor, msg)
 
-_RECV_PREAMBLE = b'\x53\x20'
+class Direction(enum.Enum):
+    In = 0x20
+    Out = 0x10
+
+_PACKET = construct.Struct(
+    'stx' / construct.Const(0x53, construct.Byte),
+    'direction' / construct.Mapping(
+        construct.Byte,
+        {e: e.value for e in Direction}),
+    'length' / construct.Rebuild(
+        construct.Byte, lambda this: len(this.message) + 2),
+    'message' / construct.Bytes(lambda this: this.length - 2),
+    'checksum' / construct.Checksum(
+        construct.Byte, xor_checksum, construct.this.message),
+    'etx' / construct.Const(0xAA, construct.Byte)
+)
+
+_FIRST_MESSAGE = construct.Struct(
+    construct.Const(0x30, construct.Byte),
+    'count' / construct.Int16ub,
+    construct.Const(0xAA, construct.Byte)[19],
+)
 
 _CHALLENGE_PACKET_FULL = b'\x53\x20\x04\x10\x30\x20\xAA'
-_RESPONSE_PACKET = b'\x10\x40'
-
-_DATE_SET_PACKET = b'\x10\x10'
+_RESPONSE_MESSAGE = b'\x10\x40'
 
-_DISCONNECT_PACKET = b'\x10\x60'
-_DISCONNECTED_PACKET = b'\x10\x70'
+_DATE_SET_MESSAGE = b'\x10\x10'
 
-_STRUCT_READINGS_COUNT = struct.Struct('>H')
+_DISCONNECT_MESSAGE = b'\x10\x60'
+_DISCONNECTED_MESSAGE = b'\x10\x70'
 
-_FETCH_PACKET = b'\x10\x60'
-
-_ReadingRecord = collections.namedtuple(
-    '_ReadingRecord',
-    ('unknown1', 'unknown2', 'year', 'month', 'day', 'hour', 'minute',
-     'value', 'meal_flag'))
-_STRUCT_READING = struct.Struct('>BBBBBBBHB')
+_FETCH_MESSAGE = b'\x10\x60'
 
 _MEAL_FLAG = {
-    0x00: common.Meal.NONE,
-    0x10: common.Meal.BEFORE,
-    0x20: common.Meal.AFTER,
+    common.Meal.NONE: 0x00,
+    common.Meal.BEFORE: 0x10,
+    common.Meal.AFTER: 0x20,
 }
 
-def parse_reading(msgdata):
-    return _ReadingRecord(*_STRUCT_READING.unpack_from(msgdata))
+_READING = construct.Struct(
+    construct.Byte[2],
+    'year' / construct.Byte,
+    'month' / construct.Byte,
+    'day' / construct.Byte,
+    'hour' / construct.Byte,
+    'minute' / construct.Byte,
+    'value' / construct.Int16ub,
+    'meal' / construct.Mapping(
+        construct.Byte, _MEAL_FLAG),
+    construct.Byte[7],
+)
 
-def xor_checksum(msg):
-    return functools.reduce(operator.xor, msg)
 
 class Device(serial.SerialDevice):
     BAUDRATE = 38400
     DEFAULT_CABLE_ID = '10c4:ea60'  # Generic cable.
     TIMEOUT = 300  # We need to wait for data from the device.
 
-    def read_packet(self):
-        preamble = self.serial_.read(3)
-        if len(preamble) != 3:
-            raise exceptione.InvalidResponse(
-                response='Expected 3 bytes, received %d' % len(preamble))
-        if preamble[0:_IDX_LENGTH] != _RECV_PREAMBLE:
-            raise exceptions.InvalidResponse(
-                response='Unexpected preamble %r' % pramble[0:_IDX_LENGTH])
-
-        msglen = preamble[_IDX_LENGTH]
-        message = self.serial_.read(msglen)
-        if len(message) != msglen:
-            raise exception.InvalidResponse(
-                response='Expected %d bytes, received %d' %
-                (msglen, len(message)))
-        if message[_IDX_ETX] != _ETX:
-            raise exception.InvalidResponse(
-                response='Unexpected end-of-transmission byte: %02x' %
-                message[_IDX_ETX])
-
-        # Calculate the checksum up until before the checksum itself.
-        msgdata = message[:_IDX_CHECKSUM]
-
-        cksum = xor_checksum(msgdata)
-        if cksum != message[_IDX_CHECKSUM]:
-            raise exception.InvalidChecksum(message[_IDX_CHECKSUM], cksum)
-
-        return msgdata
+    def read_message(self):
+        pkt = _PACKET.parse_stream(self.serial_)
+        logging.debug('received packet: %r', pkt)
+        return pkt.message
 
     def wait_and_ready(self):
         challenge = self.serial_.read(1)
@@ -116,6 +104,7 @@ def wait_and_ready(self):
         # The first packet read may have a prefixed zero, it might be a bug in
         # the cp210x driver or device, but discard it if found.
         if challenge == b'\0':
+            logging.debug('spurious null byte received')
             challege = self.serial_.read(1)
             if challenge != b'\x53':
                 raise exceptions.ConnectionFailed(
@@ -127,30 +116,33 @@ def wait_and_ready(self):
             raise exceptions.ConnectionFailed(
                 message='Unexpected challenge %r' % challenge)
 
-        self.send_packet(_RESPONSE_PACKET)
+        logging.debug(
+            'challenge packet received: %s', binascii.hexlify(challenge))
+
+        self.send_message(_RESPONSE_MESSAGE)
 
         # The first packet only contains the counter of how many readings are
         # available.
-        first_packet = self.read_packet()
-
-        count = _STRUCT_READINGS_COUNT.unpack_from(first_packet, 1)
+        first_message = _FIRST_MESSAGE.parse(self.read_message())
+        logging.debug('received first message: %r', first_message)
 
-        return count[0]
+        return first_message.count
 
-    def send_packet(self, msgdata):
-        packet = array.array('B')
-        packet.extend((_STX, _DIR_OUT, len(msgdata)+2))
-        packet.extend(msgdata)
-        packet.extend((xor_checksum(msgdata), _ETX))
-        self.serial_.write(packet.tobytes())
+    def send_message(self, message):
+        pkt = _PACKET.build({
+            'message': message,
+            'direction': Direction.Out
+        })
+        logging.debug('sending packet: %s', binascii.hexlify(pkt))
+        self.serial_.write(pkt)
 
     def connect(self):
         print("Please connect and turn on the device.")
 
     def disconnect(self):
-        self.send_packet(_DISCONNECT_PACKET)
-        response = self.read_packet()
-        if response != _DISCONNECTED_PACKET:
+        self.send_message(_DISCONNECT_MESSAGE)
+        response = self.read_message()
+        if response != _DISCONNECTED_MESSAGE:
             raise exceptions.InvalidResponse(response=response)
 
     def get_meter_info(self):
@@ -175,9 +167,9 @@ def set_datetime(self, date=datetime.datetime.now()):
         # Ignore the readings count.
         self.wait_and_ready()
 
-        self.send_packet(setdatecmd)
-        response = self.read_packet()
-        if response != _DATE_SET_PACKET:
+        self.send_message(setdatecmd)
+        response = self.read_message()
+        if response != _DATE_SET_MESSAGE:
             raise exceptions.InvalidResponse(response=response)
 
         # The date we return should only include up to minute, unfortunately.
@@ -185,19 +177,19 @@ def set_datetime(self, date=datetime.datetime.now()):
                                  date.hour, date.minute)
 
     def zero_log(self):
-        raise NotmplementedError
+        raise NotImplementedError
 
     def get_readings(self):
         count = self.wait_and_ready()
 
         for _ in range(count):
-            self.send_packet(_FETCH_PACKET)
-            rpkt = self.read_packet()
+            self.send_message(_FETCH_MESSAGE)
+            message = self.read_message()
 
-            r = parse_reading(rpkt)
-            meal = _MEAL_FLAG[r.meal_flag]
+            r = _READING.parse(message)
+            logging.debug('received reading: %r', r)
 
             yield common.GlucoseReading(
                 datetime.datetime(
                     2000 + r.year, r.month, r.day, r.hour, r.minute),
-                r.value, meal=meal)
+                r.value, meal=r.meal)
diff --git a/glucometerutils/glucometer.py b/glucometerutils/glucometer.py
new file mode 100755
index 0000000..cd2331c
--- /dev/null
+++ b/glucometerutils/glucometer.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Utility to manage glucometers' data."""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2013-2017, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import argparse
+import importlib
+import inspect
+import logging
+import sys
+
+from glucometerutils import common
+from glucometerutils import exceptions
+
+def main():
+  if sys.version_info < (3, 4):
+    raise Exception(
+      'Unsupported Python version, please use at least Python 3.4')
+
+  parser = argparse.ArgumentParser()
+  subparsers = parser.add_subparsers(dest="action")
+
+  parser.add_argument(
+    '--driver', action='store', required=True,
+    help='Select the driver to use for connecting to the glucometer.')
+  parser.add_argument(
+    '--device', action='store', required=False,
+    help=('Select the path to the glucometer device. Some devices require this '
+          'argument, others will try autodetection.'))
+
+  parser.add_argument(
+    '--vlog', action='store', required=False, type=int,
+    help=('Python logging level. See the levels at '
+          'https://docs.python.org/3/library/logging.html#logging-levels'))
+
+  subparsers.add_parser(
+    'help', help=('Display a description of the driver, including supported '
+                  'features and known quirks.'))
+  subparsers.add_parser(
+    'info', help='Display information about the meter.')
+  subparsers.add_parser(
+    'zero', help='Zero out the data log of the meter.')
+
+  parser_dump = subparsers.add_parser(
+    'dump', help='Dump the readings stored in the device.')
+  parser_dump.add_argument(
+    '--unit', action='store',
+    choices=[unit.value for unit in common.Unit],
+    help='Select the unit to use for the dumped data.')
+  parser_dump.add_argument(
+    '--sort-by', action='store', default='timestamp',
+    choices=common._ReadingBase._fields,
+    help='Field to order the dumped data by.')
+  parser_dump.add_argument(
+    '--with-ketone', action='store_true', default=False,
+    help='Enable ketone reading if available on the glucometer.')
+
+  parser_date = subparsers.add_parser(
+    'datetime', help='Reads or sets the date and time of the glucometer.')
+  parser_date.add_argument(
+    '--set', action='store', nargs='?', const='now', default=None,
+    help='Set the date rather than just reading it from the device.')
+
+  args = parser.parse_args()
+
+  logging.basicConfig(level=args.vlog)
+
+  try:
+    driver = importlib.import_module('glucometerutils.drivers.' + args.driver)
+  except ImportError as e:
+    logging.error(
+      'Error importing driver "%s", please check your --driver parameter:\n%s',
+      args.driver, e)
+    return 1
+
+  # This check needs to happen before we try to initialize the device, as the
+  # help action does not require a --device at all.
+  if args.action == 'help':
+    print(inspect.getdoc(driver))
+    return 0
+
+  device = driver.Device(args.device)
+
+  device.connect()
+  device_info = device.get_meter_info()
+
+  try:
+    if args.action == 'info':
+      try:
+        time_str = device.get_datetime()
+      except NotImplementedError:
+        time_str = 'N/A'
+      print("{device_info}Time: {time}".format(
+        device_info=str(device_info), time=time_str))
+    elif args.action == 'dump':
+      unit = args.unit
+      if unit is None:
+        unit = device_info.native_unit
+
+      readings = device.get_readings()
+
+      if not args.with_ketone:
+        readings = (reading for reading in readings
+                    if not isinstance(reading, common.KetoneReading))
+
+      if args.sort_by is not None:
+        readings = sorted(
+          readings, key=lambda reading: getattr(reading, args.sort_by))
+
+      for reading in readings:
+        print(reading.as_csv(unit))
+    elif args.action == 'datetime':
+      if args.set == 'now':
+        print(device.set_datetime())
+      elif args.set:
+        try:
+          from dateutil import parser as date_parser
+          new_date = date_parser.parse(args.set)
+        except ImportError:
+          logging.error(
+            'Unable to import module "dateutil", please install it.')
+          return 1
+        except ValueError:
+          logging.error('%s: not a valid date', args.set)
+          return 1
+        print(device.set_datetime(new_date))
+      else:
+        print(device.get_datetime())
+    elif args.action == 'zero':
+      confirm = input('Delete the device data log? (y/N) ')
+      if confirm.lower() in ['y', 'ye', 'yes']:
+        device.zero_log()
+        print('\nDevice data log zeroed.')
+      else:
+        print('\nDevice data log not zeroed.')
+        return 1
+    else:
+      return 1
+  except exceptions.Error as err:
+    print('Error while executing \'%s\': %s' % (args.action, str(err)))
+    return 1
+
+  device.disconnect()
diff --git a/glucometerutils/support/construct_extras.py b/glucometerutils/support/construct_extras.py
new file mode 100644
index 0000000..6d4e302
--- /dev/null
+++ b/glucometerutils/support/construct_extras.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+"""Extra classes for Construct."""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2018, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import datetime
+
+import construct
+
+class Timestamp(construct.Adapter):
+    """Adapter for converting datetime object into timestamps.
+
+    Take two parameters: the subcon object to output the resulting timestamp as,
+    and an optional epoch offset to the UNIX Epoch.
+
+    """
+    __slots__ = ["epoch"]
+
+    def __init__(self, subcon, epoch=0):
+        super(Timestamp, self).__init__(subcon)
+        self.epoch = epoch
+
+    def _encode(self, obj, context, path):
+        assert isinstance(obj, datetime.datetime)
+        epoch_date = datetime.datetime.utcfromtimestamp(self.epoch)
+        delta = obj - epoch_date
+        return int(delta.total_seconds())
+
+    def _decode(self, obj, context, path):
+        return datetime.datetime.utcfromtimestamp(obj + self.epoch)
diff --git a/glucometerutils/support/freestyle.py b/glucometerutils/support/freestyle.py
index d722c35..7f9c7e8 100644
--- a/glucometerutils/support/freestyle.py
+++ b/glucometerutils/support/freestyle.py
@@ -15,7 +15,8 @@
 import datetime
 import logging
 import re
-import struct
+
+import construct
 
 from glucometerutils import exceptions
 from glucometerutils.support import hiddevice
@@ -24,7 +25,13 @@
 # protocol.
 _INIT_SEQUENCE = (0x04, 0x05, 0x15, 0x01)
 
-_STRUCT_PREAMBLE = struct.Struct('<BB')
+_FREESTYLE_MESSAGE = construct.Struct(
+    'hid_report' / construct.Const(0, construct.Byte),
+    'message_type' / construct.Byte,
+    'command' / construct.Padded(
+        63,  # command can only be up to 62 bytes, but one is used for length.
+        construct.Prefixed(construct.Byte, construct.GreedyBytes)),
+)
 
 _TEXT_COMPLETION_RE = re.compile('CMD (?:OK|Fail!)')
 _TEXT_REPLY_FORMAT = re.compile(
@@ -93,12 +100,10 @@ def _send_command(self, message_type, command):
           message_type: (int) The first byte sent with the report to the device.
           command: (bytes) The command to send out the device.
         """
-        cmdlen = len(command)
-        assert cmdlen <= 62
+        usb_packet = _FREESTYLE_MESSAGE.build(
+            {'message_type': message_type, 'command': command})
 
-        # First byte in the written buffer is the report number.
-        usb_packet = b'\x00' + _STRUCT_PREAMBLE.pack(
-            message_type, cmdlen) + command + bytes(62 - cmdlen)
+        logging.debug('Sending packet: %r', usb_packet)
 
         self._write(usb_packet)
 
@@ -106,6 +111,8 @@ def _read_response(self):
         """Read the response from the device and extracts it."""
         usb_packet = self._read()
 
+        logging.debug('Read packet: %r', usb_packet)
+
         assert usb_packet
         message_type = usb_packet[0]
         message_length = usb_packet[1]
diff --git a/glucometerutils/support/lifescan_binary_protocol.py b/glucometerutils/support/lifescan_binary_protocol.py
new file mode 100644
index 0000000..4632a94
--- /dev/null
+++ b/glucometerutils/support/lifescan_binary_protocol.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""Support module for the LifeScan binary protocol.
+
+A number of LifeScan devices use a semi-compatible binary protocol to talk host
+and device, which is (vastly) compatible.
+
+This module implements an interface to send and receive these messages.
+"""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2014-2018, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import construct
+
+from glucometerutils import common
+from glucometerutils.support import construct_extras
+from glucometerutils.support import lifescan
+
+_LINK_CONTROL = construct.BitStruct(
+    construct.Padding(3),
+    'more' / construct.Default(construct.Flag, False),
+    'disconnect' / construct.Default(construct.Flag, False),
+    'acknowledge' / construct.Default(construct.Flag, False),
+    'expect_receive' / construct.Default(construct.Flag, False),
+    'sequence_number' / construct.Default(construct.Flag, False),
+)
+
+def LifeScanPacket(command_prefix, include_link_control):
+    if include_link_control:
+        link_control_construct = _LINK_CONTROL
+    else:
+        link_control_construct = construct.Const(b'\x00')
+
+    command_prefix_construct = construct.Const(command_prefix, construct.Byte)
+
+    return construct.Struct(
+        'data' / construct.RawCopy(
+                construct.Struct(
+                    construct.Const(b'\x02'),  # stx
+                    'length' / construct.Rebuild(
+                        construct.Byte, lambda this: len(this.message) + 7),
+                    'link_control' / link_control_construct,
+                    'command_prefix' / command_prefix_construct,
+                    'message' / construct.Bytes(
+                        lambda this: this.length - 7),
+                    construct.Const(b'\x03'),  # etx
+                ),
+        ),
+        'checksum' / construct.Checksum(
+            construct.Int16ul, lifescan.crc_ccitt, construct.this.data.data),
+    )
+
+COMMAND_SUCCESS = construct.Const(b'\x06')
+
+VERIO_TIMESTAMP = construct_extras.Timestamp(
+    construct.Int32ul, epoch=946684800)  # 2000-01-01 (not 2010)
+
+_GLUCOSE_UNIT_MAPPING_TABLE = {
+    common.Unit.MG_DL: 0x00,
+    common.Unit.MMOL_L: 0x01,
+}
+
+GLUCOSE_UNIT = construct.Mapping(
+    construct.Byte, _GLUCOSE_UNIT_MAPPING_TABLE)
diff --git a/glucometerutils/support/serial.py b/glucometerutils/support/serial.py
index d4f352b..ce4ac20 100644
--- a/glucometerutils/support/serial.py
+++ b/glucometerutils/support/serial.py
@@ -64,4 +64,4 @@ def __init__(self, device):
             writeTimeout=None,
             bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE,
             stopbits=serial.STOPBITS_ONE,
-            xonxoff=True, rtscts=False, dsrdtr=False)
+            xonxoff=False, rtscts=False, dsrdtr=False)
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..cd71828
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,15 @@
+[tool:pytest]
+addopts =
+        --color=yes
+        --ignore=setup.py
+        --ignore=test-requirements.txt
+        -r a
+norecursedirs =
+              .git
+              dist
+              build
+              venv
+              .env
+testpaths =
+          test
+timeout = 120
diff --git a/setup.py b/setup.py
index 82a9d07..0a9f258 100644
--- a/setup.py
+++ b/setup.py
@@ -1,27 +1,70 @@
 # -*- coding: utf-8 -*-
 
-from distutils.core import setup
+import sys
+
+from setuptools import setup, find_packages
+from setuptools.command.test import test as TestCommand
+
+
+with open('test-requirements.txt') as requirements:
+    test_required = requirements.read().splitlines()
+
+
+class PyTestCommand(TestCommand):
+
+    def run_tests(self):
+        # import here, cause outside the eggs aren't loaded
+        import pytest
+        errno = pytest.main([])
+        sys.exit(errno)
+
 
 setup(
-  name = 'glucometerutils',
-  packages = ['glucometerutils', 'glucometerutils.drivers', 'glucometerutils.support'],
-  scripts = ['glucometer.py'],
-  version = '1',
-  description = 'Glucometer access utilities',
-  author = 'Diego Elio Pettenò',
-  author_email = 'flameeyes@flameeyes.eu',
-  url = 'https://www.flameeyes.eu/p/glucometerutils',
-  download_url = 'https://www.flameeyes.eu/files/glucometerutils.tgz',
-  keywords = ['glucometer', 'diabetes'],
-  python_requires = '~=3.4',
-  classifiers = [
-    'Programming Language :: Python',
-    'Programming Language :: Python :: 3',
-    'Development Status :: 4 - Beta',
-    'Environment :: Console',
-    'Operating System :: OS Independent',
-    'License :: OSI Approved :: MIT License',
-    'Intended Audience :: End Users/Desktop',
-    'Topic :: Scientific/Engineering :: Medical Science Apps.',
-  ],
+    name = 'glucometerutils',
+    version = '1',
+    description = 'Glucometer access utilities',
+    author = 'Diego Elio Pettenò',
+    author_email = 'flameeyes@flameeyes.eu',
+    url = 'https://www.flameeyes.eu/p/glucometerutils',
+    download_url = 'https://www.flameeyes.eu/files/glucometerutils.tgz',
+    keywords = ['glucometer', 'diabetes'],
+    python_requires = '~=3.4',
+    classifiers = [
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Development Status :: 4 - Beta',
+        'Environment :: Console',
+        'Operating System :: OS Independent',
+        'License :: OSI Approved :: MIT License',
+        'Intended Audience :: End Users/Desktop',
+        'Topic :: Scientific/Engineering :: Medical Science Apps.',
+    ],
+    packages = find_packages(
+        exclude=['test', 'udev']),
+    data_files = [
+        ('lib/udev/rules', ['udev/69-glucometerutils.rules']),
+    ],
+    tests_require = test_required,
+    extras_require = {
+        # These are all the drivers' dependencies. Optional dependencies are
+        # listed as mandatory for the feature.
+        'otultra2': ['pyserial'],
+        'otultraeasy': ['construct', 'pyserial'],
+        'otverio2015': ['construct', 'python-scsi'],
+        'otverioiq': ['construct', 'pyserial'],
+        'fsinsulinx': ['construct', 'hidapi'],
+        'fslibre': ['construct', 'hidapi'],
+        'fsoptium': ['pyserial'],
+        'fsprecisionneo': ['construct', 'hidapi'],
+        'accucheck_reports': [],
+        'sdcodefree': ['construct', 'pyserial'],
+    },
+    entry_points = {
+        'console_scripts': [
+            'glucometer=glucometerutils.glucometer:main'
+        ]
+    },
+    cmdclass = {
+        'test': PyTestCommand,
+    },
 )
diff --git a/test-requirements.txt b/test-requirements.txt
new file mode 100644
index 0000000..9a9c847
--- /dev/null
+++ b/test-requirements.txt
@@ -0,0 +1,5 @@
+absl-py
+construct>=2.9
+pytest>=3.6.0
+pytest-timeout>=1.3.0
+pyserial
diff --git a/test/test_common.py b/test/test_common.py
index 92805a5..4b062ac 100644
--- a/test/test_common.py
+++ b/test/test_common.py
@@ -3,9 +3,10 @@
 
 __author__ = 'Diego Elio Pettenò'
 __email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2013, Diego Elio Pettenò'
+__copyright__ = 'Copyright © 2013-2018, Diego Elio Pettenò'
 __license__ = 'MIT'
 
+import datetime
 import os
 import sys
 import unittest
@@ -15,7 +16,6 @@
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from glucometerutils import common
-from glucometerutils import exceptions
 
 
 class TestGlucoseConversion(parameterized.TestCase):
@@ -52,5 +52,78 @@ def test_invalid_values(self, from_unit, to_unit):
             common.convert_glucose_unit(100, from_unit, to_unit)
 
 
+class TestGlucoseReading(parameterized.TestCase):
+
+    TEST_DATETIME = datetime.datetime(2018, 1, 1, 0, 30, 45)
+
+    def test_minimal(self):
+        reading = common.GlucoseReading(self.TEST_DATETIME, 100)
+        self.assertEqual(reading.as_csv(common.Unit.MG_DL),
+                         '"2018-01-01 00:30:45","100.00","","blood sample",""')
+
+    @parameterized.named_parameters(
+        ('_mgdl', common.Unit.MG_DL, 100),
+        ('_mmoll', common.Unit.MMOL_L, 5.56))
+    def test_value(self, unit, expected_value):
+        reading = common.GlucoseReading(self.TEST_DATETIME, 100)
+        self.assertAlmostEqual(
+            reading.get_value_as(unit), expected_value, places=2)
+
+    @parameterized.named_parameters(
+        ('_meal_none',
+         {'meal': common.Meal.NONE},
+         '"2018-01-01 00:30:45","100.00","","blood sample",""'),
+        ('_meal_before',
+         {'meal': common.Meal.BEFORE},
+         '"2018-01-01 00:30:45","100.00","Before Meal","blood sample",""'),
+        ('_meal_after',
+         {'meal': common.Meal.AFTER},
+         '"2018-01-01 00:30:45","100.00","After Meal","blood sample",""'),
+        ('_measurement_blood',
+         {'measure_method': common.MeasurementMethod.BLOOD_SAMPLE},
+         '"2018-01-01 00:30:45","100.00","","blood sample",""'),
+        ('_measurement_cgm',
+         {'measure_method': common.MeasurementMethod.CGM},
+         '"2018-01-01 00:30:45","100.00","","CGM",""'),
+        ('_comment',
+         {'comment': 'too much'},
+         '"2018-01-01 00:30:45","100.00","","blood sample","too much"'),
+        ('_comment_quoted',
+         {'comment': '"too" much'},
+         '"2018-01-01 00:30:45","100.00","","blood sample","\"too\" much"'),
+    )
+    def test_csv(self, kwargs_dict, expected_csv):
+        reading = common.GlucoseReading(
+            self.TEST_DATETIME, 100, **kwargs_dict)
+        self.assertEqual(reading.as_csv(common.Unit.MG_DL), expected_csv)
+
+
+class TestMeterInfo(parameterized.TestCase):
+
+    @parameterized.named_parameters(
+        ('_no_serial_number',
+         {},
+         'Serial Number: N/A\n'),
+        ('_serial_number',
+         {'serial_number': 1234},
+         'Serial Number: 1234\n'),
+        ('_no_version_information',
+         {},
+         'Version Information:\n    N/A\n'),
+        ('_version_information_1',
+         {'version_info': ['test']},
+         'Version Information:\n    test\n'),
+        ('_version_information_2',
+         {'version_info': ['test', 'test2']},
+         'Version Information:\n    test\n    test2\n'),
+        ('_default_native_unit',
+         {},
+         'Native Unit: mg/dL\n'),
+    )
+    def test_meter_info(self, kwargs_dict, expected_fragment):
+        info = common.MeterInfo(self.id(), **kwargs_dict)
+        self.assertIn(expected_fragment, str(info))
+
+
 if __name__ == '__main__':
-        unittest.main()
+    unittest.main()
diff --git a/test/test_construct_extras.py b/test/test_construct_extras.py
new file mode 100644
index 0000000..b0cd1c3
--- /dev/null
+++ b/test/test_construct_extras.py
@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""Tests for the common routines."""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2018, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import datetime
+import os
+import sys
+import unittest
+
+import construct
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from glucometerutils.support import construct_extras
+
+
+_TEST_DATE1 = datetime.datetime(1970, 1, 2, 0, 0)
+_TEST_DATE2 = datetime.datetime(1971, 1, 1, 0, 0)
+_TEST_DATE3 = datetime.datetime(1970, 1, 1, 0, 0)
+
+_NEW_EPOCH = 31536000  # datetime.datetime(1971, 1, 1, 0, 0)
+
+class TestTimestamp(unittest.TestCase):
+
+    def test_build_unix_epoch(self):
+        self.assertEqual(
+            construct_extras.Timestamp(construct.Int32ul).build(_TEST_DATE1),
+            b'\x80\x51\x01\x00')
+
+    def test_parse_unix_epoch(self):
+        self.assertEqual(
+            construct_extras.Timestamp(construct.Int32ul).parse(
+                b'\x803\xe1\x01'),
+            _TEST_DATE2)
+
+    def test_build_custom_epoch(self):
+        self.assertEqual(
+            construct_extras.Timestamp(
+                construct.Int32ul, epoch=_NEW_EPOCH).build(_TEST_DATE2),
+            b'\x00\x00\x00\x00')
+
+    def test_parse_custom_epoch(self):
+        self.assertEqual(
+            construct_extras.Timestamp(
+                construct.Int32ul, epoch=_NEW_EPOCH).parse(
+                    b'\x00\x00\x00\x00'),
+            _TEST_DATE2)
+
+    def test_build_custom_epoch_negative_failure(self):
+        with self.assertRaises(construct.core.FormatFieldError):
+            construct_extras.Timestamp(
+                construct.Int32ul, epoch=_NEW_EPOCH).build(_TEST_DATE1)
+
+    def test_build_custom_epoch_negative_success(self):
+        self.assertEqual(
+            construct_extras.Timestamp(
+                construct.Int32sl, epoch=_NEW_EPOCH).build(_TEST_DATE1),
+            b'\x00\x1e\x20\xfe')
+
+    def test_build_varint(self):
+        self.assertEqual(
+            construct_extras.Timestamp(construct.VarInt).build(_TEST_DATE3),
+            b'\x00')
+
+    def test_invalid_value(self):
+        with self.assertRaises(AssertionError):
+            construct_extras.Timestamp(construct.Int32ul).build('foo')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_lifescan.py b/test/test_lifescan.py
new file mode 100644
index 0000000..5781829
--- /dev/null
+++ b/test/test_lifescan.py
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""Tests for the LifeScan OneTouch Ultra Mini driver."""
+
+__author__ = 'Diego Elio Pettenò'
+__email__ = 'flameeyes@flameeyes.eu'
+__copyright__ = 'Copyright © 2013-2017, Diego Elio Pettenò'
+__license__ = 'MIT'
+
+import array
+import os
+import sys
+import unittest
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from glucometerutils.support import lifescan
+
+class TestChecksum(unittest.TestCase):
+    def test_crc(self):
+        self.assertEqual(
+            0x41cd,
+            lifescan.crc_ccitt(b'\x02\x06\x06\x03'))
+
+    def test_crc_array(self):
+        cmd_array = array.array('B', b'\x02\x06\x08\x03')
+        self.assertEqual(
+            0x62C2,
+            lifescan.crc_ccitt(cmd_array))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_otultra2.py b/test/test_otultra2.py
index 9f18a85..b421c79 100644
--- a/test/test_otultra2.py
+++ b/test/test_otultra2.py
@@ -3,7 +3,7 @@
 
 __author__ = 'Diego Elio Pettenò'
 __email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2013-2017, Diego Elio Pettenò'
+__copyright__ = 'Copyright © 2013-2018, Diego Elio Pettenò'
 __license__ = 'MIT'
 
 import os
@@ -22,10 +22,12 @@
 class TestOTUltra2(parameterized.TestCase):
 
     def test_checksum(self):
+        # pylint: disable=protected-access
         checksum = otultra2._calculate_checksum(b'T')
         self.assertEqual(0x0054, checksum)
 
     def test_checksum_full(self):
+        # pylint: disable=protected-access
         checksum = otultra2._calculate_checksum(
             b'T "SAT","08/03/13","22:12:00   "')
         self.assertEqual(0x0608, checksum)
diff --git a/test/test_otultraeasy.py b/test/test_otultraeasy.py
deleted file mode 100644
index a1d4c02..0000000
--- a/test/test_otultraeasy.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Tests for the LifeScan OneTouch Ultra Mini driver."""
-
-__author__ = 'Diego Elio Pettenò'
-__email__ = 'flameeyes@flameeyes.eu'
-__copyright__ = 'Copyright © 2013-2017, Diego Elio Pettenò'
-__license__ = 'MIT'
-
-import array
-import os
-import sys
-import unittest
-from unittest import mock
-
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from glucometerutils.drivers import otultraeasy
-from glucometerutils.support import lifescan
-from glucometerutils import exceptions
-
-class TestOTUltraMini(unittest.TestCase):
-    def setUp(self):
-        self.addCleanup(mock.patch.stopall)
-
-        mock_serial = mock.patch('serial.Serial').start()
-        self.mock_readline = mock_serial.return_value.readline
-
-        self.device = otultraeasy.Device('mockdevice')
-
-    def test_crc(self):
-        self.assertEqual(
-            0x41cd,
-            lifescan.crc_ccitt(b'\x02\x06\x06\x03'))
-
-    def test_crc_array(self):
-        cmd_array = array.array('B', b'\x02\x06\x08\x03')
-        self.assertEqual(
-            0x62C2,
-            lifescan.crc_ccitt(cmd_array))
-
-    def test_packet_update_checksum(self):
-        packet = otultraeasy._Packet()
-
-        packet.build_command('')
-        packet.disconnect = True
-
-        packet.update_checksum()
-        self.assertEqual(
-            b'\x02\x06\x08\x03\xC2\x62',
-            packet.tobytes())
-
-        packet.validate_checksum()
-        packet.disconnect = False
-
-        with self.assertRaises(exceptions.InvalidChecksum):
-            packet.validate_checksum()
-
-
-if __name__ == '__main__':
-    unittest.main()