due to zigpy-znp issue on pairing, revert back to solid znp version ( z…

…igpy/zigpy-znp#231 )

Classes/ZigpyTransport/AppBellows.py

@@ -7,8 +7,7 @@
 import logging
 
 import bellows.config as bellows_conf
-import bellows.types as bt
-import zigpy.types as t
+import bellows.types as t
 import bellows.zigbee.application
 import zigpy.config as zigpy_conf
 import zigpy.device
@@ -137,7 +136,7 @@ async def register_endpoints(self, endpoint=1):
     def get_device(self, ieee=None, nwk=None):
         return Classes.ZigpyTransport.AppGeneric.get_device(self, ieee, nwk)
 
-    def handle_join(self, nwk: bt.EmberNodeId, ieee: bt.EmberEUI64, parent_nwk: bt.EmberNodeId, *, handle_rejoin: bool = True,) -> None:
+    def handle_join(self, nwk: t.EmberNodeId, ieee: t.EmberEUI64, parent_nwk: t.EmberNodeId, *, handle_rejoin: bool = True,) -> None:
         return Classes.ZigpyTransport.AppGeneric.handle_join(self, nwk, ieee, parent_nwk)
 
     def get_device_ieee(self, nwk):
@@ -149,9 +148,19 @@ def handle_leave(self, nwk, ieee):
     def get_zigpy_version(self):
         return Classes.ZigpyTransport.AppGeneric.get_zigpy_version(self)
 
-    def packet_received(self, packet: t.ZigbeePacket) -> None:
-        return Classes.ZigpyTransport.AppGeneric.packet_received(self,packet)
-
+    def handle_message(
+        self,
+        sender: zigpy.device.Device,
+        profile: int,
+        cluster: int,
+        src_ep: int,
+        dst_ep: int,
+        message: bytes,
+        * ,
+        dst_addressing=None,
+    )->None:
+        return Classes.ZigpyTransport.AppGeneric.handle_message(self,sender,profile,cluster,src_ep,dst_ep,message, dst_addressing=dst_addressing)
+
     async def set_zigpy_tx_power(self, power):
         # EmberConfigTxPowerMode - EZSP_CONFIG_TX_POWER_MODE in EzspConfigId
         # 0x00: Normal mode

Classes/ZigpyTransport/AppDeconz.py

@@ -142,8 +142,18 @@ def get_device_ieee(self, nwk):
     def handle_leave(self, nwk, ieee):
         Classes.ZigpyTransport.AppGeneric.handle_leave(self, nwk, ieee)
 
-    def packet_received(self, packet: t.ZigbeePacket) -> None:
-        return Classes.ZigpyTransport.AppGeneric.packet_received(self,packet)
+    def handle_message(
+        self,
+        sender: zigpy.device.Device,
+        profile: int,
+        cluster: int,
+        src_ep: int,
+        dst_ep: int,
+        message: bytes,
+        * ,
+        dst_addressing=None,
+    ) -> None:
+        return Classes.ZigpyTransport.AppGeneric.handle_message(self,sender,profile,cluster,src_ep,dst_ep,message,dst_addressing=dst_addressing)                
 
     async def set_zigpy_tx_power(self, power):
         pass

Classes/ZigpyTransport/AppGeneric.py

@@ -34,7 +34,7 @@ async def initialize(self, *, auto_form: bool = False, force_form: bool = False)
     Starts the network on a connected radio, optionally forming one with random
     settings if necessary.
     """
-    self.log.logging("TransportZigpy", "Log", "AppGeneric:initialize auto_form: %s force_form: %s Class: %s" %( auto_form, force_form, type(self)))
+    self.log.logging("TransportZigpy", "Debug", "AppGeneric:initialize auto_form: %s force_form: %s Class: %s" %( auto_form, force_form, type(self)))
 
     _retreived_backup = None
     if "autoRestore" in self.pluginconf.pluginConf and self.pluginconf.pluginConf["autoRestore"]:
@@ -45,7 +45,7 @@ async def initialize(self, *, auto_form: bool = False, force_form: bool = False)
 
         if _retreived_backup:
             if self.pluginconf.pluginConf[ "OverWriteCoordinatorIEEEOnlyOnce"]:
-                LOGGER.debug("Allow eui64 overwrite only once !!!")
+                LOGGER.debug("Allow eui64 overwrite only once !!!") 
                 _retreived_backup.network_info.stack_specific.setdefault("ezsp", {})[ "i_understand_i_can_update_eui64_only_once_and_i_still_want_to_do_it"] = True
 
             LOGGER.debug("Last backup retreived: %s" % _retreived_backup )
@@ -161,7 +161,7 @@ def get_device_ieee(self, nwk):
     return None
 
 def handle_leave(self, nwk, ieee):
-    self.log.logging("TransportZigpy", "Log","handle_leave (0x%04x %s)" %(nwk, ieee))
+    self.log.logging("TransportZigpy", "Debug","handle_leave (0x%04x %s)" %(nwk, ieee))
     plugin_frame = build_plugin_8048_frame_content(self, ieee)
     self.callBackFunction(plugin_frame)
     super(type(self),self).handle_leave(nwk, ieee)
@@ -171,75 +171,86 @@ def get_zigpy_version(self):
     LOGGER.debug("get_zigpy_version ake version number. !!")
     return self.version
 
+def handle_message(
+    self,
+    sender: zigpy.device.Device,
+    profile: int,
+    cluster: int,
+    src_ep: int,
+    dst_ep: int,
+    message: bytes,
+    dst_addressing=None,
+) -> None:
 
-def packet_received(self, packet: t.ZigbeePacket) -> None:
-    """Notify zigpy of a received Zigbee packet.""" 
-    try:
-        sender = self.get_device_with_address(packet.src)
-        self.log.logging("TransportZigpy", "Debug", "packet_received identified device - %s (%s)" %(str(sender), type(sender)) )
-
-    except KeyError:
-        self.log.logging("TransportZigpy", "Debug", "packet_received Unknown device %r" %packet.src)
-        return
-
-    self.log.logging("TransportZigpy", "Debug", "packet_received identified device  %r -> %r with source route %r" %(
-        packet.src.address, packet.dst.address, packet.source_route ))
 
-    profile, cluster, src_ep, dst_ep = packet.profile_id, packet.cluster_id, packet.src_ep, packet.dst_ep
-    message = packet.data.serialize()
-    hex_message = binascii.hexlify(message).decode("utf-8")
-    dst_addressing = packet.dst.addr_mode if packet.dst else None
+    write_capture_rx_frames( self, sender, profile, cluster, src_ep, dst_ep, message, binascii.hexlify(message).decode("utf-8"), dst_addressing)
 
-    write_capture_rx_frames( self, sender, profile, cluster, src_ep, dst_ep, message, hex_message, dst_addressing)
-
-    self.log.logging("TransportZigpy", "Debug", "packet_received - %s %s %s %s %s %s %s %s" %( 
-        sender, profile, cluster, src_ep, dst_ep, message, hex_message, dst_addressing))
-
     if sender.nwk == 0x0000:
-        # When coming from coordinator we have to send it back to zigpy
-        self.log.logging("TransportZigpy", "Debug", "packet_received from Controller Sender: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
-            str(sender.nwk), profile, cluster, src_ep, dst_ep, hex_message))
-        super(type(self),self).packet_received(packet)
+        self.log.logging("TransportZigpy", "Debug", "handle_message from Controller Sender: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
+            str(sender.nwk), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8")))
+        #self.super().handle_message(sender, profile, cluster, src_ep, dst_ep, message)
+        super(type(self),self).handle_message(sender, profile, cluster, src_ep, dst_ep, message)
 
     if cluster == 0x8036:
         # This has been handle via on_zdo_mgmt_permitjoin_rsp()
-        self.log.logging("TransportZigpy", "Debug", "packet_received 0x8036: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
-            str(sender.nwk), profile, cluster, src_ep, dst_ep, hex_message))
-        self.callBackFunction( build_plugin_8014_frame_content(self, str(sender), hex_message ) )
-        super(type(self),self).packet_received(packet)
+        self.log.logging("TransportZigpy", "Debug", "handle_message 0x8036: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
+            str(sender.nwk), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8")))
+        self.callBackFunction( build_plugin_8014_frame_content(self, str(sender), binascii.hexlify(message).decode("utf-8") ) )
+        super(type(self),self).handle_message(sender, profile, cluster, src_ep, dst_ep, message)
         return
 
     if cluster == 0x8034:
         # This has been handle via on_zdo_mgmt_leave_rsp()
-        self.log.logging("TransportZigpy", "Debug", "packet_received 0x8036: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
-            str(sender.nwk), profile, cluster, src_ep, dst_ep, hex_message))
-        self.callBackFunction( build_plugin_8047_frame_content(self, str(sender), hex_message) )
+        self.log.logging("TransportZigpy", "Debug", "handle_message 0x8036: %s Profile: %04x Cluster: %04x srcEp: %02x dstEp: %02x message: %s" %(
+            str(sender.nwk), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8")))
+        self.callBackFunction( build_plugin_8047_frame_content(self, str(sender), binascii.hexlify(message).decode("utf-8")) )
         return
 
     addr = None
     if sender.nwk is not None:
+        addr_mode = 0x02
         addr = sender.nwk.serialize()[::-1].hex()
+        if profile and cluster:
+            self.log.logging(
+                "TransportZigpy",
+                "Debug",
+                "handle_message device 1: %s Profile: %04x Cluster: %04x sEP: %s dEp: %s message: %s lqi: %s" % (
+                    str(sender), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8"), sender.lqi)),
+
     elif sender.ieee is not None:
         addr = "%016x" % t.uint64_t.deserialize(sender.ieee.serialize())[0]
-
-    addr_mode = 0x02 if sender.nwk is not None else 0x03        
-    sender.lqi = sender.lqi or 0x00
+        addr_mode = 0x03
+        if profile and cluster:
+            self.log.logging(
+                "TransportZigpy",
+                "Debug",
+                "handle_message device 1: %s Profile: %04x Cluster: %04x sEP: %s dEp: %s message: %s lqi: %s" % (
+                    str(sender), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8"), sender.lqi)),
+
+    if sender.lqi is None:
+        sender.lqi = 0x00
 
-    # Let's force profile to ZDP if eps == 0x00
     if src_ep == dst_ep == 0x00:
         profile = 0x0000
 
-    if profile is not None and cluster is not None:
-        self.log.logging( "TransportZigpy", "Debug", "packet_received device: %s Profile: %04x Cluster: %04x sEP: %s dEp: %s message: %s lqi: %s" % (
-            str(addr), profile, cluster, src_ep, dst_ep, hex_message, sender.lqi), )
+    if profile and cluster:
+        self.log.logging(
+            "TransportZigpy",
+            "Debug",
+            "handle_message device 2: %s Profile: %04x Cluster: %04x sEP: %s dEp: %s message: %s lqi: %s" % (
+                str(addr), profile, cluster, src_ep, dst_ep, binascii.hexlify(message).decode("utf-8"), sender.lqi),
+        )
 
-    if addr is not None:
+    if addr:
         plugin_frame = build_plugin_8002_frame_content(self, addr, profile, cluster, src_ep, dst_ep, message, sender.lqi, src_addrmode=addr_mode)
-        self.log.logging("TransportZigpy", "Debug", "packet_received Sender: %s frame for plugin: %s" % (addr, plugin_frame))
-        return self.callBackFunction(plugin_frame)
-
-    self.log.logging( "TransportZigpy", "Error", "packet_received - Issue with sender is %s %s" % (
-        sender.nwk, sender.ieee), )
+        self.log.logging("TransportZigpy", "Debug", "handle_message Sender: %s frame for plugin: %s" % (addr, plugin_frame))
+        self.callBackFunction(plugin_frame)
+    else:
+        self.log.logging(
+            "TransportZigpy",
+            "Error",
+            "handle_message - Issue with sender is %s %s" % (sender.nwk, sender.ieee),
+        )
 
     return
 

Classes/ZigpyTransport/AppZnp.py

@@ -13,8 +13,7 @@
 import zigpy.zdo.types as zdo_types
 import zigpy_znp.commands.util
 import zigpy_znp.config as znp_conf
-#import zigpy_znp.types as znp_t
-import zigpy.types as t
+import zigpy_znp.types as t
 import zigpy_znp.zigbee.application
 from Classes.ZigpyTransport.firmwareversionHelper import \
     znp_extract_versioning_for_plugin
@@ -117,8 +116,17 @@ def handle_leave(self, nwk, ieee):
     def get_zigpy_version(self):
         return Classes.ZigpyTransport.AppGeneric.get_zigpy_version(self)
 
-    def packet_received(self, packet: t.ZigbeePacket) -> None:
-        return Classes.ZigpyTransport.AppGeneric.packet_received(self,packet)
+    def handle_message(
+        self,
+        sender: zigpy.device.Device,
+        profile: int,
+        cluster: int,
+        src_ep: int,
+        dst_ep: int,
+        message: bytes,
+        dst_addressing=None,
+    ) -> None:
+        return Classes.ZigpyTransport.AppGeneric.handle_message(self,sender,profile,cluster,src_ep,dst_ep,message, dst_addressing=dst_addressing)
 
     async def set_zigpy_tx_power(self, power):
         self.log.logging("TransportZigpy", "Debug", "set_tx_power %s" %power)

plugin.py

@@ -1502,10 +1502,10 @@ def update_DB_device_status_to_reinit( self ):
 def check_python_modules_version( self ):
 
     MODULES_VERSION = {
-        "zigpy": "0.59.0",
-        "zigpy_znp": "0.11.6",
+        "zigpy": "0.56.1",
+        "zigpy_znp": "0.11.2",
         "zigpy_deconz": "0.21.1",
-        "bellows": "0.36.8",
+        "bellows": "0.35.8",
         }
 
     flag = True

requirements.txt

@@ -1,8 +1,8 @@
-zigpy==0.59.0
+zigpy==0.56.1
 zigpy_deconz==0.21.1
 zigpy-cli==1.0.4
-zigpy_znp==0.11.6
-bellows==0.36.8
+zigpy_znp==0.11.2
+bellows==0.35.8
 dnspython==2.3.0
 pyserial>=3.5
 z4d-certified-devices