python-ecosys/debugpy: Add VS Code debugging support for MicroPython.

micropython/aiorepl/aiorepl.py

@@ -121,16 +121,22 @@ async def task(g=None, prompt="--> "):
                 pt = t  # save previous time
                 t = time.ticks_ms()
                 if c < 0x20 or c > 0x7E:
-                    if c == 0x0A:
-                        # LF
+                    if c == 0x0A or c == 0x0D:
+                        # LF or CR (handle both for raw terminal mode compatibility)
                         if paste:
+                            # In paste mode, preserve the actual character
                             sys.stdout.write(b)
                             cmd += b
                             continue
-                        # If the previous character was also LF, and was less
-                        # than 20 ms ago, this was likely due to CRLF->LFLF
-                        # conversion, so ignore this linefeed.
-                        if pc == 0x0A and time.ticks_diff(t, pt) < 20:
+                        # Handle various newline sequences to avoid double-execution:
+                        # - CR+LF (Windows style): ignore LF if it follows CR quickly
+                        # - LF+LF (PTY double-newline): ignore second LF if it follows quickly
+                        # - CR+CR (potential double-CR): ignore second CR if it follows quickly
+                        if (
+                            (c == 0x0A and pc == 0x0D)  # LF after CR (CRLF)
+                            or (c == 0x0A and pc == 0x0A)  # LF after LF (double LF)
+                            or (c == 0x0D and pc == 0x0D)
+                        ) and time.ticks_diff(t, pt) < 20:  # CR after CR
                             continue
                         if curs:
                             # move cursor to end of the line

micropython/aiorepl/manifest.py

@@ -1,5 +1,5 @@
 metadata(
-    version="0.2.2",
+    version="0.2.3",
     description="Provides an asynchronous REPL that can run concurrently with an asyncio, also allowing await expressions.",
 )
 

micropython/bluetooth/aioble-security/manifest.py

@@ -1,4 +1,4 @@
-metadata(version="0.2.0")
+metadata(version="0.2.1")
 
 require("aioble-core")
 

micropython/bluetooth/aioble/aioble/security.py

@@ -57,10 +57,6 @@ def _save_secrets(arg=None):
 
     _path = _path or _DEFAULT_PATH
 
-    if not _modified:
-        # Only save if the secrets changed.
-        return
-
     with open(_path, "w") as f:
         # Convert bytes to hex strings (otherwise JSON will treat them like
         # strings).
@@ -106,8 +102,9 @@ def _security_irq(event, data):
             _secrets[key] = value
 
         # Queue up a save (don't synchronously write to flash).
-        _modified = True
-        schedule(_save_secrets, None)
+        if not _modified:
+            _modified = True
+            schedule(_save_secrets, None)
 
         return True
 

micropython/bluetooth/aioble/manifest.py

@@ -3,7 +3,7 @@
 # code. This allows (for development purposes) all the files to live in the
 # one directory.
 
-metadata(version="0.6.1")
+metadata(version="0.6.2")
 
 # Default installation gives you everything. Install the individual
 # components (or a combination of them) if you want a more minimal install.

micropython/umqtt.simple/manifest.py

@@ -1,4 +1,4 @@
-metadata(description="Lightweight MQTT client for MicroPython.", version="1.7.1")
+metadata(description="Lightweight MQTT client for MicroPython.", version="1.8.0")
 
 # Originally written by Paul Sokolovsky.
 

micropython/umqtt.simple/test_umqtt_simple.py

@@ -0,0 +1,76 @@
+import io
+import sys
+
+
+class Socket:
+    def __init__(self, read_data=b""):
+        self._write_buffer = io.BytesIO()
+        self._read_buffer = io.BytesIO(read_data)
+
+    def write(self, buf, length=None):
+        if length is None:
+            length = len(buf)
+        self._write_buffer.write(buf[:length])
+
+    def read(self, n):
+        return self._read_buffer.read(n)
+
+    def setblocking(self, blocking):
+        pass
+
+    def close(self):
+        pass
+
+
+sys.path.insert(0, "micropython/umqtt.simple")
+# ruff: noqa: E402
+from umqtt.simple import MQTTClient
+
+
+def make_client(read_data):
+    c = MQTTClient(b"cid", "127.0.0.1")
+    c.sock = Socket(read_data)
+    c.set_callback(lambda topic, msg: None)
+    return c
+
+
+def test_subscribe_short_topic():
+    # Remaining Length = 5 + 4 = 9 -> single VBI byte 0x09, pid=1
+    c = make_client(b"\x90\x03\x00\x01\x00")
+    c.subscribe(b"abcd", qos=0)
+    out = c.sock._write_buffer.getvalue()
+    assert out[:2] == b"\x82\x09", out
+    assert out[2:4] == b"\x00\x01", out
+    assert out[4:6] == b"\x00\x04", out
+    assert out[6:10] == b"abcd", out
+    assert out[10:11] == b"\x00", out
+
+
+def test_subscribe_long_topic():
+    # Remaining Length = 5 + 123 = 128 -> VBI 0x80 0x01
+    topic = b"a" * 123
+    c = make_client(b"\x90\x03\x00\x01\x00")
+    c.subscribe(topic, qos=0)
+    out = c.sock._write_buffer.getvalue()
+    assert out[:3] == b"\x82\x80\x01", out
+    assert out[3:5] == b"\x00\x01", out
+    assert out[5:7] == b"\x00\x7b", out
+    assert out[7:130] == topic, out
+    assert out[130:131] == b"\x00", out
+
+
+def test_unsubscribe_long_topic():
+    # Remaining Length = 4 + 123 = 127 -> still one VBI byte; use 124 for 128
+    topic = b"a" * 124
+    c = make_client(b"\xb0\x02\x00\x01")
+    c.unsubscribe(topic)
+    out = c.sock._write_buffer.getvalue()
+    assert out[:3] == b"\xa2\x80\x01", out
+    assert out[3:5] == b"\x00\x01", out
+    assert out[5:7] == b"\x00\x7c", out
+    assert out[7:131] == topic, out
+
+
+test_subscribe_short_topic()
+test_subscribe_long_topic()
+test_unsubscribe_long_topic()

micropython/umqtt.simple/umqtt/simple.py

@@ -7,6 +7,16 @@ class MQTTException(Exception):
     pass
 
 
+def _encode_len(pkt, sz):
+    i = 1
+    while sz > 0x7F:
+        pkt[i] = (sz & 0x7F) | 0x80
+        sz >>= 7
+        i += 1
+    pkt[i] = sz
+    return i
+
+
 class MQTTClient:
     def __init__(
         self,
@@ -93,12 +103,7 @@ def connect(self, clean_session=True, timeout=None):
             msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
             msg[6] |= self.lw_retain << 5
 
-        i = 1
-        while sz > 0x7F:
-            premsg[i] = (sz & 0x7F) | 0x80
-            sz >>= 7
-            i += 1
-        premsg[i] = sz
+        i = _encode_len(premsg, sz)
 
         self.sock.write(premsg, i + 2)
         self.sock.write(msg)
@@ -130,12 +135,7 @@ def publish(self, topic, msg, retain=False, qos=0):
         if qos > 0:
             sz += 2
         assert sz < 2097152
-        i = 1
-        while sz > 0x7F:
-            pkt[i] = (sz & 0x7F) | 0x80
-            sz >>= 7
-            i += 1
-        pkt[i] = sz
+        i = _encode_len(pkt, sz)
         # print(hex(len(pkt)), hexlify(pkt, ":"))
         self.sock.write(pkt, i + 1)
         self._send_str(topic)
@@ -158,37 +158,33 @@ def publish(self, topic, msg, retain=False, qos=0):
         elif qos == 2:
             assert 0
 
-    def subscribe(self, topic, qos=0):
-        assert self.cb is not None, "Subscribe callback is not set"
-        pkt = bytearray(b"\x82\0\0\0")
+    def _send_subunsub(self, topic, typ, ack_op, ack_n, qos=0):
+        pkt = bytearray(4)
+        pkt[0] = typ
         self.pid += 1
-        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid)
-        # print(hex(len(pkt)), hexlify(pkt, ":"))
-        self.sock.write(pkt)
+        pid = self.pid
+        i = _encode_len(pkt, 4 + len(topic) + (ack_n > 3))
+        self.sock.write(pkt, i + 1)
+        struct.pack_into("!H", pkt, 0, pid)
+        self.sock.write(pkt, 2)
         self._send_str(topic)
-        self.sock.write(qos.to_bytes(1, "little"))
+        if ack_n > 3:
+            self.sock.write(bytes((qos,)))
         while 1:
             op = self.wait_msg()
-            if op == 0x90:
-                resp = self.sock.read(4)
-                # print(resp)
-                assert resp[1] == pkt[2] and resp[2] == pkt[3]
-                if resp[3] == 0x80:
+            if op == ack_op:
+                resp = self.sock.read(ack_n)
+                assert (resp[1] << 8 | resp[2]) == pid
+                if ack_n > 3 and resp[3] == 0x80:
                     raise MQTTException(resp[3])
                 return
 
+    def subscribe(self, topic, qos=0):
+        assert self.cb is not None, "Subscribe callback is not set"
+        self._send_subunsub(topic, 0x82, 0x90, 4, qos)
+
     def unsubscribe(self, topic):
-        pkt = bytearray(b"\xa2\0\0\0")
-        self.pid += 1
-        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic), self.pid)
-        self.sock.write(pkt)
-        self._send_str(topic)
-        while 1:
-            op = self.wait_msg()
-            if op == 0xB0:
-                resp = self.sock.read(3)
-                assert resp[1] == pkt[2] and resp[2] == pkt[3]
-                return
+        self._send_subunsub(topic, 0xA2, 0xB0, 3)
 
     # Wait for a single incoming MQTT message and process it.
     # Subscribed messages are delivered to a callback previously

micropython/usb/examples/device/cdc_repl_example.py

@@ -25,8 +25,8 @@
 import usb.device
 from usb.device.cdc import CDCInterface
 
-cdc = CDCInterface()
-cdc.init(timeout=0)  # zero timeout makes this non-blocking, suitable for os.dupterm()
+# Zero timeout makes this non-blocking, suitable for os.dupterm().
+cdc = CDCInterface(timeout=0)
 
 # pass builtin_driver=True so that we get the built-in USB-CDC alongside,
 # if it's available.

micropython/usb/usb-device-cdc/manifest.py

@@ -1,3 +1,3 @@
-metadata(version="0.1.2")
+metadata(version="0.1.4")
 require("usb-device")
 package("usb")

micropython/usb/usb-device-cdc/usb/device/cdc.py

@@ -107,22 +107,18 @@ def __init__(self, **kwargs):
         self.line_coding_cb = None
 
         self._line_state = 0  # DTR & RTS
-        # Set a default line coding of 115200/8N1
-        self._line_coding = bytearray(b"\x00\xc2\x01\x00\x00\x00\x08")
-
-        self._wb = ()  # Optional write Buffer (IN endpoint), set by CDC.init()
-        self._rb = ()  # Optional read Buffer (OUT endpoint), set by CDC.init()
-        self._timeout = 1000  # set from CDC.init() as well
+        self._line_coding = bytearray(7)  # Will be populated by .init()
 
         # one control interface endpoint, two data interface endpoints
         self.ep_c_in = self.ep_d_in = self.ep_d_out = None
 
         self._c_itf = None  # Number of control interface, data interface is one more
 
+        # The _timeout, _wb and _rb attributes will be set by this call to .init().
         self.init(**kwargs)
 
     def init(
-        self, baudrate=9600, bits=8, parity="N", stop=1, timeout=None, txbuf=256, rxbuf=256, flow=0
+        self, baudrate=9600, bits=8, parity="N", stop=1, timeout=1000, txbuf=256, rxbuf=256, flow=0
     ):
         # Configure the CDC serial port. Note that many of these settings like
         # baudrate, bits, parity, stop don't change the USB-CDC device behavior