Merge pull request openaps#3 from openaps/dev

stub out next release: 0.1.0-dev area

Author: bewest

dexcom_reader/database_records.py

@@ -103,21 +103,117 @@ def insertion_time(self):
   def session_state(self):
     states = [None, 'REMOVED', 'EXPIRED', 'RESIDUAL_DEVIATION',
               'COUNTS_DEVIATION', 'SECOND_SESSION', 'OFF_TIME_LOSS',
-              'STARTED', 'BAD_TRANSMITTER', 'MANUFACTURING_MODE']
+              'STARTED', 'BAD_TRANSMITTER', 'MANUFACTURING_MODE',
+              'UNKNOWN1', 'UNKNOWN2', 'UNKNOWN3', 'UNKNOWN4', 'UNKNOWN5',
+              'UNKNOWN6', 'UNKNOWN7', 'UNKNOWN8']
     return states[ord(self.data[3])]
 
   def __repr__(self):
     return '%s:  state=%s' % (self.display_time, self.session_state)
 
+class G5InsertionRecord (InsertionRecord):
+  FORMAT = '<3Ic10BH'
 
 class Calibration(GenericTimestampedRecord):
+  FORMAT = '<2Iddd3cdb'
+  # CAL_FORMAT = '<2Iddd3cdb'
+  FIELDS = [ 'slope', 'intercept', 'scale', 'decay', 'numsub', 'raw' ]
   @property
-  def raw(self):
-    return binascii.hexlify(bytearray(self.data))
+  def raw (self):
+    return binascii.hexlify(self.raw_data)
+  @property
+  def slope  (self):
+    return self.data[2]
+  @property
+  def intercept  (self):
+    return self.data[3]
+  @property
+  def scale (self):
+    return self.data[4]
+  @property
+  def decay (self):
+    return self.data[8]
+  @property
+  def numsub (self):
+    return int(self.data[9])
 
   def __repr__(self):
     return '%s: CAL SET:%s' % (self.display_time, self.raw)
 
+  LEGACY_SIZE = 148
+  REV_2_SIZE = 249
+  @classmethod
+  def _ClassSize(cls):
+
+    return cls.REV_2_SIZE
+
+  @classmethod
+  def Create(cls, data, record_counter):
+    offset = record_counter * cls._ClassSize()
+    cal_size = struct.calcsize(cls.FORMAT)
+    raw_data = data[offset:offset + cls._ClassSize()]
+
+    cal_data = data[offset:offset + cal_size]
+    unpacked_data = cls._ClassFormat().unpack(cal_data)
+    return cls(unpacked_data, raw_data)
+
+  def __init__ (self, data, raw_data):
+    self.page_data = raw_data
+    self.raw_data = raw_data
+    self.data = data
+    subsize = struct.calcsize(SubCal.FORMAT)
+    offset = self.numsub * subsize
+    calsize = struct.calcsize(self.FORMAT)
+    caldata = raw_data[:calsize]
+    subdata = raw_data[calsize:calsize + offset]
+    crcdata = raw_data[calsize+offset:calsize+offset+2]
+
+    subcals = [ ]
+    for i in xrange(self.numsub):
+      offset = i * subsize
+      raw_sub = subdata[offset:offset+subsize]
+      sub = SubCal(raw_sub, self.data[1])
+      subcals.append(sub)
+
+    self.subcals = subcals
+
+    self.check_crc()
+  def to_dict (self):
+    res = super(Calibration, self).to_dict( )
+    res['subrecords'] = [ sub.to_dict( ) for sub in  self.subcals ]
+    return res
+  @property
+  def crc(self):
+    return struct.unpack('H', self.raw_data[-2:])[0]
+
+class LegacyCalibration (Calibration):
+  @classmethod
+  def _ClassSize(cls):
+
+    return cls.LEGACY_SIZE
+
+
+class SubCal (GenericTimestampedRecord):
+  FORMAT = '<IIIIc'
+  BASE_FIELDS = [ ]
+  FIELDS = [ 'entered', 'meter',  'sensor', 'applied', ]
+  def __init__ (self, raw_data, displayOffset=None):
+    self.raw_data = raw_data
+    self.data = self._ClassFormat().unpack(raw_data)
+    self.displayOffset = displayOffset
+  @property
+  def entered  (self):
+    return util.ReceiverTimeToTime(self.data[0])
+  @property
+  def meter  (self):
+    return int(self.data[1])
+  @property
+  def sensor  (self):
+    return int(self.data[2])
+  @property
+  def applied  (self):
+    return util.ReceiverTimeToTime(self.data[3])
+
 class MeterRecord(GenericTimestampedRecord):
   FORMAT = '<2IHIH'
   FIELDS = ['meter_glucose', 'meter_time' ]
@@ -133,6 +229,8 @@ def meter_time(self):
   def __repr__(self):
     return '%s: Meter BG:%s' % (self.display_time, self.meter_glucose)
 
+class G5MeterRecord (MeterRecord):
+  FORMAT = '<2IHI5BH'
 
 class EventRecord(GenericTimestampedRecord):
   # sys_time,display_time,glucose,meter_time,crc
@@ -230,3 +328,11 @@ def __repr__(self):
     else:
       return '%s: CGM BG:%s (%s) DO:%s' % (self.display_time, self.glucose,
                                            self.trend_arrow, self.display_only)
+
+class G5EGVRecord (EGVRecord):
+  FORMAT = '<2IHBBBBBBBBBcBH'
+  @property
+  def full_trend(self):
+    return self.data[12]
+
+

dexcom_reader/readdata.py

@@ -251,7 +251,7 @@ def ReadDatabasePage(self, record_type, page):
     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_format = '<2IcB4IH'
     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])
@@ -266,15 +266,21 @@ def GenericRecordYielder(self, header, data, record_type):
     for x in xrange(header[1]):
       yield record_type.Create(data, x)
 
-  def ParsePage(self, header, data):
-    record_type = constants.RECORD_TYPES[ord(header[2])]
-    generic_parser_map = {
+  PARSER_MAP = {
       'USER_EVENT_DATA': database_records.EventRecord,
       'METER_DATA': database_records.MeterRecord,
+      'CAL_SET': database_records.Calibration,
+      # 'CAL_SET': database_records.Calibration,
       'INSERTION_TIME': database_records.InsertionRecord,
       'EGV_DATA': database_records.EGVRecord,
       'SENSOR_DATA': database_records.SensorRecord,
     }
+  def ParsePage(self, header, data):
+    record_type = constants.RECORD_TYPES[ord(header[2])]
+    revision = int(header[3])
+    generic_parser_map = self.PARSER_MAP
+    if revision < 2 and record_type == 'CAL_SET':
+      generic_parser_map.update(CAL_SET=database_records.LegacyCalibration)
     xml_parsed = ['PC_SOFTWARE_PARAMETER', 'MANUFACTURING_DATA']
     if record_type in generic_parser_map:
       return self.GenericRecordYielder(header, data,
@@ -308,6 +314,20 @@ def ReadRecords(self, record_type):
       records.extend(self.ReadDatabasePage(record_type, x))
     return records
 
+class DexcomG5 (Dexcom):
+  PARSER_MAP = {
+      'USER_EVENT_DATA': database_records.EventRecord,
+      'METER_DATA': database_records.G5MeterRecord,
+      'CAL_SET': database_records.Calibration,
+      'INSERTION_TIME': database_records.G5InsertionRecord,
+      'EGV_DATA': database_records.G5EGVRecord,
+      'SENSOR_DATA': database_records.SensorRecord,
+    }
+
+def GetDevice (port, G5=False):
+  if G5:
+    return DexcomG5(port)
+  return Dexcom(port)
 
 if __name__ == '__main__':
   Dexcom.LocateAndDownload()

etc/udev/rules.d/80-dexcom.rules

@@ -0,0 +1,18 @@
+
+
+
+# udev can only match one entry at a time, but this triggers additional add entries.
+# 22a3:0047
+# 22a3 0047
+ATTRS{idVendor}=="22a3", ATTRS{idProduct}=="0047", \
+  ENV{ID_MM_DEVICE_IGNORE}="1", \
+  MODE="0664", GROUP="plugdev"
+
+
+# create a symlink to the ttyUSB device created automatically above
+#ACTION=="add",                                       \
+#  SUBSYSTEM=="tty", \
+#  ATTRS{idVendor}=="22a3", ATTRS{idProduct}=="0047", \
+#  SYMLINK+="ttyUSB.Dexcom%n"
+
+

setup.py

@@ -10,7 +10,7 @@ def readme():
         return f.read()
 
 setup(name='dexcom_reader',
-    version='0.0.8', # http://semver.org/
+    version='0.1.0-dev', # http://semver.org/
     description='Audit, and inspect data from Dexcom G4.',
     long_description=readme(),
     author="Will Nowak",
@@ -34,6 +34,10 @@ def readme():
     package_data={
       'dexcom_reader': ['etc/udev/rules.d/*']
     },
+    data_files = [
+      ('/etc/udev/rules.d/80-dexcom.rules', ['etc/udev/80-dexcom.rules'] ),
+
+    ],
     zip_safe=False,
     include_package_data=True
 )