Beispiel #1
0
  def pformat(self, prefix=''):
    head = '\n'.join([ "    op hex (%s)" % len(self.head), lib.hexdump(self.head, indent=4),
                       "    decimal", lib.int_dump(self.head, indent=11) ])
    date = '\n'.join([ "    datetime (%s)" % self.date_str( ),
                       lib.hexdump(self.date, indent=4) ])

    body = "    body (%s)" % len(self.body)
    if len(self.body) > 0:
      body = '\n'.join([ body,
                         "    hex", lib.hexdump(self.body, indent=4),
                         "    decimal", lib.int_dump(self.body, indent=11) ])
    extra = [ ]
    hour_bits = self.date[1:] and extra_hour_bits(self.date[1]) or [ ]
    year_bits = self.date[4:] and extra_year_bits(self.date[4]) or [ ]
    day_bits  = self.date[3:] and extra_hour_bits(self.date[3]) or [ ]
    if 1 in hour_bits:
      extra.append("HOUR BITS: {}".format(str(hour_bits)))
    if 1 in day_bits:
      extra.append("DAY BITS: {}".format(str(day_bits)))
    if 1 in year_bits:
      extra.append("YEAR BITS: {}".format(str(year_bits)))
    decoded = self.decode( )
    decode_msg = ''
    if decoded is not None:
      decode_msg = '\n'.join([ '###### DECODED',
                               '```python',
                               '{}'.format(lib.pformat(self.decode( ))),
                               '```', ])
    if extra:
      extra = '    ' + ' '.join(extra)
    else:
      extra = ''
    return '\n'.join([ prefix, decode_msg, head, date, body, extra ])
Beispiel #2
0
 def respond(self, raw):
   if len(raw) == 0:
     log.error("ACK is zero bytes!")
     # return False
     raise AckError("ACK is 0 bytes:\n%s" % lib.hexdump(raw))
   commStatus = raw[0]
   # usable response
   assert commStatus == 1, ('commStatus: %02x expected 0x1' % commStatus)
   status     = raw[1]
   # status == 102 'f' NAK, look up NAK
   if status == 85: # 'U'
     return raw[:3], raw[3:]
   assert False, ("NAK!!\n%s" % lib.hexdump(raw[:3]))
Beispiel #3
0
  def parse(self, raw):
    """
    Detect BadCRC here.  Also, look for eod set.
    """
    """
    log.info('readData validating remote raw[ack]: %02x' % raw[0])
    log.info('readData; foreign raw should be at least 14 bytes? %s %s' % (len(raw), len(raw) > 14))
    log.info('readData; raw[retries] %s' % int(raw[3]))
    dl_status = int(raw[0])
    if dl_status != 0x02: # this differs from the others?
      raise BadDeviceCommError("bad dl raw! %r" % raw)
      assert (int(raw[0]) == 2), repr(raw)
    # raw[1] != 0 # interface number !=0
    # raw[2] == 5 # timeout occurred
    # raw[2] == 2 # NAK
    # raw[2] # should be within 0..4
    log.info("readData ACK")
    lb, hb    = raw[5] & 0x7F, raw[6]
    self.eod  = (raw[5] & 0x80) > 0
    """
    lb, hb    = raw[5] & 0x7F, raw[6]
    self.eod  = (raw[5] & 0x80) > 0
    resLength = lib.BangInt((lb, hb))
    # we don't really care about the length
    #assert resLength < 64, ("cmd low byte count:\n%s" % lib.hexdump(raw))

    data = raw[13:13+resLength]
    self.packet = data
    log.info('%s:eod:found eod (%s)' % (self, self.eod))
    log.info('found packet len(%s), link expects(%s)' % (len(self.packet), resLength))
    assert len(data) == resLength
    head = raw[13:]
    crc = raw[-1]
    # crc check
    if crc == 0 and len(data) > 1:
      log.warn('bad zero CRC?')
    expected_crc = CRC8(data)
    if crc != expected_crc:
      msg = ':'.join( [ 'ReadRadio:BAD ACK:found raw[crc]: %#04x' % (crc),
                          'expected_crc(data): %#04x' % (expected_crc),
                          'raw:\n%s\n' % (lib.hexdump(raw)),
                          'head:\n%s\n' % (lib.hexdump(head)),
                          'data:\n%s\n' % (lib.hexdump(data)) ] )
      log.info(msg)
      log.info("XXX:IGNORE:BadCRC:returning empty message, sleep .100, avoid errors.")
      time.sleep(.100)
      return bytearray( )
      raise BadCRC(msg)
    assert crc == expected_crc
    return data
  def getData(self):
    data = self.data
    log.info("READ pump settings:\n%s" % lib.hexdump(data))
    

    auto_off_duration_hrs = data[0]
    alarm = self.alarm(data[1])
    audio_bolus_enable = data[2] == 1
    audio_bolus_size = 0
    if audio_bolus_enable:
      audio_bolus_size = data[3] / 10.0
    variable_bolus_enable = data[4] == 1  
    #MM23 is different
    maxBolus = data[5]/ 10.0
    # MM512 and up
    maxBasal = lib.BangInt(data[6:8]) / 40
    timeformat = data[8]
    insulinConcentration = {0: 100, 1: 50}[data[9]]
    patterns_enabled = data[10] == 1
    selected_pattern = data[11]
    rf_enable = data[12] == 1
    block_enable = data[13] == 1
    """
    # MM12
    insulin_action_type = data[17] == 0 and 'Fast' or 'Regular'
    """
    #MM15
    insulin_action_type = data[17]
    low_reservoir_warn_type = data[18]
    low_reservoir_warn_point = data[19]
    keypad_lock_status = data[20]

    return locals( )
Beispiel #5
0
 def getData(self):
   data = self.data
   log.info("XXX: READ cur page number:\n%s" % lib.hexdump(data))
   if len(data) == 1:
     return int(data[0])
   result = dict(page= lib.BangLong(data[0:4]), glucose=data[5], isig=data[7])
   return result
Beispiel #6
0
 def parse_time(self):
   mid = unmask_m_midnight(self.date)
   try:
     self.datetime = date = datetime(*mid)
     return date
   except ValueError, e:
     print "ERROR", e, mid, lib.hexdump(self.date)
     pass
Beispiel #7
0
 def getData(self):
   data = self.data
   log.info("READ totals today:\n%s" % lib.hexdump(data))
   totals = {
     'today': lib.BangInt(data[0:2]) / 10.0,
     'yesterday': lib.BangInt(data[2:4]) / 10.0
   }
   return totals
Beispiel #8
0
 def getData(self):
   data = self.data
   ids = [ ]
   ids.append( str(data[0:6]) )
   ids.append( str(data[6:12]) )
   ids.append( str(data[12:18]) )
   log.info("READ radio ACL:\n%s" % lib.hexdump(data))
   return ids
Beispiel #9
0
 def download_page(self, x):
   log.info('comm:XXX:READ HISTORY DATA page number: %r' % (x))
   comm = commands.ReadHistoryData(serial=self.device.serial, params=[ x ] )
   self.device.execute(comm)
   page = comm.getData( )
   comm.save(prefix=self.log_format)
   log.info("XXX: READ HISTORY DATA page number %r!!:\n%s" % (x, lib.hexdump(page)))
   time.sleep(.100)
Beispiel #10
0
def parse_midnight (data):
    mid = unmask_m_midnight(data)
    oneday = relativedelta(days=1)
    try:
      date = datetime(*mid) + oneday
      return date
    except ValueError, e:
      print "ERROR", e, lib.hexdump(data)
      pass
Beispiel #11
0
 def power_control(self, minutes=None):
   log.info('BEGIN POWER CONTROL %s' % self.serial)
   # print "PowerControl SERIAL", self.serial
   response = self.query(commands.PowerControl, minutes=minutes)
   power = self.command
   log.info('manually download PowerControl serial %s' % self.serial)
   data = self.stick.download( )
   log.info("ENDING manual download:\n%s" % lib.hexdump(data))
   return data
Beispiel #12
0
  def clear_buffer(self):
    bad = bytearray( )
    raw = bytearray( )
    for attempt in xrange( 3 ):
      segments = [ ]
      segs_vs_raw = 'segments[{0}],total_segments[{1}]:raw[{2}]'
      seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
      log_detail = segs_vs_raw.format(*seg_stats)
      log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
      log.debug('INTERFACE STATS:\n%s' % lib.pformat(self.interface_stats( )))
      log.info(":".join([ log_head, log_detail, "BEGIN ", "first poll" ]))
      size = self.poll_size( )
      end_poll = ':'.join( [ log_head, log_detail,
                             "END first poll %s" % (size),
                             "SHOULD DOWNLOAD ", str(size != 0) ] )
      log.info(end_poll)
      if size == 0:
        break
      
      seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
      log_detail = segs_vs_raw.format(*seg_stats)
      log.info("%s:download the size? %s:%s" % (log_head, size, log_detail))
          
      while size > 14:
        seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
        log_detail = segs_vs_raw.format(*seg_stats)
        log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
        log.info( ':'.join([ "%s size:%s" % (log_head, size),
                             log_detail,
                             "clear_buffer BUFFER self.download( )" ]))
        try:
          segment = self.download( )
          raw.extend(segment)
          segments.append(segment)
          seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
          log_detail = segs_vs_raw.format(*seg_stats)
          log.info(":".join([ "%s:tx:found" % (log_head),
                              log_detail,
                              'len(raw)', str(len(raw)),
                              'expected', str(size),
                              'len(segment)', str(len(segment)) ]))
        except BadCRC, e:
          seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
          log_detail = segs_vs_raw.format(*seg_stats)
          log.critical('%s:IGNORING:%s:%s' % (log_head, log_detail, e))

        seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
        log_detail = segs_vs_raw.format(*seg_stats)
        log.info(':'.join([ "%s downloaded %s segment" % (log_head, len(raw)),
                            log_detail,
                            "RAW:\n%s" % lib.hexdump(raw) ]))
        size = self.poll_size( )

      log.debug("INTERFACE STATS:\n%s" % lib.pformat(self.interface_stats( )))
      if raw:
        return raw
Beispiel #13
0
 def getData (self):
   # return self.model.decode_carb_ratios(self.data[:])
   units = self.data[0]
   labels = { 1 : 'grams', 2: 'exchanges' }
   fixed = self.data[1]
   data = self.data[1:1+(8 *2)]
   print lib.hexdump(data)
   return dict(schedule=self.decode_ratios(data[1:], units=units), units=labels.get(units), first=self.data[0])
   # xxx: remove
   schedule = [ ]
   for x in range(len(data)/ 2):
     start = x * 2
     end = start + 2
     (i, r) = data[start:end]
     ratio = int(r)
     if units == 2:
       ratio = r / 10.0
     schedule.append(dict(x=x, i=i, offset=i*30, ratio=ratio, r=r))
   return dict(schedule=schedule, units=labels.get(units), first=self.data[0])
Beispiel #14
0
  def download(self):
    """
    Download a single page, copy paste from elsewhere.
    """

    log.info("read HISTORY DATA")
    comm = commands.ReadHistoryData(serial=self.device.serial, page=0)
    self.device.execute(comm)
    log.info('comm:READ history data page!!!:\n%s' % (lib.hexdump(comm.getData( ))))
    comm.save(prefix=self.log_format)
Beispiel #15
0
 def getData(self):
   data = self.data
   log.info("XXX: READ cur page number:\n%s" % lib.hexdump(data))
   if len(data) == 1:
     return int(data[0])
   page = lib.BangLong(data[0:4])
   # https://bitbucket.org/bewest/carelink/src/419fbf23495a/ddmsDTWApplet.src/minimed/ddms/deviceportreader/MMX15.java#cl-157
   if page <= 0 or page > 36:
     page = 36
   return page
Beispiel #16
0
 def respond(self, raw):
   if len(raw) == 0:
     log.error("ReadRadio ACK is zero bytes!")
     # return False
     raise AckError("ACK is 0 bytes: %s" % lib.hexdump(raw))
   log.info('readData validating remote raw[ack]: %02x' % raw[0])
   log.info('readData; foreign raw should be at least 14 bytes? %s %s' % (len(raw), len(raw) > 14))
   log.info('readData; raw[retries] %s' % int(raw[3]))
   dl_status = int(raw[0])
   if dl_status != 0x02: # this differs from the others?
     raise BadDeviceCommError("bad dl raw! %r" % raw)
     assert (int(raw[0]) == 2), repr(raw)
   return raw[:1], raw
Beispiel #17
0
def get_pages(device):
  log.info("read cur page number")
  comm = ReadCurPageNumber(serial=device.serial )
  device.execute(comm)
  pages = comm.getData( )
  log.info('attempting to read %s pages of history' % pages)

  for x in range(pages + 1):
    log.info('comm:READ HISTORY DATA page number: %r' % (x))
    comm = ReadHistoryData(serial=device.serial, params=[ x ] )
    device.execute(comm)
    page = comm.getData( )
    log.info("XXX: READ HISTORY DATA!!:\n%s" % lib.hexdump(page))
    time.sleep(.100)
Beispiel #18
0
 def getData(self):
   data = self.data
   log.info("XXX: READ cur page number:\n%s" % lib.hexdump(data))
   # MM12 does not support this command, but has 31 pages
   # Thanks to @amazaheri
   page = 32
   if len(data) == 1:
     return int(data[0])
   if len(data) > 3:
     page = lib.BangLong(data[0:4])
   # https://bitbucket.org/bewest/carelink/src/419fbf23495a/ddmsDTWApplet.src/minimed/ddms/deviceportreader/MMX15.java#cl-157
   if page <= 0 or page > 36:
     page = 36
   return page
Beispiel #19
0
 def getData(self):
   data = self.data
   temp = { 0: 'absolute', 1: 'percent' }[self.data[0]]
   status = dict(temp=temp)
   if temp is 'absolute':
     rate = lib.BangInt(data[2:4])/40.0
     duration = lib.BangInt(data[4:6])
     status.update(rate=rate, duration=duration)
   if temp is 'percent':
     rate = int(data[1])
     duration = lib.BangInt(data[4:6])
     status.update(rate=rate, duration=duration)
   log.info("READ temporary basal:\n%s" % lib.hexdump(data))
   return status
Beispiel #20
0
  def getData(self):
    data = self.data
    log.info("READ pump settings:\n%s" % lib.hexdump(data))

    if len(data) < 2:
      log.info("pump settings: unsupported version, sorry")
      return data

    auto_off_duration_hrs = data[0]
    alarm = self.alarm(data[1])
    audio_bolus_enable = data[2] == 1
    audio_bolus_size = 0
    if audio_bolus_enable:
      audio_bolus_size = data[3] / 10.0
    variable_bolus_enable = data[4] == 1
    #MM23 is different
    maxBolus = data[5]/ 10.0
    # MM512 and up
    maxBasal = lib.BangInt(data[6:8]) / 40.0
    timeformat = data[8]
    insulinConcentration = {0: 100, 1: 50}[data[9]]
    patterns_enabled = data[10] == 1
    selected_pattern = data[11]
    rf_enable = data[12] == 1
    block_enable = data[13] == 1
    temp_basal = self.temp_basal_type(data[14:16])
    paradigm_enabled = data[16]
    """
    # MM12
    insulin_action_type = data[17] == 0 and 'Fast' or 'Regular'
    """
    #MM15
    # insulin_action_type = data[17]
    insulin_action_curve = data[17]
    low_reservoir_warn_type = data[18]
    low_reservoir_warn_point = data[19]
    keypad_lock_status = data[20]

    values = locals( )
    # safety
    values.pop('self')
    values.pop('data')

    return values
Beispiel #21
0
 def readlines( self ):
   r = self.serial.readlines( )
   io.info( 'usb.read.len: %s\n%s' % ( len( r ),
                                       lib.hexdump( bytearray( ''.join( r ) ) ) ) )
   return r
Beispiel #22
0
 def read( self, c ):
   r = self.serial.read( c )
   io.info( 'usb.read.len: %s'   % ( len( r ) ) )
   io.info( 'usb.read.raw:\n%s' % ( lib.hexdump( bytearray( r ) ) ) )
   return r
Beispiel #23
0
 def write( self, string ):
   r = self.serial.write( string )
   io.info( 'usb.write.len: %s\n%s' % ( len( string ),
                                        lib.hexdump( bytearray( string ) ) ) )
   return r
Beispiel #24
0
 def getData(self):
     data = self.data
     log.info("READ remaining insulin:\n%s" % lib.hexdump(data))
     return lib.BangInt(data[0:2]) / 10.0
Beispiel #25
0
 def getData(self):
     data = self.data
     rate = lib.BangInt(data[2:4]) / 40.0
     duration = lib.BangInt(data[4:6])
     log.info("READ temporary basal:\n%s" % lib.hexdump(data))
     return {'rate': rate, 'duration': duration}
Beispiel #26
0
 def getData(self):
   data = self.data
   log.debug("READ FIRMWARE HEX:\n%s" % lib.hexdump(data))
   return str(data.split( chr(0x0b) )[0]).strip( )
Beispiel #27
0
    log.info('get signal strength of %s' % stick)
    signal = 0
    while signal < 50:
        signal = stick.signal_strength()
    log.info('we seem to have found a nice signal strength of: %s' % signal)
    log.info("""
    at this point, we could issue remote commands to a medical
    device, let's inspect the interfaces""".strip())
    #log.info(pformat(stick.usb_stats( )))
    #log.info(pformat(stick.radio_stats( )))
    log.info(pformat(stick.interface_stats()))
    """
  size = stick.poll_size( )
  log.info("can we poll the size? %s" % (size))
  if size > 14:
    log.info("DOWNLOADING %s TO CLEAR BUFFER" % size)
    log.info('\n'.join(["can we download ?", lib.hexdump(stick.download( ))]))
  """
    log.info("CLEAR BUFFERS")
    extra = stick.clear_buffer()
    if extra:
        log.info(lib.hexdump(extra))
    else:
        log.info("NO PENDING BUFFER")
    log.info("DONE CLEARING BUFFERS")
    log.info("INTERFACE STATS:\n%s" % pformat(stick.interface_stats()))
    log.info("howdy! all done looking at the stick")

#####
# EOF
Beispiel #28
0
  log.info('get signal strength of %s' % stick)
  signal = 0
  while signal < 50:
    signal = stick.signal_strength( )
  log.info('we seem to have found a nice signal strength of: %s' % signal)
  log.info("""
    at this point, we could issue remote commands to a medical
    device, let's inspect the interfaces""".strip( ))
  #log.info(pformat(stick.usb_stats( )))
  #log.info(pformat(stick.radio_stats( )))
  log.info(pformat(stick.interface_stats( )))
  """
  size = stick.poll_size( )
  log.info("can we poll the size? %s" % (size))
  if size > 14:
    log.info("DOWNLOADING %s TO CLEAR BUFFER" % size)
    log.info('\n'.join(["can we download ?", lib.hexdump(stick.download( ))]))
  """
  log.info("CLEAR BUFFERS")
  extra = stick.clear_buffer( )
  if extra:
    log.info(lib.hexdump(extra))
  else:
    log.info("NO PENDING BUFFER")
  log.info("DONE CLEARING BUFFERS")
  log.info("INTERFACE STATS:\n%s" % pformat(stick.interface_stats( )))
  log.info("howdy! all done looking at the stick")

#####
# EOF
Beispiel #29
0
    def clear_buffer(self):
        """
    An alternative download solution.  This can be helpful in
    scenarios where a prior run seems crashed your process, but the
    radio is still transmitting and receiving data.  Running this
    method collects data from the radio until it's done receiving,
    more or less, at which point you should be free to try again.
    """
        bad = bytearray()
        raw = bytearray()
        for attempt in xrange(3):
            segments = []
            segs_vs_raw = 'segments[{0}],total_segments[{1}]:raw[{2}]'
            seg_stats = (len(segments), sum(map(len, segments)), len(raw))
            log_detail = segs_vs_raw.format(*seg_stats)
            log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
            log.debug('INTERFACE STATS:\n%s' %
                      lib.pformat(self.interface_stats()))
            log.info(":".join([log_head, log_detail, "BEGIN ", "first poll"]))
            size = self.poll_size()
            end_poll = ':'.join([
                log_head, log_detail,
                "END first poll %s" % (size), "SHOULD DOWNLOAD ",
                str(size != 0)
            ])
            log.info(end_poll)
            if size == 0:
                break

            seg_stats = (len(segments), sum(map(len, segments)), len(raw))
            log_detail = segs_vs_raw.format(*seg_stats)
            log.info("%s:download the size? %s:%s" %
                     (log_head, size, log_detail))

            while size > 14:
                seg_stats = (len(segments), sum(map(len, segments)), len(raw))
                log_detail = segs_vs_raw.format(*seg_stats)
                log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
                log.info(':'.join([
                    "%s size:%s" % (log_head, size), log_detail,
                    "clear_buffer BUFFER self.download( )"
                ]))
                try:
                    segment = self.download()
                    raw.extend(segment)
                    segments.append(segment)
                    seg_stats = (len(segments), sum(map(len,
                                                        segments)), len(raw))
                    log_detail = segs_vs_raw.format(*seg_stats)
                    log.info(":".join([
                        "%s:tx:found" % (log_head), log_detail, 'len(raw)',
                        str(len(raw)), 'expected',
                        str(size), 'len(segment)',
                        str(len(segment))
                    ]))
                except BadCRC, e:
                    seg_stats = (len(segments), sum(map(len,
                                                        segments)), len(raw))
                    log_detail = segs_vs_raw.format(*seg_stats)
                    log.critical('%s:IGNORING:%s:%s' %
                                 (log_head, log_detail, e))

                seg_stats = (len(segments), sum(map(len, segments)), len(raw))
                log_detail = segs_vs_raw.format(*seg_stats)
                log.info(':'.join([
                    "%s downloaded %s segment" % (log_head, len(raw)),
                    log_detail,
                    "RAW:\n%s" % lib.hexdump(raw)
                ]))
                size = self.poll_size()

            log.debug("INTERFACE STATS:\n%s" %
                      lib.pformat(self.interface_stats()))
            if raw:
                return raw
Beispiel #30
0
 def readlines( self ):
   r = self.serial.readlines( )
   io.info( 'usb.read.len: %s\n%s' % ( len( r ),
                                       lib.hexdump( bytearray( ''.join( r ) ) ) ) )
   return r
Beispiel #31
0
 def getData(self):
     data = self.data
     log.info("XXX: READ cur page number:\n%s" % lib.hexdump(data))
     if len(data) == 1:
         return int(data[0])
     return lib.BangLong(data[0:4])
Beispiel #32
0
 def getData(self):
   data = self.data
   log.info("READ contrast:\n%s" % lib.hexdump(data))
   return data
Beispiel #33
0
 def getData(self):
   data = self.data
   rate = lib.BangInt(data[2:4])/40.0
   duration = lib.BangInt(data[4:6])
   log.info("READ temporary basal:\n%s" % lib.hexdump(data))
   return { 'rate': rate, 'duration': duration }
Beispiel #34
0
 def hexdump(self):
     return lib.hexdump(self.data)
Beispiel #35
0
 def getData(self):
     data = self.data
     log.info("READ contrast:\n%s" % lib.hexdump(data))
     return data
Beispiel #36
0
 def hexdump (self):
   return lib.hexdump(self.data)
Beispiel #37
0
 def read( self, c ):
   r = self.serial.read( c )
   io.info( 'usb.read.len: %s'   % ( len( r ) ) )
   io.info( 'usb.read.raw:\n%s' % ( lib.hexdump( bytearray( r ) ) ) )
   return r
Beispiel #38
0
 def getData(self):
   data = self.data
   log.info("READ remaining insulin:\n%s" % lib.hexdump(data))
   return lib.BangInt(data[self.startByte:self.endByte])/self.basalStrokes
Beispiel #39
0
  def clear_buffer(self):
    """
    An alternative download solution.  This can be helpful in
    scenarios where a prior run seems crashed your process, but the
    radio is still transmitting and receiving data.  Running this
    method collects data from the radio until it's done receiving,
    more or less, at which point you should be free to try again.
    """
    bad = bytearray( )
    raw = bytearray( )
    for attempt in xrange( 3 ):
      segments = [ ]
      segs_vs_raw = 'segments[{0}],total_segments[{1}]:raw[{2}]'
      seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
      log_detail = segs_vs_raw.format(*seg_stats)
      log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
      log.debug('INTERFACE STATS:\n%s' % lib.pformat(self.interface_stats( )))
      log.info(":".join([ log_head, log_detail, "BEGIN ", "first poll" ]))
      size = self.poll_size( )
      end_poll = ':'.join( [ log_head, log_detail,
                             "END first poll %s" % (size),
                             "SHOULD DOWNLOAD ", str(size != 0) ] )
      log.info(end_poll)
      if size == 0:
        break
      
      seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
      log_detail = segs_vs_raw.format(*seg_stats)
      log.info("%s:download the size? %s:%s" % (log_head, size, log_detail))
          
      while size > 14:
        seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
        log_detail = segs_vs_raw.format(*seg_stats)
        log_head = "XXX:clear_buffer[attempt][%s]" % (attempt)
        log.info( ':'.join([ "%s size:%s" % (log_head, size),
                             log_detail,
                             "clear_buffer BUFFER self.download( )" ]))
        try:
          segment = self.download( )
          raw.extend(segment)
          segments.append(segment)
          seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
          log_detail = segs_vs_raw.format(*seg_stats)
          log.info(":".join([ "%s:tx:found" % (log_head),
                              log_detail,
                              'len(raw)', str(len(raw)),
                              'expected', str(size),
                              'len(segment)', str(len(segment)) ]))
        except BadCRC, e:
          seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
          log_detail = segs_vs_raw.format(*seg_stats)
          log.critical('%s:IGNORING:%s:%s' % (log_head, log_detail, e))

        seg_stats = ( len(segments), sum(map(len, segments)), len(raw) )
        log_detail = segs_vs_raw.format(*seg_stats)
        log.info(':'.join([ "%s downloaded %s segment" % (log_head, len(raw)),
                            log_detail,
                            "RAW:\n%s" % lib.hexdump(raw) ]))
        size = self.poll_size( )

      log.debug("INTERFACE STATS:\n%s" % lib.pformat(self.interface_stats( )))
      if raw:
        return raw
Beispiel #40
0
 def read_history_0(self):
     log.info("read HISTORY DATA")
     comm = commands.ReadHistoryData(serial=self.serial, page=0)
     self.execute(comm)
     log.info('comm:READ history data page!!!:\n%s' %
              (lib.hexdump(comm.getData())))
Beispiel #41
0
 def getData(self):
     data = self.data
     log.debug("READ FIRMWARE HEX:\n%s" % lib.hexdump(data))
     return str(data.split(chr(0x0b))[0]).strip()
Beispiel #42
0
 def readlines(self):
     r = super(type(self), self).readlines()
     self.log.info('read: %s\n%s' %
                   (len(r), lib.hexdump(bytearray(''.join(r)))))
     return r
Beispiel #43
0
 def write( self, string ):
   r = self.serial.write( string )
   io.info( 'usb.write.len: %s\n%s' % ( len( string ),
                                        lib.hexdump( bytearray( string ) ) ) )
   return r