meshcore 1.9.7__tar.gz → 1.9.8.dev2__tar.gz

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 1.9.7
+Version: 1.9.8.dev2
 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
@@ -11,6 +11,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: bleak
+Requires-Dist: pycayennelpp
 Requires-Dist: pyserial-asyncio
 Provides-Extra: dev
 Requires-Dist: pytest; extra == 'dev'

meshcore-1.9.8.dev2/examples/ble_t1000_custom_vars.py

@@ -0,0 +1,17 @@
+#!/usr/bin/python
+
+import asyncio
+from meshcore import MeshCore
+from meshcore import BLEConnection
+
+ADDRESS = "T1000_S" # node ble adress or name
+
+async def main () :
+    con  = BLEConnection(ADDRESS)
+    await con.connect()
+    mc = MeshCore(con)
+    await mc.connect()
+
+    print(await mc.commands.get_custom_vars())
+
+asyncio.run(main())

meshcore-1.9.8.dev2/examples/ble_t1000_set_cv.py

@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import asyncio
+from meshcore import MeshCore
+from meshcore import BLEConnection
+
+ADDRESS = "T1000_S" # node ble adress or name
+VAR = "gps"
+VALUE = "1"
+
+async def main () :
+    con  = BLEConnection(ADDRESS)
+    await con.connect()
+    mc = MeshCore(con, debug=True)
+    await mc.connect()
+
+    print(await mc.commands.set_custom_var(VAR, VALUE))
+
+
+asyncio.run(main())

meshcore-1.9.8.dev2/examples/serial_repeater_telemetry.py

@@ -0,0 +1,61 @@
+#!/usr/bin/python
+
+import asyncio
+import argparse
+
+from meshcore import MeshCore
+from meshcore.events import EventType
+
+async def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Get status from a repeater via serial connection')
+    parser.add_argument('-p', '--port', required=True, help='Serial port')
+    parser.add_argument('-b', '--baudrate', type=int, default=115200, help='Baud rate')
+    parser.add_argument('-r', '--repeater', required=True, help='Repeater name')
+    parser.add_argument('-pw', '--password', required=True, help='Password for login')
+    parser.add_argument('-t', '--timeout', type=float, default=10.0, help='Timeout for responses in seconds')
+    args = parser.parse_args()
+
+    # Connect to the device
+    mc = await MeshCore.create_serial(args.port, args.baudrate, debug=True)
+    
+    try:
+        # Get contacts
+        await mc.ensure_contacts()
+        repeater = mc.get_contact_by_name(args.repeater)
+        
+        if repeater is None:
+            print(f"Repeater '{args.repeater}' not found in contacts.")
+            return
+        
+        # Send login request
+        print(f"Logging in to repeater '{args.repeater}'...")
+        login_event = await mc.commands.send_login(repeater, args.password)
+        
+        if login_event.type != EventType.ERROR:
+            print("Login successful")
+            
+            # Send status request
+            print("Sending status request...")
+            await mc.commands.send_telemetry_req(repeater)
+            
+            # Wait for status response
+            telemetry_event = await mc.wait_for_event(EventType.TELEMETRY_RESPONSE, timeout=args.timeout)
+            print(telemetry_event.payload["lpp"])
+            
+            
+        else:
+            print("Login failed or timed out")
+    
+    finally:
+        # Always disconnect properly
+        await mc.disconnect()
+        print("Disconnected from device")
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nOperation cancelled by user")
+    except Exception as e:
+        print(f"Error: {e}")

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "1.9.7"
+version = "1.9.8.dev2"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },
@@ -18,7 +18,7 @@ classifiers = [
 ]
 license = "MIT"
 license-files = ["LICEN[CS]E*"]
-dependencies = [ "bleak", "pyserial-asyncio" ]
+dependencies = [ "bleak", "pyserial-asyncio", "pycayennelpp" ]
 
 [project.optional-dependencies]
 dev = ["pytest", "pytest-asyncio"]

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/src/meshcore/commands.py

@@ -306,6 +306,28 @@ class CommandHandler:
         data = b"\x03\x00" + chan.to_bytes(1, 'little') + timestamp + msg.encode("utf-8")
         return await self.send(data, [EventType.OK, EventType.ERROR])
         
+    async def send_other_params(self, manual_add_contacts : bool, telemetry_mode_base : bool, telemetry_mode_loc : bool) :
+        telemetry_mode = (telemetry_mode_base & 0b11) | ((telemetry_mode_loc & 0b11) << 2)
+        data = b"\x26" + manual_add_contacts.to_bytes(1) + telemetry_mode.to_bytes(1) 
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
+    async def send_telemetry_req(self, dst: DestinationType) -> Event :
+        dst_bytes = _validate_destination(dst, prefix_length=32)
+        logger.debug(f"Asking telemetry to {dst_bytes.hex()}")
+
+        data = b"\x27\x00\x00\x00" + dst_bytes
+        return await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
+
+    async def get_custom_vars(self) -> Event:
+        logger.debug(f"Asking for custom vars")
+        data = b"\x28"
+        return await self.send(data, [EventType.CUSTOM_VARS, EventType.ERROR])
+
+    async def set_custom_var(self, key, value) -> Event:
+        logger.debug(f"Setting custom var {key} to {value}")
+        data = b"\x29" + key.encode("utf-8") + b":" + value.encode("utf-8")
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
     async def send_cli(self, cmd) -> Event:
         logger.debug(f"Sending CLI command: {cmd}")
         data = b"\x32" + cmd.encode('utf-8')

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/src/meshcore/events.py

@@ -33,6 +33,8 @@ class EventType(Enum):
     LOG_DATA = "log_data"
     TRACE_DATA = "trace_data"
     RX_LOG_DATA = "rx_log_data"
+    TELEMETRY_RESPONSE = "telemetry_response"
+    CUSTOM_VARS = "custom_vars"
     
     # Command response types
     OK = "command_ok"
@@ -182,4 +184,4 @@ class EventDispatcher:
         except asyncio.TimeoutError:
             return None
         finally:
-            subscription.unsubscribe()
+            subscription.unsubscribe()

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/src/meshcore/packets.py

@@ -16,6 +16,14 @@ class PacketType(Enum):
     CONTACT_URI = 11
     BATTERY = 12
     DEVICE_INFO = 13
+    PRIVATE_KEY = 14
+    DISABLED = 15
+    CONTACT_MSG_RECV_V3 = 16
+    CHANNEL_MSG_RECV_V3 = 17
+    CHANNEL_INFO = 18
+    SIGN_START = 19
+    SIGNATURE = 20
+    CUSTOM_VARS = 21
     CLI_RESPONSE = 50
     
     # Push notifications
@@ -28,4 +36,6 @@ class PacketType(Enum):
     LOGIN_FAILED = 0x86
     STATUS_RESPONSE = 0x87
     LOG_DATA = 0x88
-    TRACE_DATA = 0x89
+    TRACE_DATA = 0x89
+    PUSH_CODE_NEW_ADVERT = 0x8A
+    TELEMETRY_RESPONSE = 0x8B

{meshcore-1.9.7 → meshcore-1.9.8.dev2}/src/meshcore/reader.py

@@ -1,6 +1,8 @@
 import sys
 import logging
 import asyncio
+import json
+from cayennelpp import LppFrame, LppData, LppUtil
 from typing import Any, Optional, Dict
 from .events import Event, EventType, EventDispatcher
 from .packets import PacketType
@@ -71,6 +73,9 @@ class MessageReader:
             self_info["public_key"] = data[4:36].hex()
             self_info["adv_lat"] = int.from_bytes(data[36:40], byteorder='little', signed=True)/1e6
             self_info["adv_lon"] = int.from_bytes(data[40:44], byteorder='little', signed=True)/1e6
+            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["radio_freq"] = int.from_bytes(data[48:52], byteorder='little') / 1000
             self_info["radio_bw"] = int.from_bytes(data[52:56], byteorder='little') / 1000
             self_info["radio_sf"] = data[56]
@@ -201,6 +206,18 @@ class MessageReader:
             res["response"] = data[1:].decode()
             await self.dispatcher.dispatch(Event(EventType.CLI_RESPONSE, res))
             
+        elif packet_type_value == PacketType.CUSTOM_VARS.value:
+            logger.debug(f"received custom vars response: {data.hex()}")
+            res = {}
+            rawdata = data[1:].decode()
+            if not rawdata == "" :
+                pairs = rawdata.split(",")
+                for p in pairs :
+                    psplit = p.split(":")
+                    res[psplit[0]] = psplit[1]
+            logger.debug(f"got custom vars : {res}")
+            await self.dispatcher.dispatch(Event(EventType.CUSTOM_VARS, res))   
+
         # Push notifications
         elif packet_type_value == PacketType.ADVERTISEMENT.value:
             logger.debug("Advertisement received")
@@ -358,7 +375,34 @@ class MessageReader:
             }
             
             await self.dispatcher.dispatch(Event(EventType.TRACE_DATA, res, attributes))
+
+        elif packet_type_value == PacketType.TELEMETRY_RESPONSE.value:
+            logger.debug(f"Received telemetry data: {data.hex()}")
+            res = {}
+
+            res["pubkey_pre"] = data[2:8].hex()
+            buf = data[8:]
+            res["data"] = buf.hex()
+
+            """Parse a given byte string and return as a LppFrame object."""
+            i = 0
+            data = []
+            while i < len(buf) and buf[i] != 0:
+                lppdata = LppData.from_bytes(buf[i:])
+                data.append(lppdata)
+                i = i + len(lppdata)
+
+            lpp = json.loads(json.dumps(LppFrame(data), default=LppUtil.json_encode_type_str))
+
+            res["lpp"] = lpp
+
+            attributes = {
+                "raw" : buf.hex(),
+            }
             
+            await self.dispatcher.dispatch(Event(EventType.TELEMETRY_RESPONSE, res, attributes))
+
         else:
             logger.debug(f"Unhandled data received {data}")
-            logger.debug(f"Unhandled packet type: {packet_type_value}")
+            logger.debug(f"Unhandled packet type: {packet_type_value}")
+