Restructure measurement handling logic

Author: oscar-rc1

examples/frame_detector.py

@@ -18,16 +18,16 @@
 """
 
 import asyncio
-from zbnt import ZbntClient, TrafficGenerator, Devices, Properties, discover_devices
+from zbnt import ZbntClient, FrameDetector, TrafficGenerator, Devices, Properties, discover_devices
 
 output_file = open("results.csv", "w")
 
-def write_fd_measurement(dev_id, measurement_data):
-	measurement_data = list(measurement_data)
-	measurement_data[-1] = measurement_data[-1].hex()
+def handle_measurement(device, measurement):
+	if isinstance(device, FrameDetector) and device.ports == [2, 3]:
+		measurement.payload = measurement.payload.hex()
 
-	output_file.write(",".join(map(str, measurement_data)))
-	output_file.write("\n")
+		output_file.write(",".join(map(str, measurement.__dict__.values())))
+		output_file.write("\n")
 
 async def main():
 	# Scan for devices, ask the user to select one if multiple devices are found
@@ -85,7 +85,7 @@ async def main():
 
 	# Set function to be called every time the server sends measurement data
 
-	fd0.measurement_handler = write_fd_measurement
+	client.set_callback(handle_measurement)
 
 	# Tell the server to start the run, this will initialize the DMA core
 

examples/traffic_generator.py

@@ -18,15 +18,16 @@
 """
 
 import asyncio
-from zbnt import ZbntClient, TrafficGenerator, Devices, Properties, discover_devices
+from zbnt import ZbntClient, TrafficGenerator, StatsCollector, Devices, Properties, discover_devices
 
 output_file = open("results.csv", "w")
 
-def write_sc_measurement(dev_id, measurement_data):
-	output_file.write(",".join(map(str, measurement_data)))
-	output_file.write("\n")
+def handle_measurement(device, measurement):
+	if isinstance(device, StatsCollector) and device.ports == [0]:
+		output_file.write(",".join(map(str, measurement.__dict__.values())))
+		output_file.write("\n")
 
-	print("\rTX: {0} bytes".format(measurement_data[1]), end="")
+		print("\rTX: {0} bytes".format(measurement.tx_bytes), end="")
 
 async def main():
 	# Scan for devices, ask the user to select one if multiple devices are found
@@ -82,7 +83,7 @@ async def main():
 
 	# Set function to be called every time the server sends measurement data
 
-	sc0.measurement_handler = write_sc_measurement
+	client.set_callback(handle_measurement)
 
 	# Tell the server to start the run, this will initialize the DMA core
 

zbnt/AxiDevice.py

@@ -27,19 +27,17 @@ def __init__(self, parent, dev_id, initial_props):
 		self.id = dev_id
 		self.ports = []
 		self.client = parent
-		self.measurement_handler = None
 		self.valid_properties = list(self._property_encoding)
 
 		for prop_id, prop_bytes in initial_props:
 			if prop_id == Properties.PROP_PORTS:
 				self.ports = list(prop_bytes)
 
 	def __repr__(self):
-		return "zbnt.{0}(dev_id={1}, ports={2})".format(self.__class__.__name__, self.id, str(self.ports))
+		return f"{self.__class__.__name__}(id={self.id}, ports={self.ports})"
 
 	def receive_measurement(self, data):
-		if self.measurement_handler != None:
-			self.measurement_handler(self.id, data)
+		return None
 
 	async def set_property(self, prop_id, value, params=dict()):
 		prop_encoding = self._property_encoding.get(prop_id, None)

zbnt/FrameDetector.py

@@ -70,6 +70,18 @@ class FeatureBits(IntFlag):
 		HAS_CSUM_UNIT = 4
 		HAS_FPU       = 8
 
+	class Frame:
+		def __init__(self, time, number, direction, error, match, payload):
+			self.time = time
+			self.number = number
+			self.direction = direction
+			self.error = error
+			self.match = match
+			self.payload = payload
+
+		def __repr__(self):
+			return f"FrameDetector.Frame(number={self.number}, time={self.time}, direction={self.direction}, match={self.match}, error={self.error}, captured_size={len(self.payload)})"
+
 	def __init__(self, parent, dev_id, initial_props):
 		super().__init__(parent, dev_id, initial_props)
 
@@ -92,25 +104,19 @@ def __init__(self, parent, dev_id, initial_props):
 
 	def receive_measurement(self, data):
 		if len(data) < 15:
-			return
-
-		if self.measurement_handler == None:
-			return
+			return None
 
 		time = decode_u64(data[0:8])
 		number = decode_u32(data[8:12])
-		match_dir = data[12] - 64
+		direction = data[12] & 1
+		error = data[12] >> 1
 		log_width = data[13]
 		match_mask = data[14]
 
 		ext_offset = ((log_width + 23) // log_width) * log_width - 8
-
-		if match_dir < 0 or match_dir > 1:
-			return
-
 		ext_data = data[ext_offset:]
 
-		self.measurement_handler(self.id, (time, number, match_dir, match_mask, ext_data))
+		return FrameDetector.Frame(time, number, direction, error, match_mask, ext_data)
 
 	def load_script(self, path):
 		comparator_instr = [(0, 0)] * self.max_script_size

zbnt/LatencyMeasurer.py

@@ -45,15 +45,24 @@ class LatencyMeasurer(AxiDevice):
 		])
 	}
 
+	class Measurement:
+		def __init__(self, time, number, ping, pong, lost_pings, lost_pongs):
+			self.time = time
+			self.number = number
+			self.ping = ping
+			self.pong = pong
+			self.lost_pings = lost_pings
+			self.lost_pongs = lost_pongs
+
+		def __repr__(self):
+			return f"LatencyMeasurer.Measurement(time={self.time}, number={self.number}, latency=({self.ping}, {self.pong}), lost=({self.lost_pings}, {self.lost_pongs}))"
+
 	def __init__(self, parent, dev_id, initial_props):
 		super().__init__(parent, dev_id, initial_props)
 
 	def receive_measurement(self, data):
 		if len(data) < 40:
-			return
-
-		if self.measurement_handler == None:
-			return
+			return None
 
 		time = decode_u64(data[0:8])
 
@@ -64,4 +73,4 @@ def receive_measurement(self, data):
 		num_lost_pings = decode_u64(data[24:32])
 		num_lost_pongs = decode_u64(data[32:40])
 
-		self.measurement_handler(self.id, (time, num_pings, ping_time, pong_time, num_lost_pings, num_lost_pongs))
+		return LatencyMeasurer.Measurement(time, num_pings, ping_time, pong_time, num_lost_pings, num_lost_pongs)

zbnt/SimpleTimer.py

@@ -40,4 +40,4 @@ def __init__(self, parent, dev_id, initial_props):
 					self.freq = int.from_bytes(prop_bytes[:4], byteorder="little", signed=False)
 
 	def __repr__(self):
-		return "zbnt.{0}(dev_id={1}, freq={2})".format(self.__class__.__name__, self.id, self.freq)
+		return f"SimpleTimer(id={self.id}, freq={self.freq})"

zbnt/StatsCollector.py

@@ -30,15 +30,25 @@ class StatsCollector(AxiDevice):
 		Properties.PROP_OVERFLOW_COUNT: (None, decode_u64)
 	}
 
+	class Statistics:
+		def __init__(self, time, tx_bytes, tx_good, tx_bad, rx_bytes, rx_good, rx_bad):
+			self.time = time
+			self.tx_bytes = tx_bytes
+			self.tx_good = tx_good
+			self.tx_bad = tx_bad
+			self.rx_bytes = rx_bytes
+			self.rx_good = rx_good
+			self.rx_bad = rx_bad
+
+		def __repr__(self):
+			return f"StatsCollector.Statistics(time={self.time}, tx=({self.tx_bytes}, {self.tx_good}, {self.tx_bad}), rx=({self.rx_bytes}, {self.rx_good}, {self.rx_bad}))"
+
 	def __init__(self, parent, dev_id, initial_props):
 		super().__init__(parent, dev_id, initial_props)
 
 	def receive_measurement(self, data):
 		if len(data) < 56:
-			return
-
-		if self.measurement_handler == None:
-			return
+			return None
 
 		time = decode_u64(data[0:8])
 
@@ -50,4 +60,4 @@ def receive_measurement(self, data):
 		rx_good = decode_u64(data[40:48])
 		rx_bad = decode_u64(data[48:56])
 
-		self.measurement_handler(self.id, (time, tx_bytes, tx_good, tx_bad, rx_bytes, rx_good, rx_bad))
+		return StatsCollector.Statistics(time, tx_bytes, tx_good, tx_bad, rx_bytes, rx_good, rx_bad)

zbnt/ZbntClient.py

@@ -42,7 +42,7 @@ def __init__(self):
 		self.connected = False
 		self.disconnecting = False
 		self.devices = dict()
-
+		self.callback = None
 		self.pending_msg = None
 
 	@staticmethod
@@ -94,6 +94,9 @@ def disconnect(self):
 		self.disconnecting = True
 		self.transport.close()
 
+	def set_callback(self, callback):
+		self.callback = callback
+
 	def send_message(self, msg_id, payload):
 		self.transport.write(MessageReceiver.MSG_MAGIC_IDENTIFIER)
 		self.transport.write(encode_u16(msg_id))
@@ -310,5 +313,8 @@ def message_received(self, msg_id, msg_payload):
 			dev_id = msg_id & ~Messages.MSG_ID_MEASUREMENT
 			dev_obj = self.devices.get(dev_id, None)
 
-			if dev_id != None and len(msg_payload) >= 8:
-				dev_obj.receive_measurement(msg_payload)
+			if dev_id != None and len(msg_payload) >= 8 and self.callback != None:
+				meas_obj = dev_obj.receive_measurement(msg_payload)
+
+				if meas_obj != None:
+					self.callback(dev_obj, meas_obj)