More complete data reader

Should implement all the functionality one needs to avoid using the provided
software that ships with the device.

8 files changed, 683 insertions, 97 deletions

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..1f95d26
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,5 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
index 039680b..9cb44c3 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,18 @@
 dexcom_reader
-=============
\ No newline at end of file
+=============
+
+This is a handful of scripts for dumping data from a Dexcom G4 Glucose Monitor
+connected to a computer with USB.
+
+Out of the box dumps data like:
+
+% python readdata.py 
+Found Dexcom G4 Receiver S/N: SMXXXXXXXX
+Transmitter paired: 6XXXXX
+Battery Status: CHARGING (83%)
+  Record count:
+  - Meter records: 340
+  - CGM records: 3340
+  - CGM commitable records: 3340
+  - Event records: 15
+  - Insertion records: 4
diff --git a/constants.py b/constants.py
new file mode 100644
index 0000000..2f60020
--- /dev/null
+++ b/constants.py
@@ -0,0 +1,94 @@
+import datetime
+
+
+class Error(Exception):
+  """Base error for dexcom reader."""
+
+
+class CrcError(Error):
+  """Failed to CRC properly."""
+
+
+DEXCOM_G4_USB_VENDOR = 0x22a3
+DEXCOM_G4_USB_PRODUCT = 0x0047
+
+BASE_TIME = datetime.datetime(2009, 1, 1)
+
+NULL = 0
+ACK = 1
+NAK = 2
+INVALID_COMMAND = 3
+INVALID_PARAM = 4
+INCOMPLETE_PACKET_RECEIVED = 5
+RECEIVER_ERROR = 6
+INVALID_MODE = 7
+PING = 10
+READ_FIRMWARE_HEADER = 11
+READ_DATABASE_PARTITION_INFO = 15
+READ_DATABASE_PAGE_RANGE = 16
+READ_DATABASE_PAGES = 17
+READ_DATABASE_PAGE_HEADER = 18
+READ_TRANSMITTER_ID = 25
+WRITE_TRANSMITTER_ID = 26
+READ_LANGUAGE = 27
+WRITE_LANGUAGE = 28
+READ_DISPLAY_TIME_OFFSET = 29
+WRITE_DISPLAY_TIME_OFFSET = 30
+READ_RTC = 31
+RESET_RECEIVER = 32
+READ_BATTERY_LEVEL = 33
+READ_SYSTEM_TIME = 34
+READ_SYSTEM_TIME_OFFSET = 35
+WRITE_SYSTEM_TIME = 36
+READ_GLUCOSE_UNIT = 37
+WRITE_GLUCOSE_UNIT = 38
+READ_BLINDED_MODE = 39
+WRITE_BLINDED_MODE = 40
+READ_CLOCK_MODE = 41
+WRITE_CLOCK_MODE = 42
+READ_DEVICE_MODE = 43
+ERASE_DATABASE = 45
+SHUTDOWN_RECEIVER = 46
+WRITE_PC_PARAMETERS = 47
+READ_BATTERY_STATE = 48
+READ_HARDWARE_BOARD_ID = 49
+READ_FIRMWARE_SETTINGS = 54
+READ_ENABLE_SETUP_WIZARD_FLAG = 55
+READ_SETUP_WIZARD_STATE = 57
+MAX_COMMAND = 59
+MAX_POSSIBLE_COMMAND = 255
+
+EGV_VALUE_MASK = 1023
+EGV_DISPLAY_ONLY_MASK = 32768
+EGV_TREND_ARROW_MASK = 15
+
+BATTERY_STATES = [None, 'CHARGING', 'NOT_CHARGING', 'NTC_FAULT', 'BAD_BATTERY']
+
+RECORD_TYPES = [
+  'MANUFACTURING_DATA', 'FIRMWARE_PARAMETER_DATA', 'PC_SOFTWARE_PARAMETER',
+  'SENSOR_DATA', 'EGV_DATA', 'CAL_SET', 'DEVIATION', 'INSERTION_TIME',
+  'RECEIVER_LOG_DATA', 'RECEIVER_ERROR_DATA', 'METER_DATA', 'USER_EVENT_DATA',
+  'USER_SETTING_DATA', 'MAX_VALUE',
+]
+
+TREND_ARROW_VALUES = [None, 'DOUBLE_UP', 'SINGLE_UP', '45_UP', 'FLAT',
+                      '45_DOWN', 'SINGLE_DOWN', 'DOUBLE_DOWN', 'NOT_COMPUTABLE',
+                      'OUT_OF_RANGE']
+
+SPECIAL_GLUCOSE_VALUES = {0: None,
+                          1: 'SENSOR_NOT_ACTIVE',
+                          2: 'MINIMAL_DEVIATION',
+                          3: 'NO_ANTENNA',
+                          5: 'SENSOR_NOT_CALIBRATED',
+                          6: 'COUNTS_DEVIATION',
+                          9: 'ABSOLUTE_DEVIATION',
+                          10: 'POWER_DEVIATION',
+                          12: 'BAD_RF'}
+
+
+LANGUAGES = {
+  0: None,
+  1033: 'ENGLISH',
+}
+
+
diff --git a/crc16.py b/crc16.py
new file mode 100644
index 0000000..0a55332
--- /dev/null
+++ b/crc16.py
@@ -0,0 +1,37 @@
+TABLE = [
+  0, 4129, 8258, 12387, 16516, 20645, 24774, 28903, 33032, 37161, 41290, 
+  45419, 49548, 53677, 57806, 61935, 4657, 528, 12915, 8786, 21173, 17044, 
+  29431, 25302, 37689, 33560, 45947, 41818, 54205, 50076, 62463, 58334, 9314, 
+  13379, 1056, 5121, 25830, 29895, 17572, 21637, 42346, 46411, 34088, 38153, 
+  58862, 62927, 50604, 54669, 13907, 9842, 5649, 1584, 30423, 26358, 22165, 
+  18100, 46939, 42874, 38681, 34616, 63455, 59390, 55197, 51132, 18628, 22757, 
+  26758, 30887, 2112, 6241, 10242, 14371, 51660, 55789, 59790, 63919, 35144, 
+  39273, 43274, 47403, 23285, 19156, 31415, 27286, 6769, 2640, 14899, 10770, 
+  56317, 52188, 64447, 60318, 39801, 35672, 47931, 43802, 27814, 31879, 19684, 
+  23749, 11298, 15363, 3168, 7233, 60846, 64911, 52716, 56781, 44330, 48395, 
+  36200, 40265, 32407, 28342, 24277, 20212, 15891, 11826, 7761, 3696, 65439, 
+  61374, 57309, 53244, 48923, 44858, 40793, 36728, 37256, 33193, 45514, 41451, 
+  53516, 49453, 61774, 57711, 4224, 161, 12482, 8419, 20484, 16421, 28742, 
+  24679, 33721, 37784, 41979, 46042, 49981, 54044, 58239, 62302, 689, 4752, 
+  8947, 13010, 16949, 21012, 25207, 29270, 46570, 42443, 38312, 34185, 62830, 
+  58703, 54572, 50445, 13538, 9411, 5280, 1153, 29798, 25671, 21540, 17413, 
+  42971, 47098, 34713, 38840, 59231, 63358, 50973, 55100, 9939, 14066, 1681, 
+  5808, 26199, 30326, 17941, 22068, 55628, 51565, 63758, 59695, 39368, 35305, 
+  47498, 43435, 22596, 18533, 30726, 26663, 6336, 2273, 14466, 10403, 52093, 
+  56156, 60223, 64286, 35833, 39896, 43963, 48026, 19061, 23124, 27191, 31254, 
+  2801, 6864, 10931, 14994, 64814, 60687, 56684, 52557, 48554, 44427, 40424, 
+  36297, 31782, 27655, 23652, 19525, 15522, 11395, 7392, 3265, 61215, 65342, 
+  53085, 57212, 44955, 49082, 36825, 40952, 28183, 32310, 20053, 24180, 11923, 
+  16050, 3793, 7920
+]
+
+
+def crc16(buf, start=None, end=None):
+  if start is None:
+    start = 0
+  if end is None:
+    end = len(buf)
+  num = 0
+  for i in range(start, end):
+    num = ((num<<8)&0xff00) ^ TABLE[((num>>8)&0xff)^ord(buf[i])]
+  return num & 0xffff
diff --git a/database_records.py b/database_records.py
new file mode 100644
index 0000000..bde0c67
--- /dev/null
+++ b/database_records.py
@@ -0,0 +1,189 @@
+import crc16
+import constants
+import struct
+import util
+
+
+class BaseDatabaseRecord(object):
+  FORMAT = None
+
+  @classmethod
+  def _CheckFormat(cls):
+    if cls.FORMAT is None or not cls.FORMAT:
+      raise NotImplementedError("Subclasses of %s need to define FORMAT"
+                                % cls.__name__)
+
+  @classmethod
+  def _ClassFormat(cls):
+    cls._CheckFormat()
+    return struct.Struct(cls.FORMAT)
+
+  @classmethod
+  def _ClassSize(cls):
+    return cls._ClassFormat().size
+
+  @property
+  def FMT(self):
+    self._CheckFormat()
+    return _ClassFormat()
+
+  @property
+  def SIZE(self):
+    return self._ClassSize()
+
+  @property
+  def crc(self):
+    return self.data[-1]
+
+  def __init__(self, data, raw_data):
+    self.raw_data = raw_data
+    self.data = data
+    self.check_crc()
+
+  def check_crc(self):
+    local_crc = self.calculate_crc()
+    if local_crc != self.crc:
+      raise constants.CrcError('Could not parse %s' % self.__class__.__name__)
+
+  def dump(self):
+    return ''.join('\\x%02x' % ord(c) for c in self.raw_data)
+
+  def calculate_crc(self):
+    return crc16.crc16(self.raw_data[:-2])
+
+  @classmethod
+  def Create(cls, data, record_counter):
+    offset = record_counter * cls._ClassSize()
+    raw_data = data[offset:offset + cls._ClassSize()]
+    unpacked_data = cls._ClassFormat().unpack(raw_data)
+    return cls(unpacked_data, raw_data)
+
+
+class GenericTimestampedRecord(BaseDatabaseRecord):
+  @property
+  def system_time(self):
+    return util.ReceiverTimeToTime(self.data[0])
+
+  @property
+  def display_time(self):
+    return util.ReceiverTimeToTime(self.data[1])
+
+
+class GenericXMLRecord(GenericTimestampedRecord):
+  FORMAT = '<II490sH'
+
+  @property
+  def xmldata(self):
+    data = self.data[2].replace("\x00", "")
+    return data
+
+
+class InsertionRecord(GenericTimestampedRecord):
+  FORMAT = '<3IcH'
+
+  @property
+  def insertion_time(self):
+    return util.ReceiverTimeToTime(self.data[2])
+
+  @property
+  def session_state(self):
+    states = [None, 'REMOVED', 'EXPIRED', 'RESIDUAL_DEVIATION',
+              'COUNTS_DEVIATION', 'SECOND_SESSION', 'OFF_TIME_LOSS',
+              'STARTED', 'BAD_TRANSMITTER', 'MANUFACTURING_MODE']
+    return states[ord(self.data[3])]
+
+  def __repr__(self):
+    return '%s:  state=%s' % (self.display_time, self.session_state)
+
+
+class MeterRecord(GenericTimestampedRecord):
+  FORMAT = '<2IHIH'
+
+  @property
+  def meter_glucose(self):
+    return self.data[2]
+
+  @property
+  def meter_time(self):
+    return util.ReceiverTimeToTime(self.data[3])
+
+  def __repr__(self):
+    return '%s: Meter BG:%s' % (self.display_time, self.meter_glucose)
+
+
+class EventRecord(GenericTimestampedRecord):
+  # sys_time,display_time,glucose,meter_time,crc
+  FORMAT = '<2I2c2IH'
+
+  @property
+  def event_type(self):
+    event_types = [None, 'CARBS', 'INSULIN', 'HEALTH', 'EXCERCISE',
+                    'MAX_VALUE']
+    return event_types[ord(self.data[2])]
+
+  @property
+  def event_sub_type(self):
+    subtypes = {'HEALTH': [None, 'ILLNESS', 'STRESS', 'HIGH_SYMPTOMS',
+                            'LOW_SYMTOMS', 'CYCLE', 'ALCOHOL'],
+                'EXCERCISE': [None, 'LIGHT', 'MEDIUM', 'HEAVY',
+                              'MAX_VALUE']}
+    if self.event_type in subtypes:
+      return subtypes[self.event_type][ord(self.data[3])]
+
+  @property
+  def display_time(self):
+    return util.ReceiverTimeToTime(self.data[4])
+
+  @property
+  def event_value(self):
+    value = self.data[5]
+    if self.event_type == 'INSULIN':
+      value = value / 100.0
+    return value
+
+  def __repr__(self):
+    return '%s:  event_type=%s sub_type=%s value=%s' % (self.display_time, self.event_type,
+                                    self.event_sub_type, self.event_value)
+
+
+class EGVRecord(GenericTimestampedRecord):
+  # uint, uint, ushort, byte, ushort
+  # (system_seconds, display_seconds, glucose, trend_arrow, crc)
+  FORMAT = '<2IHcH'
+
+  @property
+  def full_glucose(self):
+    return self.data[2]
+
+  @property
+  def full_trend(self):
+    return self.data[3]
+
+  @property
+  def display_only(self):
+    return bool(self.full_glucose & constants.EGV_DISPLAY_ONLY_MASK)
+
+  @property
+  def glucose(self):
+    return self.full_glucose & constants.EGV_VALUE_MASK
+
+  @property
+  def glucose_special_meaning(self):
+    if self.glucose in constants.SPECIAL_GLUCOSE_VALUES:
+      return constants.SPECIAL_GLUCOSE_VALUES[self.glucose]
+
+  @property
+  def is_special(self):
+    return self.glucose_special_meaning is not None
+
+  @property
+  def trend_arrow(self):
+    arrow_value = ord(self.full_trend) & constants.EGV_TREND_ARROW_MASK
+    return constants.TREND_ARROW_VALUES[arrow_value]
+
+  def __repr__(self):
+    if self.is_special:
+      return '%s: %s' % (self.display_time, self.glucose_special_meaning)
+    else:
+      return '%s: CGM BG:%s (%s) DO:%s' % (self.display_time, self.glucose,
+                                           self.trend_arrow, self.display_only)
diff --git a/packetwriter.py b/packetwriter.py
new file mode 100644
index 0000000..6e03342
--- /dev/null
+++ b/packetwriter.py
@@ -0,0 +1,49 @@
+import crc16
+import struct
+
+class PacketWriter(object):
+  MAX_PAYLOAD = 1584
+  MIN_LEN = 6
+  MAX_LEN = 1590
+  SOF = 0x01
+  OFFSET_SOF = 0
+  OFFSET_LENGTH = 1
+  OFFSET_CMD = 3
+  OFFSET_PAYLOAD = 4
+
+  def __init__(self):
+    self._packet = None
+
+  def Clear(self):
+    self._packet = None
+
+  def NewSOF(self, v):
+    self._packet[0] = chr(v)
+
+  def PacketString(self):
+    return ''.join(self._packet)
+ 
+  def AppendCrc(self):
+    self.SetLength()
+    ps = self.PacketString()
+    crc = crc16.crc16(ps, 0, len(ps))
+    for x in struct.pack('H', crc):
+      self._packet.append(x)
+
+  def SetLength(self):
+    self._packet[1] = chr(len(self._packet) + 2)
+
+  def _Add(self, x):
+    try:
+      len(x)
+      for y in x:
+        self._Add(y)
+    except:
+      self._packet.append(x)
+
+  def ComposePacket(self, command, payload=None):
+    assert self._packet is None
+    self._packet = ["\x01", None, "\x00", chr(command)]
+    if payload:
+      self._Add(payload)
+    self.AppendCrc()
diff --git a/readdata.py b/readdata.py
index 7fe86c2..c743b99 100644
--- a/readdata.py
+++ b/readdata.py
@@ -1,30 +1,60 @@
-"""Dexcom G4 Platinum data reader.
-
-Copyright 2013
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-from curses import ascii as asciicc
-import re
+import crc16
+import constants
+import database_records
+import datetime
 import serial
 import sys
 import time
+import packetwriter
+import struct
+import re
+import util
 import xml.etree.ElementTree as ET
+import numpy
+import platform
+
+
+class ReadPacket(object):
+  def __init__(self, command, data):
+    self._command = command
+    self._data = data
+
+  @property
+  def command(self):
+    return self._command
+
+  @property
+  def data(self):
+    return self._data
 
 
 class Dexcom(object):
-  BASE_PREFIX = "\x01\x06\x00"
+  @staticmethod
+  def FindDevice():
+    return util.find_usbserial(constants.DEXCOM_G4_USB_VENDOR,
+                               constants.DEXCOM_G4_USB_PRODUCT)
+
+  @classmethod
+  def LocateAndDownload(cls):
+    device = cls.FindDevice()
+    if not device:
+      sys.stderr.write('Could not find Dexcom G4 Receiver!\n')
+      sys.exit(1)
+    else:
+      dex = cls(device)
+      print ('Found %s S/N: %s'
+             % (dex.GetFirmwareHeader().get('ProductName'),
+                dex.ReadManufacturingData().get('SerialNumber')))
+      print 'Transmitter paired: %s' % dex.ReadTransmitterId()
+      print 'Battery Status: %s (%d%%)' % (dex.ReadBatteryState(),
+                                           dex.ReadBatteryLevel())
+      print 'Record count:'
+      print '- Meter records: %d' % (len(dex.ReadRecords('METER_DATA')))
+      print '- CGM records: %d' % (len(dex.ReadRecords('EGV_DATA')))
+      print ('- CGM commitable records: %d'
+             % (len([not x.display_only for x in dex.ReadRecords('EGV_DATA')])))
+      print '- Event records: %d' % (len(dex.ReadRecords('USER_EVENT_DATA')))
+      print '- Insertion records: %d' % (len(dex.ReadRecords('INSERTION_TIME')))
 
   def __init__(self, port):
     self._port_name = port
@@ -44,44 +74,110 @@ class Dexcom(object):
       self.Connect()
     return self._port
 
-  def Waiting(self, timeout=None):
-    start_time = time.time()
-    while True:
-      if (timeout is not None) and (time.time() - start_time) > timeout:
-        return 0
-      n = self.port.inWaiting()
-      if n:
-        return n
-      time.sleep(0.1)
-
   def write(self, *args, **kwargs):
     return self.port.write(*args, **kwargs)
 
   def read(self, *args, **kwargs):
     return self.port.read(*args, **kwargs)
 
-  def readwaiting(self):
-    waiting = self.Waiting()
-    return self.read(waiting)
-
-  def Handshake(self):
-    self.write("%s\x0a\x5e\x65" % self.BASE_PREFIX)
-    if self.readwaiting() == "%s\x01\x35\xd4" % self.BASE_PREFIX:
-      return True
-
-  def IdentifyDevice(self):
-    iprefix = "\x01\x03\x01\x01"
-    self.write("%s\x0b\x7f\x75" % self.BASE_PREFIX)
-    i = self.readwaiting()
-    # Strip prefix
-    i = i[len(iprefix):]
-    # Strip tail
-    ta = i[-2:]
-    assert ta == "\xd8\xd4"
-    i = i[:-2]
-    e = ET.fromstring(i)
-    print 'Found %s' % e.get('ProductName')
-    return e
+  def readpacket(self, timeout=None):
+    total_read = 4
+    intial_read = self.read(total_read)
+    all_data = initial_read
+    if ord(initial_read[0]) == 1:
+      command = initial_read[3]
+      data_number = struct.unpack('<H', initial_read[1:3])[0]
+      if data_number > 6:
+        toread = abs(data_number-6)
+        second_read = self.read(toread)
+        all_data += second_read
+        total_read += toread
+        out = second_read
+      else:
+        out =  ''
+      suffix = self.read(2)
+      sent_crc = struct.unpack('<H', suffix)[0]
+      local_crc = crc16.crc16(all_data, 0, total_read)
+      if sent_crc != local_crc
+        raise constants.CrcError("readpacket Failed CRC check")
+      num1 = total_read + 2
+      return ReadPacket(command, out)
+    else:
+      raise constants.Error('Error reading packet header!')
+
+  def Ping(self):
+    self.WriteCommand(constants.PING)
+    packet = self.readpacket()
+    return ord(packet.command) == constants.ACK
+
+  def WritePacket(self, packet):
+    if not packet:
+      raise constants.Error('Need a packet to send')
+    packetlen = len(packet)
+    if packetlen < 6 or packetlen > 1590:
+      raise constants.Error('Invalid packet length')
+    self.flush()
+    self.write(packet)
+
+  def WriteCommand(self, command_id, *args, **kwargs):
+    p = packetwriter.PacketWriter()
+    p.ComposePacket(command_id, *args, **kwargs)
+    self.WritePacket(p.PacketString())
+
+  def GenericReadCommand(self, command_id):
+    self.WriteCommand(command_id)
+    return self.readpacket()
+
+  def ReadTransmitterId(self):
+    return self.GenericReadCommand(constants.READ_TRANSMITTER_ID).data
+
+  def ReadLanguage(self):
+    lang = self.GenericReadCommand(constants.READ_LANGUAGE).data
+    return constants.LANGUAGES[struct.unpack('H', lang)[0]]
+
+  def ReadBatteryLevel(self):
+    level = self.GenericReadCommand(constants.READ_BATTERY_LEVEL).data
+    return struct.unpack('I', level)[0]
+
+  def ReadBatteryState(self):
+    state = self.GenericReadCommand(constants.READ_BATTERY_STATE).data
+    return constants.BATTERY_STATES[ord(state)]
+
+  def ReadRTC(self):
+    rtc = self.GenericReadCommand(constants.READ_RTC).data
+    return util.ReceiverTimeToTime(struct.unpack('I', rtc)[0])
+
+  def ReadSystemTime(self):
+    rtc = self.GenericReadCommand(constants.READ_SYSTEM_TIME).data
+    return util.ReceiverTimeToTime(struct.unpack('I', rtc)[0])
+
+  def ReadSystemTimeOffset(self):
+    rtc = self.GenericReadCommand(constants.READ_SYSTEM_TIME_OFFSET).data
+    return datetime.timedelta(seconds=struct.unpack('i', rtc)[0])
+
+  def ReadDisplayTimeOffset(self):
+    rtc = self.GenericReadCommand(constants.READ_DISPLAY_TIME_OFFSET).data
+    return datetime.timedelta(seconds=struct.unpack('i', rtc)[0])
+
+  def ReadDisplayTime(self):
+    return self.ReadSystemTime() + self.ReadDisplayTimeOffset()
+
+  def ReadGlucoseUnit(self):
+    UNIT_TYPE = (None, 'mg/dL', 'mmol/L')
+    gu = self.GenericReadCommand(constants.READ_GLUCOSE_UNIT).data
+    return UNIT_TYPE[ord(gu[0])]
+
+  def ReadClockMode(self):
+    CLOCK_MODE = (24, 12)
+    cm = self.GenericReadCommand(constants.READ_CLOCK_MODE).data
+    return CLOCK_MODE[ord(cm[0])]
+
+  def ReadDeviceMode(self):
+    return self.GenericReadCommand(constants.READ_DEVICE_MODE).data
+
+  def ReadManufacturingData(self):
+    data = self.ReadRecords('MANUFACTURING_DATA')[0].xmldata
+    return ET.fromstring(data)
 
   def flush(self):
     self.port.flush()
@@ -90,56 +186,74 @@ class Dexcom(object):
     self.port.flushInput()
     self.port.flushOutput()
 
-  def CleanData(self, i):
-    i = ''.join(c for c in i if ord(c) >= 32)
-    return i
+  def GetFirmwareHeader(self):
+    i = self.GenericReadCommand(constants.READ_FIRMWARE_HEADER)
+    return ET.fromstring(i.data)
+
+  def GetFirmwareSettings(self):
+    i = self.GenericReadCommand(constants.READ_FIRMWARE_SETTINGS)
+    return ET.fromstring(i.data)
 
-  def GetManufacturingParameters(self):
-    #self.port.write("\x01\x07\x00\x10\x00\x0f\xf8")
-    #self.readwaiting()
-    #self.clear()
-    self.write("\x01\x0c\x00\x11\x00\x00\x00\x00\x00\x01\x6e\x45")
+  def DataPartitions(self):
+    i = self.GenericReadCommand(constants.READ_DATABASE_PARTITION_INFO)
+    return ET.fromstring(i.data)
 
-    i = self.CleanData(self.readwaiting())
-    i = i[8:-4]
-    e = ET.fromstring(i)
-    print 'Found %s (S/N: %s)' % (e.get('HardwarePartNumber'),
-                                  e.get('SerialNumber'))
-    return e
+  def ReadDatabasePageRange(self, record_type):
+    record_type_index = constants.RECORD_TYPES.index(record_type)
+    self.WriteCommand(constants.READ_DATABASE_PAGE_RANGE,
+                      chr(record_type_index))
+    packet = self.readpacket()
+    return struct.unpack('II', packet.data)
 
-  def GetFirmwareHeader(self):
-    self.write("\x01\x06\x00\x0b\x7f\x75")
-    i = self.CleanData(self.readwaiting())[:-2]
-    e = ET.fromstring(i)
-    return e
+  def ReadDatabasePage(self, record_type, page):
+    record_type_index = constants.RECORD_TYPES.index(record_type)
+    self.WriteCommand(constants.READ_DATABASE_PAGES,
+                      (chr(record_type_index), struct.pack('I', page), chr(1)))
+    packet = self.readpacket()
+    assert ord(packet.command) == 1
+    # first index (uint), numrec (uint), record_type (byte), revision (byte),
+    # page# (uint), r1 (uint), r2 (uint), r3 (uint), ushort (Crc)
+    header_format = '<2I2c4IH'
+    header_data_len = struct.calcsize(header_format)
+    header = struct.unpack_from(header_format, packet.data)
+    header_crc = crc16.crc16(packet.data[:header_data_len-2])
+    assert header_crc == header[-1]
+    assert ord(header[2]) == record_type_index
+    assert header[4] == page
+    packet_data = packet.data[header_data_len:]
 
-  def Ping(self):
-    self.write("\x01\x07\x00\x10\x02\x4d\xd8")
-    self.readwaiting()
-    self.write("\x01\x07\x00\x10\x02\x4d\xd8")
-    self.readwaiting()
-    self.flush()
-    self.clear()
+    return self.ParsePage(header, packet_data)
 
-  def GetPcParams(self):
-    self.write("\x01\x0c\x00\x11\x02\x00\x00\x00\x00\x01\x2e\xce")
-    i =self.CleanData(self.readwaiting())[8:-3]
-    e = ET.fromstring(i)
-    return e
+  def GenericRecordYielder(self, header, data, record_type):
+    for x in range(header[1]):
+      yield record_type.Create(data, x)
 
-  def DataPartitions(self):
-    self.write("\x01\x06\x00\x36\x81\x92")
-    print self.readwaiting()
-    self.write("\x01\x06\x00\x0f\xfb\x35")
-    print self.readwaiting()
-    print self.readwaiting()
+  def ParsePage(self, header, data):
+    record_type = constants.RECORD_TYPES[ord(header[2])]
+    generic_parser_map = {
+      'USER_EVENT_DATA': database_records.EventRecord,
+      'METER_DATA': database_records.MeterRecord,
+      'INSERTION_TIME': database_records.InsertionRecord,
+      'EGV_DATA': database_records.EGVRecord,
+    }
+    xml_parsed = ['PC_SOFTWARE_PARAMETER', 'MANUFACTURING_DATA']
+    if record_type in generic_parser_map:
+      return self.GenericRecordYielder(header, data,
+                                       generic_parser_map[record_type])
+    elif record_type in xml_parsed:
+      return [database_records.GenericXMLRecord.Create(data, 0)]
+    else:
+      raise NotImplementedError('Parsing of %s has not yet been implemented'
+                                % record_type)
 
-d = Dexcom(sys.argv[1])
+  def ReadRecords(self, record_type):
+    records = []
+    assert record_type in constants.RECORD_TYPES
+    page_range = self.ReadDatabasePageRange(record_type)
+    for x in range(page_range[0], page_range[1] or 1):
+      records.extend(self.ReadDatabasePage(record_type, x))
+    return records
 
-if d.Handshake():
-  print "Connected successfully!"
 
-print d.IdentifyDevice()
-print d.GetManufacturingParameters()
-print d.GetFirmwareHeader()
-print d.GetPcParams()
+if __name__ == '__main__':
+  Dexcom.LocateAndDownload()
diff --git a/util.py b/util.py
new file mode 100644
index 0000000..c719092
--- /dev/null
+++ b/util.py
@@ -0,0 +1,82 @@
+import constants
+import datetime
+import os
+import platform
+import plistlib
+import re
+import subprocess
+
+
+def ReceiverTimeToTime(rtime):
+  return constants.BASE_TIME + datetime.timedelta(seconds=rtime)
+
+
+def linux_find_usbserial(vendor, product):
+  DEV_REGEX = re.compile('^tty(USB|ACM)[0-9]+$')
+  for usb_dev_root in os.listdir('/sys/bus/usb/devices'):
+    device_name = os.path.join('/sys/bus/usb/devices', usb_dev_root)
+    if not os.path.exists(os.path.join(device_name, 'idVendor')):
+      continue
+    idv = open(os.path.join(device_name, 'idVendor')).read().strip()
+    if idv != vendor:
+      continue
+    idp = open(os.path.join(device_name, 'idProduct')).read().strip()
+    if idp != product:
+      continue
+    for root, dirs, files in os.walk(device_name):
+      for option in dirs + files:
+        if DEV_REGEX.match(option):
+          return os.path.join('/dev', option)
+
+
+def osx_find_usbserial(vendor, product):
+  def recur(v):
+    if hasattr(v, '__iter__') and 'idVendor' in v and 'idProduct' in v:
+      if v['idVendor'] == vendor and v['idProduct'] == product:
+        tmp = v
+        while True:
+          if 'IODialinDevice' not in tmp and 'IORegistryEntryChildren' in tmp:
+            tmp = tmp['IORegistryEntryChildren']
+          elif 'IODialinDevice' in tmp:
+            return tmp['IODialinDevice']
+          else:
+            break
+
+    if type(v) == list:
+      for x in v:
+        out = recur(x)
+        if out is not None:
+          return out
+    elif type(v) == dict or issubclass(type(v), dict):
+      for x in v.values():
+        out = recur(x)
+        if out is not None:
+          return out
+
+  sp = subprocess.Popen(['/usr/sbin/ioreg', '-k', 'IODialinDevice',
+                         '-r', '-t', '-l', '-a', '-x'],
+                        stdout=subprocess.PIPE,
+                        stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+  stdout, _ = sp.communicate()
+  plist = plistlib.readPlistFromString(stdout)
+  return recur(plist)
+
+
+def find_usbserial(vendor, product):
+  """Find the tty device for a given usbserial devices identifiers.
+
+  Args:
+     vendor: (int) something like 0x0000
+     product: (int) something like 0x0000
+
+  Returns:
+     String, like /dev/ttyACM0 or /dev/tty.usb...
+  """
+  if platform.system() == 'Linux':
+    vendor, product = [('%04x' % (x)).strip() for x in (vendor, product)]
+    return linux_find_usbserial(vendor, product)
+  elif platform.system() == 'Darwin':
+    return osx_find_usbserial(vendor, product)
+  else:
+    raise NotImplementedError('Cannot find serial ports on %s'
+                              % platform.system())