meshcore 2.1.17__py3-none-any.whl → 2.2.2__py3-none-any.whl

meshcore/commands/__init__.py

@@ -7,10 +7,15 @@ from .binary import BinaryCommandHandler
 from .contact import ContactCommands
 from .device import DeviceCommands
 from .messaging import MessagingCommands
+from .control_data import ControlDataCommandHandler
 
 
 class CommandHandler(
-    DeviceCommands, ContactCommands, MessagingCommands, BinaryCommandHandler
+    DeviceCommands,
+    ContactCommands,
+    MessagingCommands,
+    BinaryCommandHandler,
+    ControlDataCommandHandler
 ):
     pass
 

meshcore/commands/base.py

@@ -32,10 +32,14 @@ def _validate_destination(dst: DestinationType, prefix_length: int = 6) -> bytes
     """
     if isinstance(dst, bytes):
         # Already bytes, use directly
+        if len(dst)<prefix_length:
+            raise ValueError(f"Invalid prefix len, expecting {prefix_length}, got {len(dst)}")
         return dst[:prefix_length]
     elif isinstance(dst, str):
         # Hex string, convert to bytes
         try:
+            if len(dst)<2*prefix_length:
+                raise ValueError(f"Invalid prefix len, expecting {prefix_length}, got {len(dst)/2}")
             return bytes.fromhex(dst)[:prefix_length]
         except ValueError:
             raise ValueError(f"Invalid public key hex string: {dst}")
@@ -163,7 +167,7 @@ class CommandHandlerBase:
         return Event(EventType.OK, {})
 
     # attached at base because its a common method
-    async def send_binary_req(self, dst: DestinationType, request_type: BinaryReqType, data: Optional[bytes] = None, timeout=None, min_timeout=0) -> Event:
+    async def send_binary_req(self, dst: DestinationType, request_type: BinaryReqType, data: Optional[bytes] = None, context={}, timeout=None, min_timeout=0) -> Event:
         dst_bytes = _validate_destination(dst, prefix_length=32)
         pubkey_prefix = _validate_destination(dst, prefix_length=6)
         logger.debug(f"Binary request to {dst_bytes.hex()}")
@@ -180,6 +184,6 @@ class CommandHandlerBase:
             # Use provided timeout or fallback to suggested timeout (with 5s default)
             actual_timeout = timeout if timeout is not None and timeout > 0 else result.payload.get("suggested_timeout", 4000) / 800.0
             actual_timeout = min_timeout if actual_timeout < min_timeout else actual_timeout
-            self._reader.register_binary_request(pubkey_prefix.hex(), exp_tag, request_type, actual_timeout)
+            self._reader.register_binary_request(pubkey_prefix.hex(), exp_tag, request_type, actual_timeout, context=context)
 
         return result

meshcore/commands/binary.py

@@ -1,4 +1,6 @@
+import asyncio
 import logging
+import random
 
 from .base import CommandHandlerBase
 from ..events import EventType
@@ -131,3 +133,112 @@ class BinaryCommandHandler(CommandHandlerBase):
         )
         
         return acl_event.payload["acl_data"] if acl_event else None
+
+    async def req_neighbours_async(self,
+        contact,
+        count=255,
+        offset=0,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+        req = (b"\x00" # version : 0
+            + count.to_bytes(1, "little", signed=False)
+            + offset.to_bytes(2, "little", signed=False)
+            + order_by.to_bytes(1, "little", signed=False)
+            + pubkey_prefix_length.to_bytes(1, "little", signed=False)
+            + random.randint(1, 0xFFFFFFFF).to_bytes(4, "little", signed=False)
+        )
+
+        logger.debug(f"Sending binary neighbours req, count: {count}, offset: {offset} {req.hex()}")
+
+        return await self.send_binary_req (
+            contact,
+            BinaryReqType.NEIGHBOURS,
+            data=req,
+            timeout=timeout,
+            context={"pubkey_prefix_length": pubkey_prefix_length}
+        )
+
+    async def req_neighbours_sync(self,
+        contact,
+        count=255,
+        offset=0,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+
+        res = await self.req_neighbours_async(contact,
+                count=count,
+                offset=offset,
+                order_by=order_by,
+                pubkey_prefix_length=pubkey_prefix_length,
+                timeout=timeout,
+                min_timeout=min_timeout)
+
+        if res is None or res.type == EventType.ERROR:
+            return None
+
+        timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+        timeout = timeout if min_timeout < timeout else min_timeout
+
+        if self.dispatcher is None:
+            return None
+
+        # Listen for NEIGHBOUR_RESPONSE
+        neighbours_event = await self.dispatcher.wait_for_event(
+            EventType.NEIGHBOURS_RESPONSE,
+            attribute_filters={"tag": res.payload["expected_ack"].hex()},
+            timeout=timeout,
+        )
+
+        return neighbours_event.payload if neighbours_event else None
+
+    # do several queries if not all neighbours have been obtained
+    async def fetch_all_neighbours(self,
+        contact,
+        order_by=0,
+        pubkey_prefix_length=4,
+        timeout=0,
+        min_timeout=0
+    ):
+
+        # Initial request
+        res = await self.req_neighbours_sync(contact,
+            count=255,
+            offset=0,
+            order_by=order_by,
+            pubkey_prefix_length=pubkey_prefix_length,
+            timeout=timeout,
+            min_timeout=min_timeout)
+
+        if res is None:
+            return None
+
+        neighbours_count = res["neighbours_count"] # total neighbours 
+        results_count = res["results_count"]       # obtained neighbours
+
+        del res["tag"]
+
+        while results_count < neighbours_count:
+            #await asyncio.sleep(2) # wait 2s before next fetch
+            next_res = await self.req_neighbours_sync(contact,
+                count=255,
+                offset=results_count,
+                order_by=order_by,
+                pubkey_prefix_length=pubkey_prefix_length,
+                timeout=timeout,
+                min_timeout=min_timeout+5) # requests are close, so let's have some more timeout
+
+            if next_res is None :
+                return res # caller should check it has everything
+
+            results_count = results_count + next_res["results_count"]
+
+            res["results_count"] = results_count
+            res["neighbours"] += next_res["neighbours"]
+
+        return res

meshcore/commands/contact.py

@@ -124,8 +124,8 @@ class ContactCommands(CommandHandlerBase):
         data = (
             b"\x09"
             + bytes.fromhex(contact["public_key"])
-            + contact["type"].to_bytes(1)
-            + flags.to_bytes(1)
+            + contact["type"].to_bytes(1, "little")
+            + flags.to_bytes(1, "little")
             + out_path_len.to_bytes(1, "little", signed=True)
             + bytes.fromhex(out_path_hex)
             + bytes.fromhex(adv_name_hex)

meshcore/commands/control_data.py

@@ -0,0 +1,50 @@
+import logging
+import random
+
+from .base import CommandHandlerBase
+from ..events import EventType, Event
+from ..packets import ControlType, PacketType
+
+logger = logging.getLogger("meshcore")
+
+class ControlDataCommandHandler(CommandHandlerBase):
+    """Helper functions to handle binary requests through binary commands"""
+
+    async def send_control_data (self, control_type: int, payload: bytes) -> Event:
+        data = bytearray([PacketType.SEND_CONTROL_DATA.value]) 
+        data.extend(control_type.to_bytes(1, "little", signed = False)) 
+        data.extend(payload)
+
+        result = await self.send(data, [EventType.OK, EventType.ERROR])
+        return result
+
+    async def send_node_discover_req (
+        self,
+        filter: int,
+        prefix_only: bool=True,
+        tag: int=None,
+        since: int=None
+    ) -> Event:
+
+        if tag is None:
+            tag = random.randint(1, 0xFFFFFFFF)
+
+        data = bytearray()
+        data.extend(filter.to_bytes(1, "little", signed=False))
+        data.extend(tag.to_bytes(4, "little"))
+        if not since is None:
+            data.extend(since.to_bytes(4, "little", signed=False))
+
+        logger.debug(f"sending node discover req {data.hex()}")
+
+        flags = 0
+        flags = flags | 1 if prefix_only else flags
+
+        res = await self.send_control_data(
+            ControlType.NODE_DISCOVER_REQ.value|flags, data)
+
+        if res is None:
+            return None
+        else:
+            res.payload["tag"] = tag
+            return res

meshcore/commands/device.py

@@ -87,14 +87,18 @@ class DeviceCommands(CommandHandlerBase):
             [EventType.OK, EventType.ERROR],
         )
 
+    # the old set_other_params function has been replaced in
+    # favour of set_other_params_from_infos to be more generic
+    # stays here for backward compatibility but does not support
+    # multi_acks for instance
     async def set_other_params(
-        self,
-        manual_add_contacts: bool,
-        telemetry_mode_base: int,
-        telemetry_mode_loc: int,
-        telemetry_mode_env: int,
-        advert_loc_policy: int,
-    ) -> Event:
+            self,
+            manual_add_contacts: bool,
+            telemetry_mode_base: int,
+            telemetry_mode_loc: int,
+            telemetry_mode_env: int,
+            advert_loc_policy: int,
+        ) -> Event:
         telemetry_mode = (
             (telemetry_mode_base & 0b11)
             | ((telemetry_mode_loc & 0b11) << 2)
@@ -102,61 +106,56 @@ class DeviceCommands(CommandHandlerBase):
         )
         data = (
             b"\x26"
-            + manual_add_contacts.to_bytes(1)
-            + telemetry_mode.to_bytes(1)
-            + advert_loc_policy.to_bytes(1)
+            + manual_add_contacts.to_bytes(1, "little")
+            + telemetry_mode.to_bytes(1, "little")
+            + advert_loc_policy.to_bytes(1, "little")
+        )
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
+    async def set_other_params_from_infos(self, infos) -> Event:
+        telemetry_mode = (
+            (infos["telemetry_mode_base"] & 0b11)
+            | ((infos["telemetry_mode_loc"] & 0b11) << 2)
+            | ((infos["telemetry_mode_env"] & 0b11) << 4)
+        )
+        data = (
+            b"\x26"
+            + infos["manual_add_contacts"].to_bytes(1, "little")
+            + telemetry_mode.to_bytes(1, "little")
+            + infos["adv_loc_policy"].to_bytes(1, "little")
+            + infos["multi_acks"].to_bytes(1, "little")
         )
         return await self.send(data, [EventType.OK, EventType.ERROR])
 
     async def set_telemetry_mode_base(self, telemetry_mode_base: int) -> Event:
         infos = (await self.send_appstart()).payload
-        return await self.set_other_params(
-            infos["manual_add_contacts"],
-            telemetry_mode_base,
-            infos["telemetry_mode_loc"],
-            infos["telemetry_mode_env"],
-            infos["adv_loc_policy"],
-        )
+        infos["telemetry_mode_base"] = telemetry_mode_base
+        return await self.set_other_params_from_infos(infos)
 
     async def set_telemetry_mode_loc(self, telemetry_mode_loc: int) -> Event:
         infos = (await self.send_appstart()).payload
-        return await self.set_other_params(
-            infos["manual_add_contacts"],
-            infos["telemetry_mode_base"],
-            telemetry_mode_loc,
-            infos["telemetry_mode_env"],
-            infos["adv_loc_policy"],
-        )
+        infos["telemetry_mode_loc"] = telemetry_mode_loc
+        return await self.set_other_params_from_infos(infos)
 
     async def set_telemetry_mode_env(self, telemetry_mode_env: int) -> Event:
         infos = (await self.send_appstart()).payload
-        return await self.set_other_params(
-            infos["manual_add_contacts"],
-            infos["telemetry_mode_base"],
-            infos["telemetry_mode_loc"],
-            telemetry_mode_env,
-            infos["adv_loc_policy"],
-        )
+        infos["telemetry_mode_env"] = telemetry_mode_env
+        return await self.set_other_params_from_infos(infos)
 
     async def set_manual_add_contacts(self, manual_add_contacts: bool) -> Event:
         infos = (await self.send_appstart()).payload
-        return await self.set_other_params(
-            manual_add_contacts,
-            infos["telemetry_mode_base"],
-            infos["telemetry_mode_loc"],
-            infos["telemetry_mode_env"],
-            infos["adv_loc_policy"],
-        )
+        infos["manual_add_contacts"] = manual_add_contacts
+        return await self.set_other_params_from_infos(infos)
 
     async def set_advert_loc_policy(self, advert_loc_policy: int) -> Event:
         infos = (await self.send_appstart()).payload
-        return await self.set_other_params(
-            infos["manual_add_contacts"],
-            infos["telemetry_mode_base"],
-            infos["telemetry_mode_loc"],
-            infos["telemetry_mode_env"],
-            advert_loc_policy,
-        )
+        infos["adv_loc_policy"] = advert_loc_policy
+        return await self.set_other_params_from_infos(infos)
+
+    async def set_multi_acks(self, multi_acks: int) -> Event:
+        infos = (await self.send_appstart()).payload
+        infos["multi_acks"] = multi_acks
+        return await self.set_other_params_from_infos(infos)
 
     async def set_devicepin(self, pin: int) -> Event:
         logger.debug(f"Setting device PIN to: {pin}")
@@ -206,3 +205,18 @@ class DeviceCommands(CommandHandlerBase):
     async def export_private_key(self) -> Event:
         logger.debug("Requesting private key export")
         return await self.send(b"\x17", [EventType.PRIVATE_KEY, EventType.DISABLED, EventType.ERROR])
+
+    async def get_stats_core(self) -> Event:
+        logger.debug("Getting core statistics")
+        # CMD_GET_STATS (56) + STATS_TYPE_CORE (0)
+        return await self.send(b"\x38\x00", [EventType.STATS_CORE, EventType.ERROR])
+
+    async def get_stats_radio(self) -> Event:
+        logger.debug("Getting radio statistics")
+        # CMD_GET_STATS (56) + STATS_TYPE_RADIO (1)
+        return await self.send(b"\x38\x01", [EventType.STATS_RADIO, EventType.ERROR])
+
+    async def get_stats_packets(self) -> Event:
+        logger.debug("Getting packet statistics")
+        # CMD_GET_STATS (56) + STATS_TYPE_PACKETS (2)
+        return await self.send(b"\x38\x02", [EventType.STATS_PACKETS, EventType.ERROR])

meshcore/commands/messaging.py

@@ -1,8 +1,10 @@
 import logging
 import random
 from typing import Optional, Union
+from hashlib import sha256
 
 from ..events import Event, EventType
+from ..packets import PacketType
 from .base import CommandHandlerBase, DestinationType, _validate_destination
 
 logger = logging.getLogger("meshcore")
@@ -84,21 +86,33 @@ class MessagingCommands(CommandHandlerBase):
         max_attempts=3, max_flood_attempts=2, flood_after=2, timeout=0, min_timeout=0
     ) -> Event:
         
-        dst_bytes = _validate_destination(dst)
+        try:
+            dst_bytes = _validate_destination(dst, prefix_length=32)
+            # with 32 bytes we can reset to flood
+        except ValueError:
+            # but if we can't, we'll assume we're flood
+            dst_bytes = _validate_destination(dst, prefix_length=6)
         contact = self._get_contact_by_prefix(dst_bytes.hex())
 
         attempts = 0
         flood_attempts = 0
         if not contact is None :
             flood = contact["out_path_len"] == -1
+            if len(dst_bytes) < 32:
+                # if we have a contact, then we can get a 32 bytes key !
+                dst_bytes = _validate_destination(contact, prefix_length=32)
         else:
-            flood = False 
+            # we can't know if we're flood without fetching all contacts
+            # if we have a full key (meaning we can reset path) consider direct
+            # else consider flood
+            flood = len(dst_bytes) < 32 
+            logger.info(f"send_msg_with_retry: can't determine if flood, assume {flood}")
         res = None
         while attempts < max_attempts and res is None \
                     and (not flood or flood_attempts < max_flood_attempts):
-            if attempts == flood_after : # change path to flood
+            if attempts == flood_after and not flood: # change path to flood
                 logger.info("Resetting path")
-                rp_res = await self.reset_path(dst)
+                rp_res = await self.reset_path(dst_bytes)
                 if rp_res.type == EventType.ERROR:
                     logger.error(f"Couldn't reset path {rp_res} continuing ...")
                 else:
@@ -209,3 +223,20 @@ class MessagingCommands(CommandHandlerBase):
                 return Event(EventType.ERROR, {"reason": "unsupported_path_type"})
 
         return await self.send(cmd_data, [EventType.MSG_SENT, EventType.ERROR])
+
+    async def set_flood_scope(self, scope):
+        if scope.startswith("#"): # an hash
+            logger.debug(f"Setting scope from hash {scope}")
+            scope_key = sha256(scope.encode("utf-8")).digest()[0:16]
+        elif scope == "0" or scope == "None" or scope == "*" or scope == "": # disable
+            scope_key = b"\0"*16
+        else: # assume the key has been sent directly
+            scope_key = scope.encode("utf-8")
+
+        logger.debug(f"Setting scope to {scope_key.hex()}")
+
+        cmd_data = bytearray([PacketType.SET_FLOOD_SCOPE.value])
+        cmd_data.extend(b"\0")
+        cmd_data.extend(scope_key)
+
+        return await self.send(cmd_data, [EventType.OK, EventType.ERROR])

meshcore/events.py

@@ -40,10 +40,16 @@ class EventType(Enum):
     MMA_RESPONSE = "mma_response"
     ACL_RESPONSE = "acl_response"
     CUSTOM_VARS = "custom_vars"
+    STATS_CORE = "stats_core"
+    STATS_RADIO = "stats_radio"
+    STATS_PACKETS = "stats_packets"
     CHANNEL_INFO = "channel_info"
     PATH_RESPONSE = "path_response"
     PRIVATE_KEY = "private_key"
     DISABLED = "disabled"
+    CONTROL_DATA = "control_data"
+    DISCOVER_RESPONSE = "discover_response"
+    NEIGHBOURS_RESPONSE = "neighbours_response"
 
     # Command response types
     OK = "command_ok"

meshcore/packets.py

@@ -6,6 +6,11 @@ class BinaryReqType(Enum):
     TELEMETRY = 0x03
     MMA = 0x04
     ACL = 0x05
+    NEIGHBOURS = 0x06
+
+class ControlType(Enum):
+    NODE_DISCOVER_REQ = 0x80
+    NODE_DISCOVER_RESP = 0x90
 
 # Packet prefixes for the protocol
 class PacketType(Enum):
@@ -31,8 +36,12 @@ class PacketType(Enum):
     SIGN_START = 19
     SIGNATURE = 20
     CUSTOM_VARS = 21
+    STATS = 24
     BINARY_REQ = 50
     FACTORY_RESET = 51
+    PATH_DISCOVERY = 52
+    SET_FLOOD_SCOPE = 54
+    SEND_CONTROL_DATA = 55
 
     # Push notifications
     ADVERTISEMENT = 0x80
@@ -49,3 +58,4 @@ class PacketType(Enum):
     TELEMETRY_RESPONSE = 0x8B
     BINARY_RESPONSE = 0x8C
     PATH_DISCOVERY_RESPONSE = 0x8D
+    CONTROL_DATA = 0x8E

meshcore/reader.py

@@ -1,9 +1,11 @@
 import logging
 import json
+import struct
 import time
+import io
 from typing import Any, Dict
 from .events import Event, EventType, EventDispatcher
-from .packets import BinaryReqType, PacketType
+from .packets import BinaryReqType, PacketType, ControlType
 from .parsing import lpp_parse, lpp_parse_mma, parse_acl, parse_status
 from cayennelpp import LppFrame, LppData
 from meshcore.lpp_json_encoder import lpp_json_encoder
@@ -18,20 +20,21 @@ class MessageReader:
         # before events are dispatched
         self.contacts = {}  # Temporary storage during contact list building
         self.contact_nb = 0  # Used for contact processing
-        
+
         # Track pending binary requests by tag for proper response parsing
         self.pending_binary_requests: Dict[str, Dict[str, Any]] = {}  # tag -> {request_type, expires_at}
 
-    def register_binary_request(self, prefix: str, tag: str, request_type: BinaryReqType, timeout_seconds: float):
+    def register_binary_request(self, prefix: str, tag: str, request_type: BinaryReqType, timeout_seconds: float, context={}):
         """Register a pending binary request for proper response parsing"""
         # Clean up expired requests before adding new one
         self.cleanup_expired_requests()
-        
+
         expires_at = time.time() + timeout_seconds
         self.pending_binary_requests[tag] = {
             "request_type": request_type,
             "pubkey_prefix": prefix,
-            "expires_at": expires_at
+            "expires_at": expires_at,
+            "context": context # optional info we want to keep from req to resp
         }
         logger.debug(f"Registered binary request: tag={tag}, type={request_type}, expires in {timeout_seconds}s")
 
@@ -42,13 +45,18 @@ class MessageReader:
             tag for tag, info in self.pending_binary_requests.items()
             if current_time > info["expires_at"]
         ]
-        
+
         for tag in expired_tags:
             logger.debug(f"Cleaning up expired binary request: tag={tag}")
             del self.pending_binary_requests[tag]
-    
+
     async def handle_rx(self, data: bytearray):
-        packet_type_value = data[0]
+        dbuf = io.BytesIO(data)
+        try:
+            packet_type_value = dbuf.read(1)[0]
+        except IndexError as e:
+            logger.warning(f"Received empty packet: {e}")
+            return
         logger.debug(f"Received data: {data.hex()}")
 
         # Handle command responses
@@ -78,23 +86,24 @@ class MessageReader:
             or packet_type_value == PacketType.PUSH_CODE_NEW_ADVERT.value
         ):
             c = {}
-            c["public_key"] = data[1:33].hex()
-            c["type"] = data[33]
-            c["flags"] = data[34]
-            c["out_path_len"] = int.from_bytes(data[35:36], signed=True, byteorder="little")
-            plen = int.from_bytes(data[35:36], signed=True, byteorder="little")
+            c["public_key"] = dbuf.read(32).hex()
+            c["type"] = dbuf.read(1)[0]
+            c["flags"] = dbuf.read(1)[0]
+            plen = int.from_bytes(dbuf.read(1), signed=True, byteorder="little")
+            c["out_path_len"] = plen
             if plen == -1:
                 plen = 0
-            c["out_path"] = data[36 : 36 + plen].hex()
-            c["adv_name"] = data[100:132].decode("utf-8", "ignore").replace("\0", "")
-            c["last_advert"] = int.from_bytes(data[132:136], byteorder="little")
+            path = dbuf.read(64)
+            c["out_path"] = path[0:plen].hex()
+            c["adv_name"] = dbuf.read(32).decode("utf-8", "ignore").replace("\0", "")
+            c["last_advert"] = int.from_bytes(dbuf.read(4), byteorder="little")
             c["adv_lat"] = (
-                int.from_bytes(data[136:140], byteorder="little", signed=True) / 1e6
+                int.from_bytes(dbuf.read(4), byteorder="little", signed=True) / 1e6
             )
             c["adv_lon"] = (
-                int.from_bytes(data[140:144], byteorder="little", signed=True) / 1e6
+                int.from_bytes(dbuf.read(4), byteorder="little", signed=True) / 1e6
             )
-            c["lastmod"] = int.from_bytes(data[144:148], byteorder="little")
+            c["lastmod"] = int.from_bytes(dbuf.read(4), byteorder="little")
 
             if packet_type_value == PacketType.PUSH_CODE_NEW_ADVERT.value:
                 await self.dispatcher.dispatch(Event(EventType.NEW_CONTACT, c))
@@ -103,7 +112,7 @@ class MessageReader:
                 self.contacts[c["public_key"]] = c
 
         elif packet_type_value == PacketType.CONTACT_END.value:
-            lastmod = int.from_bytes(data[1:5], byteorder="little")
+            lastmod = int.from_bytes(dbuf.read(4), byteorder="little")
             attributes = {
                 "lastmod": lastmod,
             }
@@ -113,37 +122,39 @@ class MessageReader:
 
         elif packet_type_value == PacketType.SELF_INFO.value:
             self_info = {}
-            self_info["adv_type"] = data[1]
-            self_info["tx_power"] = data[2]
-            self_info["max_tx_power"] = data[3]
-            self_info["public_key"] = data[4:36].hex()
+            self_info["adv_type"] = dbuf.read(1)[0]
+            self_info["tx_power"] = dbuf.read(1)[0]
+            self_info["max_tx_power"] = dbuf.read(1)[0]
+            self_info["public_key"] = dbuf.read(32).hex()
             self_info["adv_lat"] = (
-                int.from_bytes(data[36:40], byteorder="little", signed=True) / 1e6
+                int.from_bytes(dbuf.read(4), byteorder="little", signed=True) / 1e6
             )
             self_info["adv_lon"] = (
-                int.from_bytes(data[40:44], byteorder="little", signed=True) / 1e6
+                int.from_bytes(dbuf.read(4), byteorder="little", signed=True) / 1e6
             )
-            self_info["adv_loc_policy"] = data[45]
-            self_info["telemetry_mode_env"] = (data[46] >> 4) & 0b11
-            self_info["telemetry_mode_loc"] = (data[46] >> 2) & 0b11
-            self_info["telemetry_mode_base"] = (data[46]) & 0b11
-            self_info["manual_add_contacts"] = data[47] > 0
+            self_info["multi_acks"] = dbuf.read(1)[0]
+            self_info["adv_loc_policy"] = dbuf.read(1)[0]
+            telemetry_mode = dbuf.read(1)[0]
+            self_info["telemetry_mode_env"] = (telemetry_mode >> 4) & 0b11
+            self_info["telemetry_mode_loc"] = (telemetry_mode >> 2) & 0b11
+            self_info["telemetry_mode_base"] = (telemetry_mode) & 0b11
+            self_info["manual_add_contacts"] = dbuf.read(1)[0] > 0
             self_info["radio_freq"] = (
-                int.from_bytes(data[48:52], byteorder="little") / 1000
+                int.from_bytes(dbuf.read(4), byteorder="little") / 1000
             )
             self_info["radio_bw"] = (
-                int.from_bytes(data[52:56], byteorder="little") / 1000
+                int.from_bytes(dbuf.read(4), byteorder="little") / 1000
             )
-            self_info["radio_sf"] = data[56]
-            self_info["radio_cr"] = data[57]
-            self_info["name"] = data[58:].decode("utf-8", "ignore")
+            self_info["radio_sf"] = dbuf.read(1)[0]
+            self_info["radio_cr"] = dbuf.read(1)[0]
+            self_info["name"] = dbuf.read().decode("utf-8", "ignore")
             await self.dispatcher.dispatch(Event(EventType.SELF_INFO, self_info))
 
         elif packet_type_value == PacketType.MSG_SENT.value:
             res = {}
-            res["type"] = data[1]
-            res["expected_ack"] = bytes(data[2:6])
-            res["suggested_timeout"] = int.from_bytes(data[6:10], byteorder="little")
+            res["type"] = dbuf.read(1)[0]
+            res["expected_ack"] = dbuf.read(4)
+            res["suggested_timeout"] = int.from_bytes(dbuf.read(4), byteorder="little")
 
             attributes = {
                 "type": res["type"],
@@ -155,15 +166,14 @@ class MessageReader:
         elif packet_type_value == PacketType.CONTACT_MSG_RECV.value:
             res = {}
             res["type"] = "PRIV"
-            res["pubkey_prefix"] = data[1:7].hex()
-            res["path_len"] = data[7]
-            res["txt_type"] = data[8]
-            res["sender_timestamp"] = int.from_bytes(data[9:13], byteorder="little")
-            if data[8] == 2:
-                res["signature"] = data[13:17].hex()
-                res["text"] = data[17:].decode("utf-8", "ignore")
-            else:
-                res["text"] = data[13:].decode("utf-8", "ignore")
+            res["pubkey_prefix"] = dbuf.read(6).hex()
+            res["path_len"] = dbuf.read(1)[0]
+            txt_type = dbuf.read(1)[0]
+            res["txt_type"] = txt_type
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            if txt_type == 2:
+                res["signature"] = dbuf.read(4).hex()
+            res["text"] = dbuf.read().decode("utf-8", "ignore")
 
             attributes = {
                 "pubkey_prefix": res["pubkey_prefix"],
@@ -177,16 +187,16 @@ class MessageReader:
         elif packet_type_value == 16:  # A reply to CMD_SYNC_NEXT_MESSAGE (ver >= 3)
             res = {}
             res["type"] = "PRIV"
-            res["SNR"] = int.from_bytes(data[1:2], byteorder="little", signed=True) / 4
-            res["pubkey_prefix"] = data[4:10].hex()
-            res["path_len"] = data[10]
-            res["txt_type"] = data[11]
-            res["sender_timestamp"] = int.from_bytes(data[12:16], byteorder="little")
-            if data[11] == 2:
-                res["signature"] = data[16:20].hex()
-                res["text"] = data[20:].decode("utf-8", "ignore")
-            else:
-                res["text"] = data[16:].decode("utf-8", "ignore")
+            res["SNR"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True) / 4
+            dbuf.read(2) # reserved
+            res["pubkey_prefix"] = dbuf.read(6).hex()
+            res["path_len"] = dbuf.read(1)[0]
+            txt_type = dbuf.read(1)[0]
+            res["txt_type"] = txt_type
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            if txt_type == 2:
+                res["signature"] = dbuf.read(4).hex()
+            res["text"] = dbuf.read().decode("utf-8", "ignore")
 
             attributes = {
                 "pubkey_prefix": res["pubkey_prefix"],
@@ -200,11 +210,11 @@ class MessageReader:
         elif packet_type_value == PacketType.CHANNEL_MSG_RECV.value:
             res = {}
             res["type"] = "CHAN"
-            res["channel_idx"] = data[1]
-            res["path_len"] = data[2]
-            res["txt_type"] = data[3]
-            res["sender_timestamp"] = int.from_bytes(data[4:8], byteorder="little")
-            res["text"] = data[8:].decode("utf-8", "ignore")
+            res["channel_idx"] = dbuf.read(1)[0]
+            res["path_len"] = dbuf.read(1)[0]
+            res["txt_type"] = dbuf.read(1)[0]
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            res["text"] = dbuf.read().decode("utf-8", "ignore")
 
             attributes = {
                 "channel_idx": res["channel_idx"],
@@ -218,12 +228,13 @@ class MessageReader:
         elif packet_type_value == 17:  # A reply to CMD_SYNC_NEXT_MESSAGE (ver >= 3)
             res = {}
             res["type"] = "CHAN"
-            res["SNR"] = int.from_bytes(data[1:2], byteorder="little", signed=True) / 4
-            res["channel_idx"] = data[4]
-            res["path_len"] = data[5]
-            res["txt_type"] = data[6]
-            res["sender_timestamp"] = int.from_bytes(data[7:11], byteorder="little")
-            res["text"] = data[11:].decode("utf-8", "ignore")
+            res["SNR"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True) / 4
+            dbuf.read(2) # reserved
+            res["channel_idx"] = dbuf.read(1)[0]
+            res["path_len"] = dbuf.read(1)[0]
+            res["txt_type"] = dbuf.read(1)[0]
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            res["text"] = dbuf.read().decode("utf-8", "ignore")
 
             attributes = {
                 "channel_idx": res["channel_idx"],
@@ -235,7 +246,7 @@ class MessageReader:
             )
 
         elif packet_type_value == PacketType.CURRENT_TIME.value:
-            time_value = int.from_bytes(data[1:5], byteorder="little")
+            time_value = int.from_bytes(dbuf.read(4), byteorder="little")
             result = {"time": time_value}
             await self.dispatcher.dispatch(Event(EventType.CURRENT_TIME, result))
 
@@ -244,34 +255,34 @@ class MessageReader:
             await self.dispatcher.dispatch(Event(EventType.NO_MORE_MSGS, result))
 
         elif packet_type_value == PacketType.CONTACT_URI.value:
-            contact_uri = "meshcore://" + data[1:].hex()
+            contact_uri = "meshcore://" + dbuf.read().hex()
             result = {"uri": contact_uri}
             await self.dispatcher.dispatch(Event(EventType.CONTACT_URI, result))
 
         elif packet_type_value == PacketType.BATTERY.value:
-            battery_level = int.from_bytes(data[1:3], byteorder="little")
+            battery_level = int.from_bytes(dbuf.read(2), byteorder="little")
             result = {"level": battery_level}
             if len(data) > 3:  # has storage info as well
-                result["used_kb"] = int.from_bytes(data[3:7], byteorder="little")
-                result["total_kb"] = int.from_bytes(data[7:11], byteorder="little")
+                result["used_kb"] = int.from_bytes(dbuf.read(4), byteorder="little")
+                result["total_kb"] = int.from_bytes(dbuf.read(4), byteorder="little")
             await self.dispatcher.dispatch(Event(EventType.BATTERY, result))
 
         elif packet_type_value == PacketType.DEVICE_INFO.value:
             res = {}
-            res["fw ver"] = data[1]
+            res["fw ver"] = dbuf.read(1)[0]
             if data[1] >= 3:
-                res["max_contacts"] = data[2] * 2
-                res["max_channels"] = data[3]
-                res["ble_pin"] = int.from_bytes(data[4:8], byteorder="little")
-                res["fw_build"] = data[8:20].decode("utf-8", "ignore").replace("\0", "")
-                res["model"] = data[20:60].decode("utf-8", "ignore").replace("\0", "")
-                res["ver"] = data[60:80].decode("utf-8", "ignore").replace("\0", "")
+                res["max_contacts"] = dbuf.read(1)[0] * 2
+                res["max_channels"] = dbuf.read(1)[0]
+                res["ble_pin"] = int.from_bytes(dbuf.read(4), byteorder="little")
+                res["fw_build"] = dbuf.read(12).decode("utf-8", "ignore").replace("\0", "")
+                res["model"] = dbuf.read(40).decode("utf-8", "ignore").replace("\0", "")
+                res["ver"] = dbuf.read(20).decode("utf-8", "ignore").replace("\0", "")
             await self.dispatcher.dispatch(Event(EventType.DEVICE_INFO, res))
 
         elif packet_type_value == PacketType.CUSTOM_VARS.value:
             logger.debug(f"received custom vars response: {data.hex()}")
             res = {}
-            rawdata = data[1:].decode("utf-8", "ignore")
+            rawdata = dbuf.read().decode("utf-8", "ignore")
             if not rawdata == "":
                 pairs = rawdata.split(",")
                 for p in pairs:
@@ -280,33 +291,114 @@ class MessageReader:
             logger.debug(f"got custom vars : {res}")
             await self.dispatcher.dispatch(Event(EventType.CUSTOM_VARS, res))
 
+        elif packet_type_value == PacketType.STATS.value:  # RESP_CODE_STATS (24)
+            logger.debug(f"received stats response: {data.hex()}")
+            # RESP_CODE_STATS: All stats responses use code 24 with sub-type byte
+            # Byte 0: response_code (24), Byte 1: stats_type (0=core, 1=radio, 2=packets)
+            if len(data) < 2:
+                logger.error(f"Stats response too short: {len(data)} bytes, need at least 2 for header")
+                await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": "invalid_frame_length"}))
+                return
+            
+            stats_type = data[1]
+            
+            if stats_type == 0:  # STATS_TYPE_CORE
+                # RESP_CODE_STATS + STATS_TYPE_CORE: 11 bytes total
+                # Format: <B B H I H B (response_code, stats_type, battery_mv, uptime_secs, errors, queue_len)
+                if len(data) < 11:
+                    logger.error(f"Stats core response too short: {len(data)} bytes, expected 11")
+                    await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": "invalid_frame_length"}))
+                else:
+                    try:
+                        battery_mv, uptime_secs, errors, queue_len = struct.unpack('<H I H B', data[2:11])
+                        res = {
+                            'battery_mv': battery_mv,
+                            'uptime_secs': uptime_secs,
+                            'errors': errors,
+                            'queue_len': queue_len
+                        }
+                        logger.debug(f"parsed stats core: {res}")
+                        await self.dispatcher.dispatch(Event(EventType.STATS_CORE, res))
+                    except struct.error as e:
+                        logger.error(f"Error parsing stats core binary frame: {e}, data: {data.hex()}")
+                        await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"binary_parse_error: {e}"}))
+            
+            elif stats_type == 1:  # STATS_TYPE_RADIO
+                # RESP_CODE_STATS + STATS_TYPE_RADIO: 14 bytes total
+                # Format: <B B h b b I I (response_code, stats_type, noise_floor, last_rssi, last_snr, tx_air_secs, rx_air_secs)
+                if len(data) < 14:
+                    logger.error(f"Stats radio response too short: {len(data)} bytes, expected 14")
+                    await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": "invalid_frame_length"}))
+                else:
+                    try:
+                        noise_floor, last_rssi, last_snr_scaled, tx_air_secs, rx_air_secs = struct.unpack('<h b b I I', data[2:14])
+                        res = {
+                            'noise_floor': noise_floor,
+                            'last_rssi': last_rssi,
+                            'last_snr': last_snr_scaled / 4.0,  # Unscale SNR (was multiplied by 4)
+                            'tx_air_secs': tx_air_secs,
+                            'rx_air_secs': rx_air_secs
+                        }
+                        logger.debug(f"parsed stats radio: {res}")
+                        await self.dispatcher.dispatch(Event(EventType.STATS_RADIO, res))
+                    except struct.error as e:
+                        logger.error(f"Error parsing stats radio binary frame: {e}, data: {data.hex()}")
+                        await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"binary_parse_error: {e}"}))
+            
+            elif stats_type == 2:  # STATS_TYPE_PACKETS
+                # RESP_CODE_STATS + STATS_TYPE_PACKETS: 26 bytes total
+                # Format: <B B I I I I I I (response_code, stats_type, recv, sent, flood_tx, direct_tx, flood_rx, direct_rx)
+                if len(data) < 26:
+                    logger.error(f"Stats packets response too short: {len(data)} bytes, expected 26")
+                    await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": "invalid_frame_length"}))
+                else:
+                    try:
+                        recv, sent, flood_tx, direct_tx, flood_rx, direct_rx = struct.unpack('<I I I I I I', data[2:26])
+                        res = {
+                            'recv': recv,
+                            'sent': sent,
+                            'flood_tx': flood_tx,
+                            'direct_tx': direct_tx,
+                            'flood_rx': flood_rx,
+                            'direct_rx': direct_rx
+                        }
+                        logger.debug(f"parsed stats packets: {res}")
+                        await self.dispatcher.dispatch(Event(EventType.STATS_PACKETS, res))
+                    except struct.error as e:
+                        logger.error(f"Error parsing stats packets binary frame: {e}, data: {data.hex()}")
+                        await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"binary_parse_error: {e}"}))
+            
+            else:
+                logger.error(f"Unknown stats type: {stats_type}, data: {data.hex()}")
+                await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"unknown_stats_type: {stats_type}"}))
+
         elif packet_type_value == PacketType.CHANNEL_INFO.value:
             logger.debug(f"received channel info response: {data.hex()}")
             res = {}
-            res["channel_idx"] = data[1]
+            res["channel_idx"] = dbuf.read(1)[0]
 
             # Channel name is null-terminated, so find the first null byte
-            name_bytes = data[2:34]
+            name_bytes = dbuf.read(32)
             null_pos = name_bytes.find(0)
             if null_pos >= 0:
                 res["channel_name"] = name_bytes[:null_pos].decode("utf-8", "ignore")
             else:
                 res["channel_name"] = name_bytes.decode("utf-8", "ignore")
 
-            res["channel_secret"] = data[34:50]
+            res["channel_secret"] = dbuf.read(16)
             await self.dispatcher.dispatch(Event(EventType.CHANNEL_INFO, res, res))
 
         # Push notifications
         elif packet_type_value == PacketType.ADVERTISEMENT.value:
             logger.debug("Advertisement received")
             res = {}
-            res["public_key"] = data[1:33].hex()
+            res["public_key"] = dbuf.read(32).hex()
             await self.dispatcher.dispatch(Event(EventType.ADVERTISEMENT, res, res))
 
         elif packet_type_value == PacketType.PATH_UPDATE.value:
             logger.debug("Code path update")
             res = {}
-            res["public_key"] = data[1:33].hex()
+            res["public_key"] = dbuf.read(32).hex()
             await self.dispatcher.dispatch(Event(EventType.PATH_UPDATE, res, res))
 
         elif packet_type_value == PacketType.ACK.value:
@@ -314,7 +406,7 @@ class MessageReader:
             ack_data = {}
 
             if len(data) >= 5:
-                ack_data["code"] = bytes(data[1:5]).hex()
+                ack_data["code"] = dbuf.read(4).hex()
 
             attributes = {"code": ack_data.get("code", "")}
 
@@ -326,23 +418,24 @@ class MessageReader:
 
         elif packet_type_value == PacketType.RAW_DATA.value:
             res = {}
-            res["SNR"] = data[1] / 4
-            res["RSSI"] = data[2]
-            res["payload"] = data[4:].hex()
+            res["SNR"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True) / 4
+            res["RSSI"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True)
+            res["payload"] = dbuf.read(4).hex()
             logger.debug("Received raw data")
             print(res)
             await self.dispatcher.dispatch(Event(EventType.RAW_DATA, res))
 
         elif packet_type_value == PacketType.LOGIN_SUCCESS.value:
             res = {}
+            attributes = {}
             if len(data) > 1:
-                res["permissions"] = data[1]
-                res["is_admin"] = (data[1] & 1) == 1  # Check if admin bit is set
+                perms = dbuf.read(1)[0]
+                res["permissions"] = perms
+                res["is_admin"] = (perms & 1) == 1  # Check if admin bit is set
 
-            if len(data) > 7:
-                res["pubkey_prefix"] = data[2:8].hex()
+                res["pubkey_prefix"] = dbuf.read(6).hex()
 
-            attributes = {"pubkey_prefix": res.get("pubkey_prefix")}
+                attributes = {"pubkey_prefix": res.get("pubkey_prefix")}
 
             await self.dispatcher.dispatch(
                 Event(EventType.LOGIN_SUCCESS, res, attributes)
@@ -350,11 +443,14 @@ class MessageReader:
 
         elif packet_type_value == PacketType.LOGIN_FAILED.value:
             res = {}
+            attributes = {}
+
+            pbuf.read(1)
 
             if len(data) > 7:
-                res["pubkey_prefix"] = data[2:8].hex()
+                res["pubkey_prefix"] = pbuf.read(6).hex()
 
-            attributes = {"pubkey_prefix": res.get("pubkey_prefix")}
+                attributes = {"pubkey_prefix": res.get("pubkey_prefix")}
 
             await self.dispatcher.dispatch(
                 Event(EventType.LOGIN_FAILED, res, attributes)
@@ -368,12 +464,7 @@ class MessageReader:
             attributes = {
                 "pubkey_prefix": res["pubkey_pre"],
             }
-            data_hex = data[8:].hex()
-            logger.debug(f"Status response: {data_hex}")
 
-            attributes = {
-                "pubkey_prefix": res["pubkey_pre"],
-            }
             await self.dispatcher.dispatch(
                 Event(EventType.STATUS_RESPONSE, res, attributes)
             )
@@ -386,22 +477,23 @@ class MessageReader:
 
             # First byte is SNR (signed byte, multiplied by 4)
             if len(data) > 1:
-                snr_byte = data[1]
+                snr_byte = dbuf.read(1)[0]
                 # Convert to signed value
                 snr = (snr_byte if snr_byte < 128 else snr_byte - 256) / 4.0
                 log_data["snr"] = snr
 
             # Second byte is RSSI (signed byte)
             if len(data) > 2:
-                rssi_byte = data[2]
+                rssi_byte = dbuf.read(1)[0]
                 # Convert to signed value
                 rssi = rssi_byte if rssi_byte < 128 else rssi_byte - 256
                 log_data["rssi"] = rssi
 
             # Remaining bytes are the raw data payload
             if len(data) > 3:
-                log_data["payload"] = data[3:].hex()
-                log_data["payload_length"] = len(data) - 3
+                payload=dbuf.read()
+                log_data["payload"] = payload.hex()
+                log_data["payload_length"] = len(payload)
 
             attributes = {
                 "pubkey_prefix": log_data["raw_hex"],
@@ -470,8 +562,10 @@ class MessageReader:
             logger.debug(f"Received telemetry data: {data.hex()}")
             res = {}
 
-            res["pubkey_pre"] = data[2:8].hex()
-            buf = data[8:]
+            dbuf.read(1)
+
+            res["pubkey_pre"] = dbuf.read(6).hex()
+            buf = dbuf.read()
 
             """Parse a given byte string and return as a LppFrame object."""
             i = 0
@@ -498,29 +592,31 @@ class MessageReader:
 
         elif packet_type_value == PacketType.BINARY_RESPONSE.value:
             logger.debug(f"Received binary data: {data.hex()}")
-            tag = data[2:6].hex()
-            response_data = data[6:]
-            
+            dbuf.read(1)
+            tag = dbuf.read(4).hex()
+            response_data = dbuf.read()
+
             # Always dispatch generic BINARY_RESPONSE
             binary_res = {"tag": tag, "data": response_data.hex()}
             await self.dispatcher.dispatch(
                 Event(EventType.BINARY_RESPONSE, binary_res, {"tag": tag})
             )
-            
+
             # Check for tracked request type and dispatch specific response
             if tag in self.pending_binary_requests:
                 request_type = self.pending_binary_requests[tag]["request_type"]
                 pubkey_prefix = self.pending_binary_requests[tag]["pubkey_prefix"]
+                context = self.pending_binary_requests[tag]["context"]
                 del self.pending_binary_requests[tag]
                 logger.debug(f"Processing binary response for tag {tag}, type {request_type}, pubkey_prefix {pubkey_prefix}")
-                
+
                 if request_type == BinaryReqType.STATUS and len(response_data) >= 52:
                     res = {}
                     res = parse_status(response_data, pubkey_prefix=pubkey_prefix)
                     await self.dispatcher.dispatch(
                         Event(EventType.STATUS_RESPONSE, res, {"pubkey_prefix": res["pubkey_pre"], "tag": tag})
                     )
-                
+
                 elif request_type == BinaryReqType.TELEMETRY:
                     try:
                         lpp = lpp_parse(response_data)
@@ -530,7 +626,7 @@ class MessageReader:
                         )
                     except Exception as e:
                         logger.error(f"Error parsing binary telemetry response: {e}")
-                
+
                 elif request_type == BinaryReqType.MMA:
                     try:
                         mma_result = lpp_parse_mma(response_data[4:])  # Skip 4-byte header
@@ -540,7 +636,7 @@ class MessageReader:
                         )
                     except Exception as e:
                         logger.error(f"Error parsing binary MMA response: {e}")
-                
+
                 elif request_type == BinaryReqType.ACL:
                     try:
                         acl_result = parse_acl(response_data)
@@ -550,19 +646,54 @@ class MessageReader:
                         )
                     except Exception as e:
                         logger.error(f"Error parsing binary ACL response: {e}")
+
+                elif request_type == BinaryReqType.NEIGHBOURS:
+                    try:
+                        pk_plen = context["pubkey_prefix_length"]
+                        bbuf = io.BytesIO(response_data)
+
+                        res = {
+                            "pubkey_prefix": pubkey_prefix,
+                            "tag": tag
+                        }
+                        res.update(context) # add context in result
+
+                        res["neighbours_count"] = int.from_bytes(bbuf.read(2), "little", signed=True)
+                        results_count = int.from_bytes(bbuf.read(2), "little", signed=True)
+                        res["results_count"] = results_count
+
+                        neighbours_list = []
+
+                        for _ in range (results_count):
+                            neighb = {}
+                            neighb["pubkey"] = bbuf.read(pk_plen).hex()
+                            neighb["secs_ago"] = int.from_bytes(bbuf.read(4), "little", signed=True)
+                            neighb["snr"] = int.from_bytes(bbuf.read(1), "little", signed=True) / 4
+                            neighbours_list.append(neighb)
+
+                        res["neighbours"] = neighbours_list
+
+                        await self.dispatcher.dispatch(
+                            Event(EventType.NEIGHBOURS_RESPONSE, res, {"tag": tag, "pubkey_prefix": pubkey_prefix})
+                        )
+
+                    except Exception as e:
+                        logger.error(f"Error parsing binary NEIGHBOURS response: {e}")
+
             else:
                 logger.debug(f"No tracked request found for binary response tag {tag}")
 
         elif packet_type_value == PacketType.PATH_DISCOVERY_RESPONSE.value:
             logger.debug(f"Received path discovery response: {data.hex()}")
             res = {}
-            res["pubkey_pre"] = data[2:8].hex()
-            opl = data[8]
+            dbuf.read(1)
+            res["pubkey_pre"] = dbuf.read(6).hex()
+            opl = dbuf.read(1)[0]
             res["out_path_len"] = opl
-            res["out_path"] = data[9 : 9 + opl].hex()
-            ipl = data[9 + opl]
+            res["out_path"] = dbuf.read(opl).hex()
+            ipl = dbuf.read(1)[0]
             res["in_path_len"] = ipl
-            res["in_path"] = data[10 + opl : 10 + opl + ipl].hex()
+            res["in_path"] = dbuf.read(ipl).hex()
 
             attributes = {"pubkey_pre": res["pubkey_pre"]}
 
@@ -573,7 +704,7 @@ class MessageReader:
         elif packet_type_value == PacketType.PRIVATE_KEY.value:
             logger.debug(f"Received private key response: {data.hex()}")
             if len(data) >= 65:  # 1 byte response code + 64 bytes private key
-                private_key = data[1:65]  # Extract 64-byte private key
+                private_key = dbuf.read(64)  # Extract 64-byte private key
                 res = {"private_key": private_key}
                 await self.dispatcher.dispatch(Event(EventType.PRIVATE_KEY, res))
             else:
@@ -584,6 +715,50 @@ class MessageReader:
             res = {"reason": "private_key_export_disabled"}
             await self.dispatcher.dispatch(Event(EventType.DISABLED, res))
 
+        elif packet_type_value == PacketType.CONTROL_DATA.value:
+            logger.debug("Received control data packet")
+            res={}
+            res["SNR"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True) / 4
+            res["RSSI"] = int.from_bytes(dbuf.read(1), byteorder="little", signed=True)
+            res["path_len"] = dbuf.read(1)[0]
+            payload = dbuf.read()
+            payload_type = payload[0]
+            res["payload_type"] = payload_type
+            res["payload"] = payload
+
+            attributes = {"payload_type": payload_type}
+            await self.dispatcher.dispatch(
+                Event(EventType.CONTROL_DATA, res, attributes)
+            )
+
+            # decode NODE_DISCOVER_RESP
+            if payload_type & 0xF0 == ControlType.NODE_DISCOVER_RESP.value:
+                pbuf = io.BytesIO(payload[1:])
+                ndr = dict(res)
+                del ndr["payload_type"]
+                del ndr["payload"]
+                ndr["node_type"] = payload_type & 0x0F
+                ndr["SNR_in"] = int.from_bytes(pbuf.read(1), byteorder="little", signed=True)/4
+                ndr["tag"] = pbuf.read(4).hex()
+
+                pubkey = pbuf.read()
+                if len(pubkey) < 32:
+                    pubkey = pubkey[0:8]
+                else:
+                    pubkey = pubkey[0:32]
+
+                ndr["pubkey"] = pubkey.hex()
+
+                attributes = {
+                    "node_type" : ndr["node_type"],
+                    "tag" : ndr["tag"],
+                    "pubkey" : ndr["pubkey"],
+                }
+
+                await self.dispatcher.dispatch(
+                    Event(EventType.DISCOVER_RESPONSE, ndr, attributes)
+                )
+
         else:
             logger.debug(f"Unhandled data received {data}")
             logger.debug(f"Unhandled packet type: {packet_type_value}")

{meshcore-2.1.17.dist-info → meshcore-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.1.17
+Version: 2.2.2
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues

meshcore-2.2.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+meshcore/__init__.py,sha256=55PdT8gZ9Lf727s7BdSuCt3lIBlAhRzX28A8i0DHaRc,602
+meshcore/ble_cx.py,sha256=S5uanBI88Mxwcs1zWbdQGVJ6GC4kdWz8-Z_2aQVpeGI,6864
+meshcore/connection_manager.py,sha256=3U0TWuHDvL5FfwEwXRy5HjlCyV3nsWhhrEC7TVxFzZI,5899
+meshcore/events.py,sha256=w1Ug5ugO2hAcMs7cV3WRi_4-hv0Lw_Y7NuZzZv0LPl8,8238
+meshcore/lpp_json_encoder.py,sha256=vyn7z3VYWOo_B9xmCzqblh5xCa0QKWKcMi2eOqw18RE,1875
+meshcore/meshcore.py,sha256=n8fH7AEx7DR8BHOYL_Qex9ns6ACKklNNqYbPnNnvqyE,16110
+meshcore/packets.py,sha256=3irQww-HBAe_O03oHPAdp8Z6pwenjsVX_u3F19fHKyc,1294
+meshcore/parsing.py,sha256=48PQkig-sqvsRlkF9zkvWhJoSq6ERCbGb_aRuCND5NI,4044
+meshcore/reader.py,sha256=YNCP4-ll5JEKW6cvbRMfjFLdG4RtVKt-npEDr8hnpwM,33939
+meshcore/serial_cx.py,sha256=-kaqnqk7Ydufu2DECFfPDv4Xs-7gHUBuz8v0xf8fvvE,3969
+meshcore/tcp_cx.py,sha256=05YRVMnjY5aVBTJcHa0uG4VfFKGbV6hQ1pPIsJg4CDI,4227
+meshcore/commands/__init__.py,sha256=qfGPzrha7pZQYHOXLZyDsK-QVRjiz5zxAEj8kMxO9uU,536
+meshcore/commands/base.py,sha256=yKfKSmdnIh0DhAZ34TtioE38huxXc0QGB5Hm_wbcOqg,7398
+meshcore/commands/binary.py,sha256=MihRjG4IppPYPeu2KMpctcBPac_hdClp6PgGirQfydg,8412
+meshcore/commands/contact.py,sha256=7X4e17M2YxUZsfUhaN18XZG2inTuXknXJOBAoPblydw,5880
+meshcore/commands/control_data.py,sha256=sXp1RoEw6Z0zPr0Nn5XBovEY6r9sePbWQwsbY0iYyXc,1512
+meshcore/commands/device.py,sha256=Ub8sS0xtJu3TJwENyswk8lYmYorMH3W33ppHEpSNpoU,9437
+meshcore/commands/messaging.py,sha256=Mglog1xCz_DhKJU1vEv0AD7bBo5_OhEul1MpSY7dnXc,9806
+meshcore-2.2.2.dist-info/METADATA,sha256=rgQoS5tlPN59QZPkaYmKja9Ah_M3pt0g95Xt_D7VlwE,25316
+meshcore-2.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meshcore-2.2.2.dist-info/licenses/LICENSE,sha256=o62-JWT_C-ZqEtzb1Gl_PPtPr0pVT8KDmgji_Y_bejI,1075
+meshcore-2.2.2.dist-info/RECORD,,

meshcore-2.1.17.dist-info/RECORD

@@ -1,21 +0,0 @@
-meshcore/__init__.py,sha256=55PdT8gZ9Lf727s7BdSuCt3lIBlAhRzX28A8i0DHaRc,602
-meshcore/ble_cx.py,sha256=S5uanBI88Mxwcs1zWbdQGVJ6GC4kdWz8-Z_2aQVpeGI,6864
-meshcore/connection_manager.py,sha256=3U0TWuHDvL5FfwEwXRy5HjlCyV3nsWhhrEC7TVxFzZI,5899
-meshcore/events.py,sha256=ZaVy2cCjujM3--xUDoUZqHZTq09R1rR8y3-_rLL8-fQ,8014
-meshcore/lpp_json_encoder.py,sha256=vyn7z3VYWOo_B9xmCzqblh5xCa0QKWKcMi2eOqw18RE,1875
-meshcore/meshcore.py,sha256=n8fH7AEx7DR8BHOYL_Qex9ns6ACKklNNqYbPnNnvqyE,16110
-meshcore/packets.py,sha256=2soo3H6FEbVdYk-ZQANIM3YpyCwsaIOrB4QIEJLLw0c,1072
-meshcore/parsing.py,sha256=48PQkig-sqvsRlkF9zkvWhJoSq6ERCbGb_aRuCND5NI,4044
-meshcore/reader.py,sha256=mIewSrfsgt-qe-acoxGQncHZhEhRr_3CEZuN1afnr7E,24784
-meshcore/serial_cx.py,sha256=-kaqnqk7Ydufu2DECFfPDv4Xs-7gHUBuz8v0xf8fvvE,3969
-meshcore/tcp_cx.py,sha256=05YRVMnjY5aVBTJcHa0uG4VfFKGbV6hQ1pPIsJg4CDI,4227
-meshcore/commands/__init__.py,sha256=NNmkTEcL-DLyuwKLUagEzpqe3C6ui2tETbu_mUd4p-I,441
-meshcore/commands/base.py,sha256=0bDHcNGlKoej03xJqzo_wL5ctoPQU5kcK1Ca5sZh1pk,7097
-meshcore/commands/binary.py,sha256=MVKXrT4pFSlzFkVFLBX988Eh57tRwunw4XPKBumbQNU,4890
-meshcore/commands/contact.py,sha256=-dRY68xZkDFP6-i53WujyWhEsXZsFRk98B3j3zBzaL4,5860
-meshcore/commands/device.py,sha256=vstyy1crvhGbDgCAtyCWyjj3X8F2CpMw1LFTOwoHh6M,8273
-meshcore/commands/messaging.py,sha256=MIVGM5G8J16qimKjCHdrlEiVJ4g_MsBaZKPvRJHJcLU,8306
-meshcore-2.1.17.dist-info/METADATA,sha256=ImPYOzshM7CKAhB-wRgqE3ZoN_0wIwE4Ksk3mRykENg,25317
-meshcore-2.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meshcore-2.1.17.dist-info/licenses/LICENSE,sha256=o62-JWT_C-ZqEtzb1Gl_PPtPr0pVT8KDmgji_Y_bejI,1075
-meshcore-2.1.17.dist-info/RECORD,,