mpremote: Add automatic reconnect feature.

This adds a `reconnect` command that enables automatic reconnection
when a device disconnects. The reconnect feature:

- Always reconnects to the exact same port, even when using `auto`
- Shows clear status messages during reconnection
- Preserves resume state through reconnections
- Handles Windows timing issues with retry logic

Usage: mpremote connect auto reconnect repl

The reconnect command remembers the actual device path that was
connected (e.g., /dev/ttyACM2) and only reconnects to that specific
device, preventing accidental connections to different boards.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

docs/reference/mpremote.rst

@@ -90,7 +90,7 @@ The full list of supported commands are:
 
   .. code-block:: bash
 
-      $ mpremote connect <device>
+      $ mpremote connect [--options] <device>
 
   ``<device>`` may be one of:
 
@@ -135,6 +135,19 @@ The full list of supported commands are:
   This disables :ref:`auto-soft-reset <mpremote_reset>`. This is useful if you
   want to run a subsequent command on a board without first soft-resetting it.
 
+.. _mpremote_command_reconnect:
+
+- **reconnect** -- enable automatic reconnection on disconnect:
+
+  .. code-block:: bash
+
+      $ mpremote reconnect
+
+  This enables automatic reconnection to the same device if it disconnects.
+  When the device disconnects, mpremote will wait for it to reconnect instead
+  of exiting. This is useful for development where devices may be unplugged
+  and replugged frequently.
+
 .. _mpremote_command_soft_reset:
 
 - **soft-reset** -- perform a soft-reset of the device:

tools/mpremote/mpremote/commands.py

@@ -5,6 +5,7 @@
 import sys
 import tempfile
 import zlib
+import time
 
 import serial.tools.list_ports
 
@@ -43,6 +44,8 @@ def do_connect(state, args=None):
                 if p.vid is not None and p.pid is not None:
                     try:
                         state.transport = SerialTransport(p.device, baudrate=115200)
+                        # Store the actual device path for reconnect
+                        state.connect_device = p.device
                         return
                     except TransportError as er:
                         if not er.args[0].startswith("failed to access"):
@@ -55,13 +58,17 @@ def do_connect(state, args=None):
             for p in serial.tools.list_ports.comports():
                 if p.serial_number == serial_number:
                     state.transport = SerialTransport(p.device, baudrate=115200)
+                    # Store the actual device path for reconnect
+                    state.connect_device = p.device
                     return
             raise TransportError("no device with serial number {}".format(serial_number))
         else:
             # Connect to the given device.
             if dev.startswith("port:"):
                 dev = dev[len("port:") :]
             state.transport = SerialTransport(dev, baudrate=115200)
+            # Store the actual device path for reconnect
+            state.connect_device = dev
             return
     except TransportError as er:
         msg = er.args[0]
@@ -70,6 +77,46 @@ def do_connect(state, args=None):
         raise CommandError(msg)
 
 
+def do_reconnect(state):
+    """Attempt to reconnect to the same device after disconnect."""
+    if not state.reconnect_enabled or not state.connect_device:
+        return False
+
+    # Always show the specific device we're waiting for
+    device_name = state.connect_device
+    print(f"Waiting for reconnection on {device_name}...")
+
+    # Add a small initial delay to let the device fully disconnect
+    time.sleep(1)
+
+    while True:
+        try:
+            # Always try to reconnect to the specific device path that was connected
+            dev = state.connect_device
+
+            # Try multiple times for the specific port
+            for attempt in range(3):
+                try:
+                    state.transport = SerialTransport(dev, baudrate=115200)
+                    # Restore resume state if it was set
+                    if state.was_resumed:
+                        state._auto_soft_reset = False
+                    # Give the device a moment to stabilize
+                    time.sleep(0.5)
+                    return True
+                except TransportError:
+                    if attempt < 2:  # Not the last attempt
+                        time.sleep(0.5)  # Wait a bit before retry
+                    else:
+                        pass  # Last attempt failed, continue to wait
+
+        except Exception:
+            pass
+
+        # Wait before retrying
+        time.sleep(1)
+
+
 def do_disconnect(state, _args=None):
     if not state.transport:
         return
@@ -484,6 +531,15 @@ def do_umount(state, path):
 
 def do_resume(state, _args=None):
     state._auto_soft_reset = False
+    state.was_resumed = True
+
+
+def do_reconnect_cmd(state, _args=None):
+    """Enable automatic reconnection on disconnect."""
+    state.reconnect_enabled = True
+    # If we're already connected, store the current device
+    if state.transport:
+        state.connect_device = state.transport.device_name
 
 
 def do_soft_reset(state, _args=None):

tools/mpremote/mpremote/main.py

@@ -26,6 +26,8 @@
     CommandError,
     do_connect,
     do_disconnect,
+    do_reconnect,
+    do_reconnect_cmd,
     do_edit,
     do_filesystem,
     do_mount,
@@ -281,6 +283,10 @@ def argparse_none(description):
         do_resume,
         argparse_none("resume a previous mpremote session (will not auto soft-reset)"),
     ),
+    "reconnect": (
+        do_reconnect_cmd,
+        argparse_none("enable automatic reconnection on disconnect"),
+    ),
     "soft-reset": (
         do_soft_reset,
         argparse_none("perform a soft-reset of the device"),
@@ -493,6 +499,9 @@ def __init__(self):
         self.transport = None
         self._did_action = False
         self._auto_soft_reset = True
+        self.reconnect_enabled = False
+        self.connect_device = None
+        self.was_resumed = False
 
     def did_action(self):
         self._did_action = True
@@ -574,11 +583,24 @@ def main():
         # If no commands were "actions" then implicitly finish with the REPL
         # using default args.
         if state.run_repl_on_completion():
-            disconnected = do_repl(state, argparse_repl().parse_args([]))
-
-            # Handle disconnection message
-            if disconnected:
-                print("\ndevice disconnected")
+            while True:
+                disconnected = do_repl(state, argparse_repl().parse_args([]))
+
+                # Handle disconnection message
+                if disconnected:
+                    print("\nDevice disconnected")
+
+                    # Try to reconnect if enabled
+                    if state.reconnect_enabled:
+                        do_disconnect(state)  # Clean up current connection state
+                        if do_reconnect(state):
+                            # Successfully reconnected, continue the loop
+                            # Reset action state for the new connection
+                            state._did_action = False
+                            continue
+
+                # If not reconnecting or reconnect failed, exit
+                break
 
         return 0
     except CommandError as e: