Пример #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 ])
Пример #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]))
Пример #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
Пример #4
0
  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( )
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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)
Пример #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
Пример #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
Пример #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
Пример #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])
Пример #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)
Пример #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
Пример #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
Пример #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)
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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}
Пример #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( )
Пример #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
Пример #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
Пример #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
Пример #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
Пример #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])
Пример #32
0
 def getData(self):
   data = self.data
   log.info("READ contrast:\n%s" % lib.hexdump(data))
   return data
Пример #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 }
Пример #34
0
 def hexdump(self):
     return lib.hexdump(self.data)
Пример #35
0
 def getData(self):
     data = self.data
     log.info("READ contrast:\n%s" % lib.hexdump(data))
     return data
Пример #36
0
 def hexdump (self):
   return lib.hexdump(self.data)
Пример #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
Пример #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
Пример #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
Пример #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())))
Пример #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()
Пример #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
Пример #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