meshcore 2.3.10__tar.gz → 2.3.12__tar.gz

{meshcore-2.3.10 → meshcore-2.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: meshcore
-Version: 2.3.10
+Version: 2.3.12
 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.3.10 → meshcore-2.3.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "2.3.10"
+version = "2.3.12"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },

{meshcore-2.3.10 → meshcore-2.3.12}/src/meshcore/commands/device.py

@@ -11,10 +11,13 @@ logger = logging.getLogger("meshcore")
 
 
 class DeviceCommands(CommandHandlerBase):
-    async def send_appstart(self) -> Event:
+    async def send_appstart(self, timeout=None) -> Event:
         logger.debug("Sending appstart command")
         b1 = bytearray(b"\x01\x03      mccli")
-        return await self.send(b1, [EventType.SELF_INFO, EventType.ERROR])
+        if timeout is None:
+            return await self.send(b1, [EventType.SELF_INFO, EventType.ERROR])
+        else:
+            return await self.send(b1, [EventType.SELF_INFO, EventType.ERROR], timeout=timeout)
 
     async def send_device_query(self) -> Event:
         logger.debug("Sending device query command")

{meshcore-2.3.10 → meshcore-2.3.12}/src/meshcore/commands/messaging.py

@@ -114,31 +114,29 @@ class MessagingCommands(CommandHandlerBase):
         max_attempts=3, max_flood_attempts=2, flood_after=2, timeout=0, min_timeout=0
     ) -> Event:
 
+        # try to get a 32 bytes key (for flood reset), fallback to 6
         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())
+        if not contact is None and len(dst_bytes) < 32 :
+            # if we have a contact then we can get full key
+            dst_bytes = _validate_destination(contact, prefix_length=32)
 
         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:
-            # 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}")
+        flood = False # by default consider we sent direct (will be overriden after send)
         res = None
         while attempts < max_attempts and res is None \
                     and (not flood or flood_attempts < max_flood_attempts):
-            if attempts == flood_after and not flood: # change path to flood
+            if attempts == flood_after and not flood : # change path to flood
+                if len(dst_bytes) < 32: # can only reset with full key
+                    logger.info("Don't have full key, retreiving contacts so we can reset path")
+                    await self.get_contacts()
+                    contact = self._get_contact_by_prefix(dst_bytes.hex())
+                    if not contact is None:
+                        dst_bytes = _validate_destination(contact, prefix_length=32)
                 logger.info("Resetting path")
                 rp_res = await self.reset_path(dst_bytes)
                 if rp_res.type == EventType.ERROR:
@@ -160,12 +158,13 @@ class MessagingCommands(CommandHandlerBase):
                     flood_attempts += 1
                 continue
 
+            flood = result.payload["type"] == 1 # we can sync flood flag from result ...
             exp_ack = result.payload["expected_ack"].hex()
-            timeout = result.payload["suggested_timeout"] / 1000 * 1.2 if timeout==0 else timeout
-            timeout = timeout if timeout > min_timeout else min_timeout
+            atimeout = result.payload["suggested_timeout"] / 1000 * 1.2 if timeout==0 else timeout
+            atimeout = atimeout if atimeout > min_timeout else min_timeout
             res = await self.dispatcher.wait_for_event(EventType.ACK,
                         attribute_filters={"code": exp_ack},
-                        timeout=timeout)
+                        timeout=atimeout)
 
             attempts = attempts + 1
             if flood :

{meshcore-2.3.10 → meshcore-2.3.12}/src/meshcore/meshcore.py

@@ -118,9 +118,11 @@ class MeshCore:
         auto_reconnect: bool = False,
         max_reconnect_attempts: int = 3,
         cx_dly: float = 0.1,
+        rts = False,
+        dtr = True
     ) -> "MeshCore":
         """Create and connect a MeshCore instance using serial connection"""
-        connection = SerialConnection(port, baudrate, cx_dly=cx_dly)
+        connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=dtr)
 
         mc = cls(
             connection,
@@ -131,6 +133,19 @@ class MeshCore:
             max_reconnect_attempts=max_reconnect_attempts,
         )
         res = await mc.connect()
+        if res is None:
+            logger.info("No response from meshcore node, trying to invert dtr")
+            await mc.disconnect()
+            connection = SerialConnection(port, baudrate, cx_dly=cx_dly, rts=rts, dtr=not dtr)
+            mc = cls(
+                connection,
+                debug=debug,
+                only_error=only_error,
+                default_timeout=default_timeout,
+                auto_reconnect=auto_reconnect,
+                max_reconnect_attempts=max_reconnect_attempts,
+            )
+            res = await mc.connect()
         if res is None:
             logger.error("No response from meshcore node, disconnecting")
             logger.error("Are you sure your node is a serial companion ?")
@@ -188,7 +203,7 @@ class MeshCore:
         to initialize the session.  MeshCore.connect() does this on the initial
         connection; this callback ensures it also happens on reconnects (F02).
         """
-        await self.commands.send_appstart()
+        await self.commands.send_appstart(timeout=2)
 
     async def connect(self):
         await self.dispatcher.start()
@@ -196,7 +211,7 @@ class MeshCore:
         if result is None:
             await self.dispatcher.stop()
             raise ConnectionError("Failed to connect to device")
-        res = await self.commands.send_appstart()
+        res = await self.commands.send_appstart(timeout=2)
         if res is None or res.type == EventType.ERROR:
             return None
         return res

{meshcore-2.3.10 → meshcore-2.3.12}/src/meshcore/serial_cx.py

@@ -11,7 +11,7 @@ logger = logging.getLogger("meshcore")
 
 
 class SerialConnection:
-    def __init__(self, port, baudrate, cx_dly=0.2):
+    def __init__(self, port, baudrate, cx_dly=0.2, rts=False, dtr=True):
         self.port = port
         self.baudrate = baudrate
         self.transport = None
@@ -21,6 +21,8 @@ class SerialConnection:
         self.cx_dly = cx_dly
         self._connected_event = asyncio.Event()
         self._background_tasks: set[asyncio.Task] = set()
+        self.rts = rts
+        self.dtr = dtr
 
         self.frame_expected_size = 0
         self.inframe = b""
@@ -41,8 +43,8 @@ class SerialConnection:
             self.cx.transport = transport
             logger.debug('port opened')
             if isinstance(transport, serial_asyncio.SerialTransport) and transport.serial:
-                transport.serial.dtr = False  # Deassert DTR to avoid serial-open reset/handshake issues
-                transport.serial.rts = False  # You can manipulate Serial object via transport
+                transport.serial.dtr = self.cx.dtr  # DTR should be deasserted on heltec_v2 to avoid serial-open reset/handshake issues
+                transport.serial.rts = self.cx.rts
             self.cx._connected_event.set()
 
         def data_received(self, data):