Implement measurement reception, define property encoding functions

Author: oscar-rc1

zbnt/AxiDevice.py

@@ -20,6 +20,7 @@
 
 class AxiDevice:
 	_property_encoding = dict()
+	_property_params = dict()
 
 	def __init__(self, parent, dev_id, initial_props):
 		self.id = dev_id
@@ -39,33 +40,55 @@ def receive_measurement(self, data):
 		if self.measurement_handler != None:
 			self.measurement_handler(self.id, data)
 
-	async def set_property(self, prop_id, value):
+	async def set_property(self, prop_id, value, params=dict()):
 		prop_encoding = self._property_encoding.get(prop_id, None)
+		_, prop_params = self._property_params.get(prop_id, (0, []))
+		value_bytes = b""
 
 		if prop_encoding == None:
-			raise Exception("Property {0} is invalid for {1}".format(prop_id, self.__class__.__name__))
+			raise ValueError("Property {0} is invalid for {1}".format(prop_id, self.__class__.__name__))
 
 		encoder, _ = prop_encoding
 
 		if encoder == None:
-			raise Exception("Property " + str(prop_id) + " is read-only")
+			raise ValueError("Property {0} is read-only".format(prop_id))
 
-		return await self.client.set_raw_property(self.id, prop_id, encoder(value))
+		for param_name, param_encoder in prop_params:
+			param_value = params.get(param_name, None)
 
-	async def get_property(self, prop_id):
+			if param_value == None:
+				raise ValueError("Missing parameter: {0}".format(param_name))
+
+			value_bytes += param_encoder(param_value)
+
+		value_bytes += encoder(value)
+
+		return await self.client.set_raw_property(self.id, prop_id, value_bytes)
+
+	async def get_property(self, prop_id, params=dict()):
 		prop_encoding = self._property_encoding.get(prop_id, None)
+		params_size, prop_params = self._property_params.get(prop_id, (0, []))
+		param_bytes = b""
 
 		if prop_encoding == None:
-			raise Exception("Property {0} is invalid for {1}".format(prop_id, self.__class__.__name__))
+			raise ValueError("Property {0} is invalid for {1}".format(prop_id, self.__class__.__name__))
 
 		_, decoder = prop_encoding
 
 		if decoder == None:
-			raise Exception("Property " + str(prop_id) + " is write-only")
+			raise ValueError("Property {0} is write-only".format(prop_id))
+
+		for param_name, param_encoder in prop_params:
+			param_value = params.get(param_name, None)
+
+			if param_value == None:
+				raise ValueError("Missing parameter: {0}".format(param_name))
+
+			param_bytes += param_encoder(param_value)
 
-		success, value = await self.client.get_raw_property(self.id, prop_id)
+		success, value = await self.client.get_raw_property(self.id, prop_id, param_bytes)
 
 		if not success:
 			return (False, None)
 
-		return (success, decoder(value))
+		return (success, decoder(value[params_size:]))

zbnt/AxiMdio.py

@@ -20,12 +20,9 @@
 from .AxiDevice import *
 
 class AxiMdio(AxiDevice):
-	def __init__(self, dev_id, initial_props):
-		super().__init__(dev_id, initial_props)
+	def __init__(self, parent, dev_id, initial_props):
+		super().__init__(parent, dev_id, initial_props)
 
 		for prop_id, prop_bytes in initial_props:
 			if prop_id == Properties.PROP_PHY_ADDR:
 				self.phys = list(prop_bytes)
-
-	def receive_measurement(self, data):
-		pass

zbnt/Encoding.py

@@ -45,6 +45,15 @@ def encode_s32(value):
 def encode_s64(value):
 	return value.to_bytes(8, byteorder="little", signed=True)
 
+def encode_str(value):
+	return value.encode("UTF-8")
+
+def encode_mac(value):
+	return bytes.fromhex(value.replace(":", "").replace(" ", ""))
+
+def encode_ip4(value):
+	return b"".join(map(lambda x: encode_u8(int(x)), value.split(".")[::-1]))
+
 # decode_x : bytes to number
 
 def decode_bool(value):
@@ -73,3 +82,13 @@ def decode_s32(value):
 
 def decode_s64(value):
 	return int.from_bytes(value[:8], byteorder="little", signed=True)
+
+def decode_str(value):
+	return value.encode("UTF-8")
+
+def decode_mac(value):
+	hex_mac = value.hex().upper()
+	return ":".join([hex_mac[i:i+1] for i in range(0, len(hex_mac), 2)])
+
+def decode_ip4(value):
+	return "{0}.{1}.{2}.{3}".format(value[3], value[2], value[1], value[0])

zbnt/FrameDetector.py

@@ -19,34 +19,78 @@
 from enum import IntFlag
 
 from .Enums import *
+from .Encoding import *
 from .AxiDevice import *
 
 class FrameDetector(AxiDevice):
+	_property_encoding = {
+		Properties.PROP_ENABLE: (encode_bool, decode_bool),
+		Properties.PROP_ENABLE_LOG: (encode_bool, decode_bool),
+		Properties.PROP_ENABLE_SCRIPT: (encode_u32, decode_u32),
+		Properties.PROP_OVERFLOW_COUNT: (None, lambda x: (decode_u64(x[:8]), decode_u64(x[8:16]))),
+		Properties.PROP_FRAME_SCRIPT: (lambda x: x, lambda x: x),
+		Properties.PROP_FRAME_SCRIPT_NAME: (encode_str, decode_str)
+	}
+
+	_property_params = {
+		Properties.PROP_FRAME_SCRIPT: (4, [
+			("index", encode_u32)
+		]),
+
+		Properties.PROP_FRAME_SCRIPT_NAME: (4, [
+			("index", encode_u32)
+		])
+	}
+
 	class FeatureBits(IntFlag):
 		HAS_CMP_UNIT  = 1
 		HAS_EDIT_UNIT = 2
 		HAS_CSUM_UNIT = 4
 		HAS_FPU       = 8
 
-	def __init__(self, dev_id, initial_props):
-		super().__init__(dev_id, initial_props)
+	def __init__(self, parent, dev_id, initial_props):
+		super().__init__(parent, dev_id, initial_props)
 
 		self.features = FrameDetector.FeatureBits(0)
 
 		for prop_id, prop_bytes in initial_props:
 			if prop_id == Properties.PROP_FEATURE_BITS:
 				if len(prop_bytes) >= 4:
-					self.features = FrameDetector.FeatureBits(int.from_bytes(prop_bytes[:4], byteorder="little", signed=False))
+					self.features = FrameDetector.FeatureBits(decode_u32(prop_bytes))
 			elif prop_id == Properties.PROP_NUM_SCRIPTS:
 				if len(prop_bytes) >= 4:
-					self.num_scripts = int.from_bytes(prop_bytes[:4], byteorder="little", signed=False)
+					self.num_scripts = decode_u32(prop_bytes)
 			elif prop_id == Properties.PROP_MAX_SCRIPT_SIZE:
 				if len(prop_bytes) >= 4:
-					self.max_script_size = int.from_bytes(prop_bytes[:4], byteorder="little", signed=False)
+					self.max_script_size = decode_u32(prop_bytes)
 			elif prop_id == Properties.PROP_FIFO_SIZE:
 				if len(prop_bytes) >= 8:
-					self.tx_fifo_size = int.from_bytes(prop_bytes[:4], byteorder="little", signed=False)
-					self.extr_fifo_size = int.from_bytes(prop_bytes[4:8], byteorder="little", signed=False)
+					self.tx_fifo_size = decode_u32(prop_bytes[:4])
+					self.extr_fifo_size = decode_u32(prop_bytes[4:8])
 
 	def receive_measurement(self, data):
-		pass
+		if len(data) < 14:
+			return
+
+		if self.measurement_handler == None:
+			return
+
+		time = decode_u64(data[0:8])
+		match_dir = data[8] - 65
+		log_width = data[9]
+		ext_count = decode_u16(data[10:12])
+		match_mask = decode_u16(data[12:14])
+		ext_offset = ((log_width + 13) // log_width) * log_width
+
+		if match_dir < 0 or match_dir > 1:
+			return
+
+		if ext_count > len(data) - ext_offset:
+			return
+
+		ext_data = data[ext_offset:]
+
+		if ext_count % log_width != 0:
+			ext_data = ext_data[:-log_width] + ext_data[-log_width + ext_count % log_width:]
+
+		self.measurement_handler(self.id, (time, match_dir, match_mask, ext_data))

zbnt/LatencyMeasurer.py

@@ -17,11 +17,52 @@
 """
 
 from .Enums import *
+from .Encoding import *
 from .AxiDevice import *
 
 class LatencyMeasurer(AxiDevice):
-	def __init__(self, dev_id, initial_props):
-		super().__init__(dev_id, initial_props)
+	_property_encoding = {
+		Properties.PROP_ENABLE: (encode_bool, decode_bool),
+		Properties.PROP_ENABLE_LOG: (encode_bool, decode_bool),
+		Properties.PROP_ENABLE_BROADCAST: (encode_bool, decode_bool),
+		Properties.PROP_MAC_ADDR: (encode_mac, decode_mac),
+		Properties.PROP_IP_ADDR: (encode_ip4, decode_ip4),
+		Properties.PROP_FRAME_PADDING: (encode_u16, decode_u16),
+		Properties.PROP_FRAME_GAP: (encode_u32, decode_u32),
+		Properties.PROP_TIMEOUT: (encode_u32, decode_u32),
+		Properties.PROP_OVERFLOW_COUNT: (None, decode_u64)
+	}
+
+	_property_params = {
+		Properties.PROP_MAC_ADDR: (1, [
+			("index", encode_u8)
+		]),
+
+		Properties.PROP_IP_ADDR: (1, [
+			("index", encode_u8)
+		])
+	}
+
+	def __init__(self, parent, dev_id, initial_props):
+		print(self._property_encoding)
+		print(LatencyMeasurer._property_encoding)
+
+		super().__init__(parent, dev_id, initial_props)
 
 	def receive_measurement(self, data):
-		pass
+		if len(data) < 40:
+			return
+
+		if self.measurement_handler == None:
+			return
+
+		time = decode_u64(data[0:8])
+
+		last_ping = decode_u32(data[8:12])
+		last_pong = decode_u32(data[12:16])
+
+		num_ping_pongs = decode_u64(data[16:24])
+		num_lost_pings = decode_u64(data[24:32])
+		num_lost_pongs = decode_u64(data[32:40])
+
+		self.measurement_handler(self.id, (time, last_ping, last_pong, num_ping_pongs, num_lost_pings, num_lost_pongs))

zbnt/MessageReceiver.py

@@ -16,13 +16,12 @@
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-import socket
 import asyncio
-import netifaces
 
 from enum import Enum, auto
 
 from .Enums import *
+from .Encoding import *
 
 class MsgRxStatus(Enum):
 	MSG_RX_MAGIC = auto()
@@ -33,14 +32,7 @@ class MsgRxStatus(Enum):
 class MessageReceiver(asyncio.Protocol):
 	MSG_MAGIC_IDENTIFIER = b"\xFFZB\x02"
 
-	def __init__(self, on_connection_made, on_message, on_error):
-		loop = asyncio.get_running_loop()
-
-		self.on_connection_lost = loop.create_future()
-		self.on_connection_made = on_connection_made
-		self.on_message = on_message
-		self.on_error = on_error
-
+	def __init__(self):
 		self.status = MsgRxStatus.MSG_RX_MAGIC
 		self.buffer = b"\x00\x00\x00\x00"
 		self.count = 0
@@ -50,9 +42,6 @@ def __init__(self, on_connection_made, on_message, on_error):
 	def connection_made(self, transport):
 		self.transport = transport
 
-		if self.on_connection_made != None:
-			self.on_connection_made()
-
 	def bytes_received(self, data):
 		for b in data:
 			b = b.to_bytes(1, "little")
@@ -69,17 +58,15 @@ def bytes_received(self, data):
 				self.buffer += b
 
 				if len(self.buffer) == 4:
-					self.id = int.from_bytes(self.buffer[0:2], byteorder='little', signed=False)
-					self.size = int.from_bytes(self.buffer[2:4], byteorder='little', signed=False)
+					self.id = decode_u16(self.buffer[0:2])
+					self.size = decode_u16(self.buffer[2:4])
 					self.buffer = b""
 
 					if self.id == Messages.MSG_ID_EXTENDED:
 						self.status = MsgRxStatus.MSG_RX_EXTENDED_HEADER
 						self.id = self.size
 					elif self.size == 0:
-						if self.on_message != None:
-							self.on_message(self.id, self.buffer)
-
+						self.message_received(self.id, self.buffer)
 						self.status = MsgRxStatus.MSG_RX_MAGIC
 						self.buffer = b"\x00\x00\x00\x00"
 					else:
@@ -94,30 +81,29 @@ def bytes_received(self, data):
 				self.buffer += b
 
 				if len(self.buffer) == 4:
-					self.size = int.from_bytes(self.buffer, byteorder='little', signed=False)
+					self.size = decode_u32(self.buffer)
 					self.buffer = b""
 
 					if self.size == 0:
 						self.status = MsgRxStatus.MSG_RX_DATA
 					else:
-						if self.on_message != None:
-							self.on_message(self.id, self.buffer)
-
+						self.message_received(self.id, self.buffer)
 						self.status = MsgRxStatus.MSG_RX_MAGIC
 						self.buffer = b"\x00\x00\x00\x00"
 			else:
 				self.buffer += b
 
 				if len(self.buffer) == self.size:
-					if self.on_message != None:
-						self.on_message(self.id, self.buffer)
-
+					self.message_received(self.id, self.buffer)
 					self.status = MsgRxStatus.MSG_RX_MAGIC
 					self.buffer = b"\x00\x00\x00\x00"
 
-	def error_received(self, exc):
-		if self.on_error != None:
-			self.on_error(exc)
+	def message_received(self, msg_id, msg_payload):
+		pass
+
+	def error_received(self, err):
+		raise ConnectionError(err)
 
 	def connection_lost(self, exc):
-		self.on_connection_lost.set_result(True)
+		if exc != None:
+			raise ConnectionError(exc)

zbnt/SimpleTimer.py

@@ -17,11 +17,18 @@
 """
 
 from .Enums import *
+from .Encoding import *
 from .AxiDevice import *
 
 class SimpleTimer(AxiDevice):
-	def __init__(self, dev_id, initial_props):
-		super().__init__(dev_id, initial_props)
+	_property_encoding = {
+		Properties.PROP_ENABLE: (encode_bool, decode_bool),
+		Properties.PROP_TIMER_TIME: (None, decode_u64),
+		Properties.PROP_TIMER_LIMIT: (encode_u64, decode_u64)
+	}
+
+	def __init__(self, parent, dev_id, initial_props):
+		super().__init__(parent, dev_id, initial_props)
 
 		self.freq = 125000000
 
@@ -30,5 +37,5 @@ def __init__(self, dev_id, initial_props):
 				if len(prop_bytes) >= 4:
 					self.freq = int.from_bytes(prop_bytes[:4], byteorder="little", signed=False)
 
-	def receive_measurement(self, data):
-		pass
+	def __repr__(self):
+		return "zbnt.{0}(dev_id={1}, freq={2})".format(self.__class__.__name__, self.id, self.freq)