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
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 ])
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
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
if size == 0:
log.info("\n".join([
"%s:END:no data:INTERFACE STATS" % (log_head),
lib.pformat(self.interface_stats())
]))
def transmit_packet(self, command):
"""
Address a pump with a request.
"""
packet = TransmitPacket(command)
self.command = packet
self.transmit = packet
log.info('transmit_packet:write:%r' % (self.command))
result = self.process()
return result
def open(self):
"""
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
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
if size == 0:
log.info("\n".join([ "%s:END:no data:INTERFACE STATS" % (log_head),
lib.pformat(self.interface_stats( )) ]))
def transmit_packet(self, command):
"""
Address a pump with a request.
"""
packet = TransmitPacket(command)
self.command = packet
self.transmit = packet
log.info('transmit_packet:write:%r' % (self.command))
result = self.process( )
return result
def open(self):
"""
Open and get signal strength so everything is ready to go.
