Merge branch 'micropython:master' into patch-1

Author: dotdashnotdotsoftware

.github/workflows/build_packages.yml

@@ -23,7 +23,7 @@ jobs:
       if: vars.MICROPY_PUBLISH_MIP_INDEX && github.event_name == 'push' && ! github.event.deleted
       run: source tools/ci.sh && ci_push_package_index
     - name: Upload packages as artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: packages-${{ github.sha }}
         path: ${{ env.PACKAGE_INDEX_PATH }}

.github/workflows/ruff.yml

@@ -6,6 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - run: pip install --user ruff==0.1.2
+    # Version should be kept in sync with .pre-commit_config.yaml & also micropython
+    - run: pip install --user ruff==0.11.6
     - run: ruff check --output-format=github .
     - run: ruff format --diff .

.pre-commit-config.yaml

@@ -8,7 +8,8 @@ repos:
         verbose: true
         stages: [commit-msg]
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.1.2
+    # Version should be kept in sync with .github/workflows/ruff.yml & also micropython
+    rev: v0.11.6
     hooks:
       - id: ruff
         id: ruff-format

micropython/aioespnow/README.md

@@ -55,7 +55,7 @@ A small async server example::
     import asyncio
 
     # A WLAN interface must be active to send()/recv()
-    network.WLAN(network.STA_IF).active(True)
+    network.WLAN(network.WLAN.IF_STA).active(True)
 
     e = aioespnow.AIOESPNow()  # Returns AIOESPNow enhanced with async support
     e.active(True)

micropython/aiorepl/aiorepl.py

@@ -132,7 +132,7 @@ async def task(g=None, prompt="--> "):
                             continue
                         if curs:
                             # move cursor to end of the line
-                            sys.stdout.write("\x1B[{}C".format(curs))
+                            sys.stdout.write("\x1b[{}C".format(curs))
                             curs = 0
                         sys.stdout.write("\n")
                         if cmd:
@@ -153,10 +153,10 @@ async def task(g=None, prompt="--> "):
                             if curs:
                                 cmd = "".join((cmd[: -curs - 1], cmd[-curs:]))
                                 sys.stdout.write(
-                                    "\x08\x1B[K"
+                                    "\x08\x1b[K"
                                 )  # move cursor back, erase to end of line
                                 sys.stdout.write(cmd[-curs:])  # redraw line
-                                sys.stdout.write("\x1B[{}D".format(curs))  # reset cursor location
+                                sys.stdout.write("\x1b[{}D".format(curs))  # reset cursor location
                             else:
                                 cmd = cmd[:-1]
                                 sys.stdout.write("\x08 \x08")
@@ -207,21 +207,21 @@ async def task(g=None, prompt="--> "):
                         elif key == "[D":  # left
                             if curs < len(cmd) - 1:
                                 curs += 1
-                                sys.stdout.write("\x1B")
+                                sys.stdout.write("\x1b")
                                 sys.stdout.write(key)
                         elif key == "[C":  # right
                             if curs:
                                 curs -= 1
-                                sys.stdout.write("\x1B")
+                                sys.stdout.write("\x1b")
                                 sys.stdout.write(key)
                         elif key == "[H":  # home
                             pcurs = curs
                             curs = len(cmd)
-                            sys.stdout.write("\x1B[{}D".format(curs - pcurs))  # move cursor left
+                            sys.stdout.write("\x1b[{}D".format(curs - pcurs))  # move cursor left
                         elif key == "[F":  # end
                             pcurs = curs
                             curs = 0
-                            sys.stdout.write("\x1B[{}C".format(pcurs))  # move cursor right
+                            sys.stdout.write("\x1b[{}C".format(pcurs))  # move cursor right
                     else:
                         # sys.stdout.write("\\x")
                         # sys.stdout.write(hex(c))
@@ -231,7 +231,7 @@ async def task(g=None, prompt="--> "):
                         # inserting into middle of line
                         cmd = "".join((cmd[:-curs], b, cmd[-curs:]))
                         sys.stdout.write(cmd[-curs - 1 :])  # redraw line to end
-                        sys.stdout.write("\x1B[{}D".format(curs))  # reset cursor location
+                        sys.stdout.write("\x1b[{}D".format(curs))  # reset cursor location
                     else:
                         sys.stdout.write(b)
                         cmd += b

micropython/bluetooth/aioble-central/manifest.py

@@ -1,4 +1,4 @@
-metadata(version="0.2.2")
+metadata(version="0.3.0")
 
 require("aioble-core")
 

micropython/bluetooth/aioble-core/manifest.py

@@ -1,4 +1,4 @@
-metadata(version="0.3.0")
+metadata(version="0.4.0")
 
 package(
     "aioble",

micropython/bluetooth/aioble/aioble/central.py

@@ -104,7 +104,9 @@ async def _cancel_pending():
 
 # Start connecting to a peripheral.
 # Call device.connect() rather than using method directly.
-async def _connect(connection, timeout_ms):
+async def _connect(
+    connection, timeout_ms, scan_duration_ms, min_conn_interval_us, max_conn_interval_us
+):
     device = connection.device
     if device in _connecting:
         return
@@ -122,7 +124,13 @@ async def _connect(connection, timeout_ms):
 
     try:
         with DeviceTimeout(None, timeout_ms):
-            ble.gap_connect(device.addr_type, device.addr)
+            ble.gap_connect(
+                device.addr_type,
+                device.addr,
+                scan_duration_ms,
+                min_conn_interval_us,
+                max_conn_interval_us,
+            )
 
             # Wait for the connected IRQ.
             await connection._event.wait()

micropython/bluetooth/aioble/aioble/device.py

@@ -132,14 +132,26 @@ def __str__(self):
     def addr_hex(self):
         return binascii.hexlify(self.addr, ":").decode()
 
-    async def connect(self, timeout_ms=10000):
+    async def connect(
+        self,
+        timeout_ms=10000,
+        scan_duration_ms=None,
+        min_conn_interval_us=None,
+        max_conn_interval_us=None,
+    ):
         if self._connection:
             return self._connection
 
         # Forward to implementation in central.py.
         from .central import _connect
 
-        await _connect(DeviceConnection(self), timeout_ms)
+        await _connect(
+            DeviceConnection(self),
+            timeout_ms,
+            scan_duration_ms,
+            min_conn_interval_us,
+            max_conn_interval_us,
+        )
 
         # Start the device task that will clean up after disconnection.
         self._connection._run_task()

micropython/bluetooth/aioble/examples/l2cap_file_client.py

@@ -88,7 +88,7 @@ async def download(self, path, dest):
 
         await self._command(_COMMAND_SEND, path.encode())
 
-        with open(dest, "wb") as f:  # noqa: ASYNC101
+        with open(dest, "wb") as f:  # noqa: ASYNC230
             total = 0
             buf = bytearray(self._channel.our_mtu)
             mv = memoryview(buf)

micropython/bluetooth/aioble/examples/l2cap_file_server.py

@@ -83,7 +83,7 @@ async def l2cap_task(connection):
 
             if send_file:
                 print("Sending:", send_file)
-                with open(send_file, "rb") as f:  # noqa: ASYNC101
+                with open(send_file, "rb") as f:  # noqa: ASYNC230
                     buf = bytearray(channel.peer_mtu)
                     mv = memoryview(buf)
                     while n := f.readinto(buf):

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.5.2")
+metadata(version="0.6.0")
 
 # Default installation gives you everything. Install the individual
 # components (or a combination of them) if you want a more minimal install.

micropython/drivers/codec/wm8960/wm8960.py

@@ -331,8 +331,7 @@ def __init__(
                 sysclk = 11289600
             else:
                 sysclk = 12288000
-            if sysclk < sample_rate * 256:
-                sysclk = sample_rate * 256
+            sysclk = max(sysclk, sample_rate * 256)
             if mclk_freq is None:
                 mclk_freq = sysclk
         else:  # sysclk_source == SYSCLK_MCLK
@@ -691,10 +690,8 @@ def alc_mode(self, channel, mode=ALC_MODE):
     def alc_gain(self, target=-12, max_gain=30, min_gain=-17.25, noise_gate=-78):
         def limit(value, minval, maxval):
             value = int(value)
-            if value < minval:
-                value = minval
-            if value > maxval:
-                value = maxval
+            value = max(value, minval)
+            value = min(value, maxval)
             return value
 
         target = limit((16 + (target * 2) // 3), 0, 15)
@@ -718,8 +715,7 @@ def logb(value, limit):
             while value > 1:
                 value >>= 1
                 lb += 1
-            if lb > limit:
-                lb = limit
+            lb = min(lb, limit)
             return lb
 
         attack = logb(attack / 6, 7)

micropython/drivers/display/lcd160cr/lcd160cr.py

@@ -189,10 +189,8 @@ def clip_line(c, w, h):
                         c[3] = h - 1
                 else:
                     if c[0] == c[2]:
-                        if c[1] < 0:
-                            c[1] = 0
-                        if c[3] < 0:
-                            c[3] = 0
+                        c[1] = max(c[1], 0)
+                        c[3] = max(c[3], 0)
                     else:
                         if c[3] < c[1]:
                             c[0], c[2] = c[2], c[0]

micropython/drivers/imu/lsm9ds1/lsm9ds1.py

@@ -43,6 +43,7 @@
     print("")
     time.sleep_ms(100)
 """
+
 import array
 from micropython import const
 

micropython/drivers/radio/nrf24l01/manifest.py

@@ -1,3 +1,3 @@
-metadata(description="nrf24l01 2.4GHz radio driver.", version="0.1.0")
+metadata(description="nrf24l01 2.4GHz radio driver.", version="0.2.0")
 
 module("nrf24l01.py", opt=3)

micropython/drivers/radio/nrf24l01/nrf24l01.py

@@ -1,5 +1,4 @@
-"""NRF24L01 driver for MicroPython
-"""
+"""NRF24L01 driver for MicroPython"""
 
 from micropython import const
 import utime
@@ -130,6 +129,13 @@ def reg_write(self, reg, value):
         self.cs(1)
         return ret
 
+    def read_status(self):
+        self.cs(0)
+        # STATUS register is always shifted during command transmit
+        self.spi.readinto(self.buf, NOP)
+        self.cs(1)
+        return self.buf[0]
+
     def flush_rx(self):
         self.cs(0)
         self.spi.readinto(self.buf, FLUSH_RX)
@@ -220,14 +226,21 @@ def send(self, buf, timeout=500):
         result = None
         while result is None and utime.ticks_diff(utime.ticks_ms(), start) < timeout:
             result = self.send_done()  # 1 == success, 2 == fail
+
+        if result is None:
+            # timed out, cancel sending and power down the module
+            self.flush_tx()
+            self.reg_write(CONFIG, self.reg_read(CONFIG) & ~PWR_UP)
+            raise OSError("timed out")
+
         if result == 2:
             raise OSError("send failed")
 
     # non-blocking tx
     def send_start(self, buf):
         # power up
         self.reg_write(CONFIG, (self.reg_read(CONFIG) | PWR_UP) & ~PRIM_RX)
-        utime.sleep_us(150)
+        utime.sleep_us(1500)  # needs to be 1.5ms
         # send the data
         self.cs(0)
         self.spi.readinto(self.buf, W_TX_PAYLOAD)
@@ -243,7 +256,8 @@ def send_start(self, buf):
 
     # returns None if send still in progress, 1 for success, 2 for fail
     def send_done(self):
-        if not (self.reg_read(STATUS) & (TX_DS | MAX_RT)):
+        status = self.read_status()
+        if not (status & (TX_DS | MAX_RT)):
             return None  # tx not finished
 
         # either finished or failed: get and clear status flags, power down

micropython/drivers/sensor/hts221/hts221.py

@@ -52,7 +52,7 @@ def __init__(self, i2c, data_rate=1, address=0x5F):
 
         # Set configuration register
         # Humidity and temperature average configuration
-        self.bus.writeto_mem(self.slv_addr, 0x10, b"\x1B")
+        self.bus.writeto_mem(self.slv_addr, 0x10, b"\x1b")
 
         # Set control register
         # PD | BDU | ODR

micropython/drivers/sensor/lps22h/lps22h.py

@@ -37,6 +37,7 @@
     print("Pressure: %.2f hPa Temperature: %.2f C"%(lps.pressure(), lps.temperature()))
     time.sleep_ms(10)
 """
+
 import machine
 from micropython import const
 

micropython/espflash/espflash.py

@@ -113,22 +113,22 @@ def _poll_reg(self, addr, flag, retry=10, delay=0.050):
             raise Exception(f"Register poll timeout. Addr: 0x{addr:02X} Flag: 0x{flag:02X}.")
 
     def _write_slip(self, pkt):
-        pkt = pkt.replace(b"\xDB", b"\xdb\xdd").replace(b"\xc0", b"\xdb\xdc")
-        self.uart.write(b"\xC0" + pkt + b"\xC0")
+        pkt = pkt.replace(b"\xdb", b"\xdb\xdd").replace(b"\xc0", b"\xdb\xdc")
+        self.uart.write(b"\xc0" + pkt + b"\xc0")
         self._log(pkt)
 
     def _read_slip(self):
         pkt = None
         # Find the packet start.
-        if self.uart.read(1) == b"\xC0":
+        if self.uart.read(1) == b"\xc0":
             pkt = bytearray()
             while True:
                 b = self.uart.read(1)
-                if b is None or b == b"\xC0":
+                if b is None or b == b"\xc0":
                     break
                 pkt += b
-            pkt = pkt.replace(b"\xDB\xDD", b"\xDB").replace(b"\xDB\xDC", b"\xC0")
-            self._log(b"\xC0" + pkt + b"\xC0", False)
+            pkt = pkt.replace(b"\xdb\xdd", b"\xdb").replace(b"\xdb\xdc", b"\xc0")
+            self._log(b"\xc0" + pkt + b"\xc0", False)
         return pkt
 
     def _strerror(self, err):
@@ -230,7 +230,7 @@ def flash_read_size(self):
             raise Exception(f"Unexpected flash size bits: 0x{flash_bits:02X}.")
 
         flash_size = 2**flash_bits
-        print(f"Flash size {flash_size/1024/1024} MBytes")
+        print(f"Flash size {flash_size / 1024 / 1024} MBytes")
         return flash_size
 
     def flash_attach(self):
@@ -265,7 +265,7 @@ def flash_write_file(self, path, blksize=0x1000):
                     self.md5sum.update(buf)
                 # The last data block should be padded to the block size with 0xFF bytes.
                 if len(buf) < blksize:
-                    buf += b"\xFF" * (blksize - len(buf))
+                    buf += b"\xff" * (blksize - len(buf))
                 checksum = self._checksum(buf)
                 if seq % erase_blocks == 0:
                     # print(f"Erasing {seq} -> {seq+erase_blocks}...")

micropython/lora/examples/reliable_delivery/sender.py

@@ -149,7 +149,7 @@ def send(self, sensor_data, adjust_output_power=True):
                 delta = time.ticks_diff(maybe_ack.ticks_ms, sent_at)
                 print(
                     f"ACKed with RSSI {rssi}, {delta}ms after sent "
-                    + f"(skew {delta-ACK_DELAY_MS-ack_packet_ms}ms)"
+                    + f"(skew {delta - ACK_DELAY_MS - ack_packet_ms}ms)"
                 )
 
                 if adjust_output_power:

micropython/lora/examples/reliable_delivery/sender_async.py

@@ -141,7 +141,7 @@ async def send(self, sensor_data, adjust_output_power=True):
                 delta = time.ticks_diff(maybe_ack.ticks_ms, sent_at)
                 print(
                     f"ACKed with RSSI {rssi}, {delta}ms after sent "
-                    + f"(skew {delta-ACK_DELAY_MS-ack_packet_ms}ms)"
+                    + f"(skew {delta - ACK_DELAY_MS - ack_packet_ms}ms)"
                 )
 
                 if adjust_output_power: