def update(self):
upd_list = [
] # list of nodes with new laps (node, new_lap_id, lap_timestamp)
cross_list = [] # list of nodes with crossing-flag changes
for index, node in enumerate(self.nodes):
if node.frequency:
readtime = monotonic()
node_data = self.data[index]
if not node_data:
break
data_line = node_data.readline()
if data_line == '':
node_data.seek(0)
data_line = node_data.readline()
data_columns = data_line.split(',')
lap_id = int(data_columns[1])
ms_val = int(data_columns[2])
rssi_val = int(data_columns[3])
node.node_peak_rssi = int(data_columns[4])
node.pass_peak_rssi = int(data_columns[5])
node.loop_time = int(data_columns[6])
cross_flag = True if data_columns[7] == 'T' else False
node.pass_nadir_rssi = int(data_columns[8])
node.node_nadir_rssi = int(data_columns[9])
pn_history = PeakNadirHistory()
pn_history.peakRssi = int(data_columns[10])
pn_history.peakFirstTime = int(data_columns[11])
pn_history.peakLastTime = int(data_columns[12])
pn_history.nadirRssi = int(data_columns[13])
pn_history.nadirTime = int(data_columns[14])
if node.is_valid_rssi(rssi_val):
node.current_rssi = rssi_val
self.process_lap_stats(node, readtime, lap_id, ms_val,
cross_flag, pn_history, cross_list,
upd_list)
else:
self.log(
'RSSI reading ({0}) out of range on Node {1}; rejected'
.format(rssi_val, node.index + 1))
# process any nodes with crossing-flag changes
self.process_crossings(cross_list)
# process any nodes with new laps detected
self.process_updates(upd_list)
def update(self):
upd_list = [
] # list of nodes with new laps (node, new_lap_id, lap_timestamp)
cross_list = [] # list of nodes with crossing-flag changes
for node in self.nodes:
if node.frequency:
if node.api_valid_flag or node.api_level >= 5:
if node.api_level >= 18:
data = self.read_block(node.i2c_addr, READ_LAP_STATS,
19)
elif node.api_level >= 17:
data = self.read_block(node.i2c_addr, READ_LAP_STATS,
28)
elif node.api_level >= 13:
data = self.read_block(node.i2c_addr, READ_LAP_STATS,
20)
else:
data = self.read_block(node.i2c_addr, READ_LAP_STATS,
18)
server_roundtrip = self.i2c_response - self.i2c_request
server_oneway = server_roundtrip / 2
readtime = self.i2c_response - server_oneway
else:
data = self.read_block(node.i2c_addr, READ_LAP_STATS, 17)
if data != None:
lap_id = data[0]
if node.api_level >= 18:
offset_rssi = 3
offset_nodePeakRssi = 4
offset_passPeakRssi = 5
offset_loopTime = 6
offset_crossing = 8
offset_passNadirRssi = 9
offset_nodeNadirRssi = 10
offset_peakRssi = 11
offset_peakFirstTime = 12
offset_peakLastTime = 14
offset_nadirRssi = 16
offset_nadirTime = 17
else:
offset_rssi = 5
offset_nodePeakRssi = 7
offset_passPeakRssi = 9
offset_loopTime = 11
offset_crossing = 15
offset_passNadirRssi = 16
offset_nodeNadirRssi = 18
offset_peakRssi = 20
offset_peakTime = 22
offset_nadirRssi = 24
offset_nadirTime = 26
rssi_val = unpack_rssi(node, data[offset_rssi:])
if node.is_valid_rssi(rssi_val):
node.current_rssi = rssi_val
cross_flag = None
pn_history = None
if node.api_valid_flag: # if newer API functions supported
if node.api_level >= 18:
ms_val = unpack_16(data[1:])
pn_history = PeakNadirHistory()
pn_history.peakRssi = unpack_rssi(
node, data[offset_peakRssi:])
pn_history.peakFirstTime = unpack_16(
data[offset_peakFirstTime:]
) # ms *since* the first peak time
pn_history.peakLastTime = unpack_16(
data[offset_peakLastTime:]
) # ms *since* the last peak time
pn_history.nadirRssi = unpack_rssi(
node, data[offset_nadirRssi:])
pn_history.nadirTime = unpack_16(
data[offset_nadirTime:])
else:
ms_val = unpack_32(data[1:])
node.node_peak_rssi = unpack_rssi(
node, data[offset_nodePeakRssi:])
node.pass_peak_rssi = unpack_rssi(
node, data[offset_passPeakRssi:])
node.loop_time = unpack_16(data[offset_loopTime:])
if data[offset_crossing]:
cross_flag = True
else:
cross_flag = False
node.pass_nadir_rssi = unpack_rssi(
node, data[offset_passNadirRssi:])
if node.api_level >= 13:
node.node_nadir_rssi = unpack_rssi(
node, data[offset_nodeNadirRssi:])
if node.api_level >= 18:
data_logger = self.data_loggers[node.index]
if data_logger:
data_logger.write(
"{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14}\n"
.format(readtime, lap_id, int(ms_val),
node.current_rssi,
node.node_peak_rssi,
node.pass_peak_rssi,
node.loop_time,
'T' if cross_flag else 'F',
node.pass_nadir_rssi,
node.node_nadir_rssi, peakRssi,
peakFirstTime, peakLastTime,
nadirRssi, nadirTime))
else: # if newer API functions not supported
ms_val = unpack_32(data[1:])
node.pass_peak_rssi = unpack_rssi(node, data[11:])
node.loop_time = unpack_32(data[13:])
self.process_lap_stats(node, readtime, lap_id, ms_val,
cross_flag, pn_history,
cross_list, upd_list)
else:
self.log(
'RSSI reading ({0}) out of range on Node {1}; rejected'
.format(rssi_val, node.index + 1))
# process any nodes with crossing-flag changes
self.process_crossings(cross_list)
# process any nodes with new laps detected
self.process_updates(upd_list)