zigpy-zboss 2.0.0__tar.gz → 2.0.2__tar.gz

{zigpy_zboss-2.0.0/zigpy_zboss.egg-info → zigpy_zboss-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.0
+Version: 2.0.2
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.2}/zigpy_zboss/__init__.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 2
 MINOR_VERSION = 0
-PATCH_VERSION = 0
+PATCH_VERSION = 2
 
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"

zigpy_zboss-2.0.2/zigpy_zboss/tools/get_nwk_keys.py

@@ -0,0 +1,87 @@
+"""Probe the NCP's network keys.
+
+Reads the active network key(s) from the live stack via GetNwkKeys and, for
+contrast, attempts to read the ZB_NVRAM_COMMON_DATA dataset directly. Use this
+to confirm GetNwkKeys returns a usable key on your hardware - the COMMON_DATA
+NVRAM read is the one that intermittently fails with GENERIC/ERROR and leaves
+zigpy with a blank network key.
+
+Usage:
+    python -m zigpy_zboss.tools.get_nwk_keys [/dev/ttyACM0]
+"""
+import asyncio
+import sys
+
+import serialx
+
+from zigpy_zboss import commands as c
+from zigpy_zboss import types as t
+from zigpy_zboss.api import ZBOSS
+from zigpy_zboss.tools.config import get_config
+
+
+def _is_blank(key) -> bool:
+    """Return True if the key is unset (all 0x00 or all 0xFF) or missing."""
+    return key is None or key.serialize() in (b"\xff" * 16, b"\x00" * 16)
+
+
+async def get_nwk_keys(config):
+    """Print the NCP network keys and contrast with the NVRAM read."""
+    zboss = ZBOSS(config)
+    await zboss.connect()
+    try:
+        rsp = await zboss.request(c.NcpConfig.GetNwkKeys.Req(TSN=1))
+        print(f"GetNwkKeys status: {rsp.StatusCat} {rsp.StatusCode}")
+        for idx, (key, num) in enumerate(
+            (
+                (rsp.NwkKey1, rsp.KeyNumber1),
+                (rsp.NwkKey2, rsp.KeyNumber2),
+                (rsp.NwkKey3, rsp.KeyNumber3),
+            ),
+            start=1,
+        ):
+            tag = "blank" if _is_blank(key) else "REAL"
+            print(f"  NwkKey{idx} (seq {num}): {key}  [{tag}]")
+
+        usable = not _is_blank(rsp.NwkKey1)
+        print(
+            "\nVerdict: GetNwkKeys "
+            + (
+                "returns a usable network key - the fix will work."
+                if usable
+                else "did NOT return a usable key on this firmware."
+            )
+        )
+
+        # Contrast: the COMMON_DATA NVRAM read that intermittently fails.
+        nv = await zboss.request(
+            c.NcpConfig.ReadNVRAM.Req(
+                TSN=2, DatasetId=t.DatasetId.ZB_NVRAM_COMMON_DATA
+            )
+        )
+        print(
+            f"\nZB_NVRAM_COMMON_DATA read status: {nv.StatusCat} "
+            f"{nv.StatusCode}"
+            + ("  (OK)" if nv.StatusCode == 0 else "  (this is the failure)")
+        )
+    finally:
+        zboss.close()
+
+
+async def main(argv):
+    """Get config and print the NCP network keys."""
+    config = get_config(argv)
+
+    try:
+        await get_nwk_keys(config)
+    except serialx.SerialException as exc:
+        print(f"Failed to read NCP network keys! {exc}")
+    except RuntimeError as exc2:
+        print(
+            f"Failed to read NCP network keys! {exc2}\n"
+            "Power cycle the module and try again."
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main(sys.argv[1:]))

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.2}/zigpy_zboss/zigbee/application.py

@@ -87,7 +87,10 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
     async def start_network(self):
         """Start the network."""
-        if self.state.node_info.nwk is None:
+        if (
+            self.state.node_info.nwk in (None, t.NWK(0xFFFE))
+            or self.state.node_info.ieee in (None, t.EUI64.UNKNOWN)
+        ):
             await self.load_network_info()
 
         await self.start_without_formation()
@@ -447,10 +450,6 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
         self.state.network_info.security_level = 0x05
 
-        common = await self._api.nvram.read(
-            t_zboss.DatasetId.ZB_NVRAM_COMMON_DATA,
-            t_zboss.DSCommonData
-        )
         counters = await self._api.nvram.read(
             t_zboss.DatasetId.ZB_IB_COUNTERS,
             t_zboss.DSIbCounters
@@ -461,37 +460,39 @@ class ControllerApplication(zigpy.application.ControllerApplication):
         if counters is not None:
             tx_counter = counters.nib_counter
 
-        if common is not None:
-            self.state.network_info.network_key = zigpy.state.Key(
-                key=common.nwk_key,
-                tx_counter=tx_counter,
-                rx_counter=0,
-                seq=common.nwk_key_seq,
-                partner_ieee=self.state.node_info.ieee,
+        nwk_keys = await self._api.request(
+            c.NcpConfig.GetNwkKeys.Req(TSN=self.get_sequence()))
+        nwk_key = nwk_keys.NwkKey1
+        if (
+            nwk_keys.StatusCode != 0
+            or nwk_key is None
+            or nwk_key.serialize() in (b"\xff" * 16, b"\x00" * 16)
+        ):
+            raise zigpy.exceptions.ControllerException(
+                "NCP reports joined but GetNwkKeys returned no usable network "
+                f"key (status={nwk_keys.StatusCode}, NwkKey1={nwk_key}); "
+                "refusing to load a blank key."
             )
+        self.state.network_info.network_key = zigpy.state.Key(
+            key=nwk_key,
+            tx_counter=tx_counter,
+            rx_counter=0,
+            seq=nwk_keys.KeyNumber1,
+            partner_ieee=self.state.node_info.ieee,
+        )
 
-            if self.state.node_info.logical_type == \
-                    zdo_t.LogicalType.Coordinator:
-                self.state.network_info.tc_link_key = zigpy.state.Key(
-                    key=common.tc_standard_key,
-                    tx_counter=0,
-                    rx_counter=0,
-                    seq=0,
-                    partner_ieee=self.state.node_info.ieee,
-                )
-            else:
-                res = await self._api.request(
-                    c.NcpConfig.GetTrustCenterAddr.Req(
-                        TSN=self.get_sequence()))
-                self.state.network_info.tc_link_key = (
-                    zigpy.state.Key(
-                        key=None,
-                        tx_counter=0,
-                        rx_counter=0,
-                        seq=0,
-                        partner_ieee=res.TCIEEE,
-                    ),
-                )
+        # The coordinator is the trust centre, and ZBOSS always uses the
+        # standard global TC link key (ZigBeeAlliance09) - we never push a
+        # custom one. Set it explicitly rather than reading the flaky
+        # ZB_NVRAM_COMMON_DATA dataset (its only extra contribution was
+        # partner_ieee, which nothing compares against).
+        self.state.network_info.tc_link_key = zigpy.state.Key(
+            key=t.KeyData(zigpy.config.CONF_NWK_TC_LINK_KEY_DEFAULT),
+            tx_counter=0,
+            rx_counter=0,
+            seq=0,
+            partner_ieee=self.state.node_info.ieee,
+        )
 
         res = await self._api.request(
             c.NcpConfig.GetRxOnWhenIdle.Req(TSN=self.get_sequence()))

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.2/zigpy_zboss.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-zboss
-Version: 2.0.0
+Version: 2.0.2
 Summary: A library for zigpy which communicates with Nordic nRF52 radios running ZBOSS NCP
 Author-email: Damien Kastner <damien.kastner@kardia.no>
 License: GPL-3.0

{zigpy_zboss-2.0.0 → zigpy_zboss-2.0.2}/zigpy_zboss.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ zigpy_zboss/tools/__init__.py
 zigpy_zboss/tools/config.py
 zigpy_zboss/tools/factory_reset_ncp.py
 zigpy_zboss/tools/get_ncp_version.py
+zigpy_zboss/tools/get_nwk_keys.py
 zigpy_zboss/tools/log2pcap.py
 zigpy_zboss/types/__init__.py
 zigpy_zboss/types/basic.py