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

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}")

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/device.py

@@ -106,9 +106,9 @@ 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])
 
@@ -120,10 +120,10 @@ class DeviceCommands(CommandHandlerBase):
         )
         data = (
             b"\x26"
-            + infos["manual_add_contacts"].to_bytes(1)
-            + telemetry_mode.to_bytes(1)
-            + infos["adv_loc_policy"].to_bytes(1)
-            + infos["multi_acks"].to_bytes(1)
+            + 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])
 
@@ -205,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

@@ -86,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:

meshcore/events.py

@@ -40,6 +40,9 @@ 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"

meshcore/packets.py

@@ -36,6 +36,7 @@ class PacketType(Enum):
     SIGN_START = 19
     SIGNATURE = 20
     CUSTOM_VARS = 21
+    STATS = 24
     BINARY_REQ = 50
     FACTORY_RESET = 51
     PATH_DISCOVERY = 52

meshcore/reader.py

@@ -1,5 +1,6 @@
 import logging
 import json
+import struct
 import time
 import io
 from typing import Any, Dict
@@ -51,7 +52,11 @@ class MessageReader:
 
     async def handle_rx(self, data: bytearray):
         dbuf = io.BytesIO(data)
-        packet_type_value = dbuf.read(1)[0]
+        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
@@ -286,6 +291,87 @@ 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 = {}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.1.24
+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.24.dist-info/RECORD

@@ -1,23 +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=P40oq3C9j2cEg6iD9_-SxWK927C3ykWBTpjL8ixygFQ,8140
-meshcore/lpp_json_encoder.py,sha256=vyn7z3VYWOo_B9xmCzqblh5xCa0QKWKcMi2eOqw18RE,1875
-meshcore/meshcore.py,sha256=n8fH7AEx7DR8BHOYL_Qex9ns6ACKklNNqYbPnNnvqyE,16110
-meshcore/packets.py,sha256=FT6GwH8rveLBWuFVMkbqnAuaymrk6uhd_t46Qj98uf4,1279
-meshcore/parsing.py,sha256=48PQkig-sqvsRlkF9zkvWhJoSq6ERCbGb_aRuCND5NI,4044
-meshcore/reader.py,sha256=inhn0Xsc7J0VKKyPVWwoM1LXfAKO-SJ4Th1c3sN4yy8,28645
-meshcore/serial_cx.py,sha256=-kaqnqk7Ydufu2DECFfPDv4Xs-7gHUBuz8v0xf8fvvE,3969
-meshcore/tcp_cx.py,sha256=05YRVMnjY5aVBTJcHa0uG4VfFKGbV6hQ1pPIsJg4CDI,4227
-meshcore/commands/.binary.py.swp,sha256=SXeYOAsKheJnezxgvzUUHL43qUQWEPyc-VZUMBRsGV8,24576
-meshcore/commands/__init__.py,sha256=qfGPzrha7pZQYHOXLZyDsK-QVRjiz5zxAEj8kMxO9uU,536
-meshcore/commands/base.py,sha256=jO6KWSxBciEMaP0weE8OAbN6Tf-kWSaljb9py3gvihg,7126
-meshcore/commands/binary.py,sha256=MihRjG4IppPYPeu2KMpctcBPac_hdClp6PgGirQfydg,8412
-meshcore/commands/contact.py,sha256=-dRY68xZkDFP6-i53WujyWhEsXZsFRk98B3j3zBzaL4,5860
-meshcore/commands/control_data.py,sha256=sXp1RoEw6Z0zPr0Nn5XBovEY6r9sePbWQwsbY0iYyXc,1512
-meshcore/commands/device.py,sha256=V-gxA88We1KLDtzJ-rsmxv5LH04sUOacqnBc6TwB_gg,8662
-meshcore/commands/messaging.py,sha256=5h0JecOT3KJV1AFdasVLs889xtXY4J5gguJ7KbUoZOE,9073
-meshcore-2.1.24.dist-info/METADATA,sha256=9Ks9G4ws_jzHVCUps3JJmpWjWZ7LoKj9pbCpSViIA2c,25317
-meshcore-2.1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meshcore-2.1.24.dist-info/licenses/LICENSE,sha256=o62-JWT_C-ZqEtzb1Gl_PPtPr0pVT8KDmgji_Y_bejI,1075
-meshcore-2.1.24.dist-info/RECORD,,