Implement functions for getting/setting device properties

Author: oscar-rc1

zbnt/AxiDevice.py

@@ -19,9 +19,14 @@
 from .Enums import *
 
 class AxiDevice:
-	def __init__(self, dev_id, initial_props):
+	_property_encoding = dict()
+
+	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:
@@ -31,4 +36,36 @@ def __repr__(self):
 		return "zbnt.{0}(dev_id={1}, ports={2})".format(self.__class__.__name__, self.id, str(self.ports))
 
 	def receive_measurement(self, data):
-		pass
+		if self.measurement_handler != None:
+			self.measurement_handler(self.id, data)
+
+	async def set_property(self, prop_id, value):
+		prop_encoding = self._property_encoding.get(prop_id, None)
+
+		if prop_encoding == None:
+			raise Exception("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")
+
+		return await self.client.set_raw_property(self.id, prop_id, encoder(value))
+
+	async def get_property(self, prop_id):
+		prop_encoding = self._property_encoding.get(prop_id, None)
+
+		if prop_encoding == None:
+			raise Exception("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")
+
+		success, value = await self.client.get_raw_property(self.id, prop_id)
+
+		if not success:
+			return (False, None)
+
+		return (success, decoder(value))

zbnt/DiscoveryClient.py

@@ -21,40 +21,62 @@
 import netifaces
 import ipaddress
 
+from .Encoding import *
 from .MessageReceiver import *
 
 class DiscoveryClient(MessageReceiver):
 	MSG_DISCOVERY_PORT = 5466
 
 	def __init__(self, address_list, on_device_discovered):
-		super().__init__(self.send_broadcast, self.message_received, None)
+		super().__init__()
 
 		self.address_list = address_list
 		self.on_device_discovered = on_device_discovered
 
-	def datagram_received(self, data, addr):
-		self.remote_addr = addr
-		super().bytes_received(data)
+	@staticmethod
+	async def create(addr, callback):
+		loop = asyncio.get_running_loop()
 
-		self.status = MsgRxStatus.MSG_RX_MAGIC
-		self.buffer = b"\x00\x00\x00\x00"
+		_, protocol = await loop.create_datagram_endpoint(
+			lambda: DiscoveryClient(addr, callback),
+			remote_addr=None,
+			family=socket.AF_INET,
+			allow_broadcast=True
+		)
+
+		return protocol
+
+	def connection_made(self, transport):
+		super().connection_made(transport)
 
-	def send_broadcast(self):
 		self.validator = random.randint(0, 2**64 - 1)
 
 		message = MessageReceiver.MSG_MAGIC_IDENTIFIER
-		message += Messages.MSG_ID_DISCOVERY.to_bytes(2, byteorder="little")
-		message += b"\x08\x00"
-		message += self.validator.to_bytes(8, byteorder="little")
+		message += encode_u16(Messages.MSG_ID_DISCOVERY)
+		message += encode_u16(8)
+		message += encode_u64(self.validator)
 
 		for address in self.address_list:
 			self.transport.sendto(message, (address, DiscoveryClient.MSG_DISCOVERY_PORT))
 
+	def datagram_received(self, data, addr):
+		self.remote_addr = addr
+		super().bytes_received(data)
+
+		self.status = MsgRxStatus.MSG_RX_MAGIC
+		self.buffer = b"\x00\x00\x00\x00"
+
+	def error_received(self, err):
+		pass
+
+	def connection_lost(self, exc):
+		pass
+
 	def message_received(self, msg_id, msg_payload):
 		if msg_id != Messages.MSG_ID_DISCOVERY or len(msg_payload) <= 67:
 			return
 
-		validator = int.from_bytes(msg_payload[0:8], byteorder='little', signed=False)
+		validator = decode_u64(msg_payload[0:8])
 
 		if validator != self.validator:
 			return
@@ -64,7 +86,7 @@ def message_received(self, msg_id, msg_payload):
 		device["version"] = (
 			msg_payload[11],
 			msg_payload[10],
-			int.from_bytes(msg_payload[8:10], byteorder='little', signed=False),
+			decode_u16(msg_payload[8:10]),
 			msg_payload[12:28].strip(b"\x00").decode("UTF-8"),
 			msg_payload[28:44].strip(b"\x00").decode("UTF-8"),
 			"d" if msg_payload[44] else ""
@@ -101,24 +123,11 @@ def message_received(self, msg_id, msg_payload):
 			return
 
 		device["address"] = address_list
-		device["port"] = int.from_bytes(msg_payload[65:67], byteorder='little', signed=False)
+		device["port"] = decode_u16(msg_payload[65:67])
 		device["name"] = msg_payload[67:].decode("UTF-8")
 
 		self.on_device_discovered(device)
 
-	@staticmethod
-	async def create(addr, callback):
-		loop = asyncio.get_running_loop()
-
-		_, protocol = await loop.create_datagram_endpoint(
-			lambda: DiscoveryClient(addr, callback),
-			remote_addr=None,
-			family=socket.AF_INET,
-			allow_broadcast=True
-		)
-
-		return protocol
-
 async def discover_devices(timeout):
 	address_list = []
 	device_list = []

zbnt/Encoding.py

@@ -0,0 +1,75 @@
+"""
+	zbnt/python-client
+	Copyright (C) 2020 Oscar R.
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+# encode_x : number to bytes
+
+def encode_bool(value):
+	return bool(value).to_bytes(1, byteorder="little", signed=False)
+
+def encode_u8(value):
+	return value.to_bytes(1, byteorder="little", signed=False)
+
+def encode_u16(value):
+	return value.to_bytes(2, byteorder="little", signed=False)
+
+def encode_u32(value):
+	return value.to_bytes(4, byteorder="little", signed=False)
+
+def encode_u64(value):
+	return value.to_bytes(8, byteorder="little", signed=False)
+
+def encode_s8(value):
+	return value.to_bytes(1, byteorder="little", signed=True)
+
+def encode_s16(value):
+	return value.to_bytes(2, byteorder="little", signed=True)
+
+def encode_s32(value):
+	return value.to_bytes(4, byteorder="little", signed=True)
+
+def encode_s64(value):
+	return value.to_bytes(8, byteorder="little", signed=True)
+
+# decode_x : bytes to number
+
+def decode_bool(value):
+	return bool(value[0])
+
+def decode_u8(value):
+	return int.from_bytes(value[:1], byteorder="little", signed=False)
+
+def decode_u16(value):
+	return int.from_bytes(value[:2], byteorder="little", signed=False)
+
+def decode_u32(value):
+	return int.from_bytes(value[:4], byteorder="little", signed=False)
+
+def decode_u64(value):
+	return int.from_bytes(value[:8], byteorder="little", signed=False)
+
+def decode_s8(value):
+	return int.from_bytes(value[:1], byteorder="little", signed=True)
+
+def decode_s16(value):
+	return int.from_bytes(value[:2], byteorder="little", signed=True)
+
+def decode_s32(value):
+	return int.from_bytes(value[:4], byteorder="little", signed=True)
+
+def decode_s64(value):
+	return int.from_bytes(value[:8], byteorder="little", signed=True)