Fix MicroPython and busio

diff --git a/src/adafruit_blinka/microcontroller/esp8266/pin.py b/src/adafruit_blinka/microcontroller/esp8266/pin.py
index 9dc856faadc64d8bbcabde444b2978d95b18b110..5ba98840d611aded29a7fe8a4d7e973e45c2841b 100755 (executable)
--- a/src/adafruit_blinka/microcontroller/esp8266/pin.py
+++ b/src/adafruit_blinka/microcontroller/esp8266/pin.py
@@ -16,14 +16,14 @@ GPIO16 = Pin(16)
 TOUT = Pin("TOUT")
 
 # ordered as spiId, sckId, mosiId, misoId
-SPI_PORTS = (1, GPIO14, GPIO13, GPIO12)
+spiPorts = (1, GPIO14, GPIO13, GPIO12)
 
 # ordered as uartId, txId, rxId
-UART_PORTS = (
+uartPorts = (
     (0, GPIO1, GPIO3),
     # TODO secondary pins for UART0 configurable from Micropython? How to flag?
     # (0, GPIO15, GPIO13)
     (1, GPIO2, None),
 )
 
-I2C_PORTS = ()
+i2cPorts = ()

diff --git a/src/adafruit_blinka/microcontroller/generic_micropython/i2c.py b/src/adafruit_blinka/microcontroller/generic_micropython/i2c.py
new file mode 100755 (executable)
index 0000000..3ace77a
--- /dev/null
+++ b/src/adafruit_blinka/microcontroller/generic_micropython/i2c.py
@@ -0,0 +1,51 @@
+"""I2C Class for Generic MicroPython"""
+from machine import I2C as _I2C
+
+
+class I2C:
+    """I2C Class for Generic MicroPython"""
+
+    MASTER = 0
+
+    # pylint: disable=unused-argument
+    def __init__(self, portId, *, mode=MASTER, baudrate=100000):
+        self._i2c = _I2C(portId, freq=baudrate)
+
+    def scan(self):
+        """Perform an I2C Device Scan"""
+        return self._i2c.scan()
+
+    def writeto(self, address, buffer, *, stop=True):
+        """Write the data from the buffer to the address"""
+        return self._i2c.writeto(address, buffer)
+
+    def readfrom_into(self, address, buffer, *, stop=True):
+        """Read data from an address and into the buffer"""
+        return self._i2c.readfrom_into(address, buffer)
+
+    def writeto_then_readfrom(
+        self,
+        address,
+        buffer_out,
+        buffer_in,
+        *,
+        out_start=0,
+        out_end=None,
+        in_start=0,
+        in_end=None,
+        stop=False
+    ):
+        """Write data from buffer_out to an address and then
+        read data from an address and into buffer_in
+        """
+        self._i2c.writeto_then_readfrom(
+            address,
+            buffer_out,
+            buffer_in,
+            out_start=out_start,
+            out_end=out_end,
+            in_start=in_start,
+            in_end=in_end,
+        )
+
+    # pylint: enable=unused-argument

diff --git a/src/adafruit_blinka/microcontroller/generic_micropython/spi.py b/src/adafruit_blinka/microcontroller/generic_micropython/spi.py
new file mode 100755 (executable)
index 0000000..7842a19
--- /dev/null
+++ b/src/adafruit_blinka/microcontroller/generic_micropython/spi.py
@@ -0,0 +1,66 @@
+"""SPI Class for Generic MicroPython"""
+from machine import SPI as _SPI
+
+# pylint: disable=protected-access, no-self-use
+class SPI:
+    """SPI Class for Generic MicroPython"""
+
+    MSB = _SPI.MSB
+    LSB = _SPI.LSB
+
+    def __init__(self, portId, baudrate=100000):
+        self._frequency = baudrate
+        self._spi = _SPI(portId)
+
+    # pylint: disable=too-many-arguments,unused-argument
+    def init(
+        self,
+        baudrate=1000000,
+        polarity=0,
+        phase=0,
+        bits=8,
+        firstbit=_SPI.MSB,
+    ):
+        """Initialize the Port"""
+        self._frequency = baudrate
+        self._spi.init(
+            baudrate=baudrate,
+            polarity=polarity,
+            phase=phase,
+            bits=bits,
+            firstbit=firstbit,
+            mode=_SPI.MASTER,
+        )
+
+    # pylint: enable=too-many-arguments
+
+    @property
+    def frequency(self):
+        """Return the current frequency"""
+        return self._frequency
+
+    def write(self, buf, start=0, end=None):
+        """Write data from the buffer to SPI"""
+        self._spi.write(buf)
+
+    def readinto(self, buf, start=0, end=None, write_value=0):
+        """Read data from SPI and into the buffer"""
+        self._spi.readinto(buf)
+
+    # pylint: disable=too-many-arguments
+    def write_readinto(
+        self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
+    ):
+        """Perform a half-duplex write from buffer_out and then
+        read data into buffer_in
+        """
+        self._spi.write_readinto(
+            buffer_out,
+            buffer_in,
+            out_start=out_start,
+            out_end=out_end,
+            in_start=in_start,
+            in_end=in_end,
+        )
+
+    # pylint: enable=too-many-arguments

diff --git a/src/adafruit_blinka/microcontroller/rp2040/i2c.py b/src/adafruit_blinka/microcontroller/rp2040/i2c.py
new file mode 100644 (file)
index 0000000..16ff2e3
--- /dev/null
+++ b/src/adafruit_blinka/microcontroller/rp2040/i2c.py
@@ -0,0 +1,65 @@
+"""I2C Class for RP2040"""
+from machine import I2C as _I2C
+from machine import Pin
+from microcontroller.pin import i2cPorts
+
+
+class I2C:
+    """Custom I2C Class for RP2040"""
+
+    def __init__(self, scl, sda, *, frequency=100000):
+        for portId, portScl, portSda in i2cPorts:
+            try:
+                if scl == portScl and sda == portSda:
+                    self._i2c = _I2C(
+                        portId, sda=Pin(sda.id), scl=Pin(scl.id), freq=frequency
+                    )
+                    break
+            except RuntimeError:
+                pass
+        else:
+            raise ValueError(
+                "No Hardware I2C on (scl,sda)={}\nValid I2C ports: {}".format(
+                    (scl, sda), i2cPorts
+                )
+            )
+
+    def scan(self):
+        """Perform an I2C Device Scan"""
+        return self._i2c.scan()
+
+    # pylint: disable=unused-argument
+    def writeto(self, address, buffer, *, stop=True):
+        "Write data to the address from the buffer"
+        return self._i2c.writeto(address, buffer)
+
+    def readfrom_into(self, address, buffer, *, stop=True):
+        """Read data from an address and into the buffer"""
+        return self._i2c.readfrom_into(address, buffer)
+
+    def writeto_then_readfrom(
+        self,
+        address,
+        buffer_out,
+        buffer_in,
+        *,
+        out_start=0,
+        out_end=None,
+        in_start=0,
+        in_end=None,
+        stop=False
+    ):
+        """Write data from buffer_out to an address and then
+        read data from an address and into buffer_in
+        """
+        self._i2c.writeto_then_readfrom(
+            address,
+            buffer_out,
+            buffer_in,
+            out_start=out_start,
+            out_end=out_end,
+            in_start=in_start,
+            in_end=in_end,
+        )
+
+    # pylint: enable=unused-argument

diff --git a/src/adafruit_blinka/microcontroller/rp2040/pin.py b/src/adafruit_blinka/microcontroller/rp2040/pin.py
index 6febdc42e4059b6d61f267744cd47497beeed146..e16890f8307d57317d48c325519f353a661812e7 100755 (executable)
--- a/src/adafruit_blinka/microcontroller/rp2040/pin.py
+++ b/src/adafruit_blinka/microcontroller/rp2040/pin.py
@@ -34,7 +34,7 @@ GP28 = Pin(28)
 GP29 = Pin(29)
 
 # ordered as spiId, sckId, mosiId (tx), misoId (rx)
-SPI_PORTS = (
+spiPorts = (
     (0, GP2, GP3, GP0),
     (0, GP2, GP3, GP4),
     (0, GP2, GP7, GP0),
@@ -54,7 +54,7 @@ SPI_PORTS = (
 )
 
 # ordered as uartId, txId, rxId
-UART_PORTS = (
+uartPorts = (
     (0, GP0, GP1),
     (0, GP0, GP13),
     (0, GP12, GP1),
@@ -66,7 +66,7 @@ UART_PORTS = (
 )
 
 # ordered as scl, sda
-I2C_PORTS = (
+i2cPorts = (
     (0, GP1, GP0),
     (0, GP1, GP4),
     (0, GP1, GP8),

diff --git a/src/adafruit_blinka/microcontroller/rp2040/spi.py b/src/adafruit_blinka/microcontroller/rp2040/spi.py
new file mode 100644 (file)
index 0000000..e876a38
--- /dev/null
+++ b/src/adafruit_blinka/microcontroller/rp2040/spi.py
@@ -0,0 +1,88 @@
+"""SPI Class for RP2040"""
+from machine import SPI as _SPI
+from machine import Pin
+from microcontroller.pin import spiPorts
+
+# pylint: disable=protected-access, no-self-use
+class SPI:
+    """Custom SPI Class for RP2040"""
+
+    def __init__(self, clock, MOSI=None, MISO=None, *, baudrate=1000000):
+        self._frequency = baudrate
+        for portId, portSck, portMosi, portMiso in spiPorts:
+            if (
+                (clock == portSck)
+                and MOSI in (portMosi, None)  # Clock is required!
+                and MISO in (portMiso, None)  # But can do with just output
+            ):  # Or just input
+                mosiPin = Pin(portMosi.id) if MOSI else None
+                misoPin = Pin(portMiso.id) if MISO else None
+                self._spi = _SPI(
+                    portId,
+                    sck=Pin(portSck.id),
+                    mosi=mosiPin,
+                    miso=misoPin,
+                    baudrate=baudrate,
+                )
+                break
+        else:
+            raise ValueError(
+                "No Hardware SPI on (SCLK, MOSI, MISO)={}\nValid SPI ports:{}".format(
+                    (clock, MOSI, MISO), spiPorts
+                )
+            )
+
+    # pylint: disable=too-many-arguments,unused-argument
+    def init(
+        self,
+        baudrate=1000000,
+        polarity=0,
+        phase=0,
+        bits=8,
+        firstbit=_SPI.MSB,
+        sck=None,
+        mosi=None,
+        miso=None,
+    ):
+        """Initialize the Port"""
+        self._frequency = baudrate
+        self._spi.init(
+            baudrate=baudrate,
+            polarity=polarity,
+            phase=phase,
+            bits=bits,
+            firstbit=firstbit,
+        )
+
+    # pylint: enable=too-many-arguments
+
+    @property
+    def frequency(self):
+        """Return the current frequency"""
+        return self._frequency
+
+    def write(self, buf, start=0, end=None):
+        """Write data from the buffer to SPI"""
+        self._spi.write(buf)
+
+    def readinto(self, buf, start=0, end=None, write_value=0):
+        """Read data from SPI and into the buffer"""
+        self._spi.readinto(buf)
+
+    # pylint: disable=too-many-arguments
+    def write_readinto(
+        self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
+    ):
+        """Perform a half-duplex write from buffer_out and then
+        read data into buffer_in
+        """
+        self._spi.write_readinto(
+            buffer_out,
+            buffer_in,
+            out_start=out_start,
+            out_end=out_end,
+            in_start=in_start,
+            in_end=in_end,
+        )
+
+    # pylint: enable=too-many-arguments

diff --git a/src/adafruit_blinka/microcontroller/rp2040/uart.py b/src/adafruit_blinka/microcontroller/rp2040/uart.py
new file mode 100644 (file)
index 0000000..a233b8e
--- /dev/null
+++ b/src/adafruit_blinka/microcontroller/rp2040/uart.py
@@ -0,0 +1,48 @@
+"""UART Class for RP2040"""
+from machine import UART as _UART
+from machine import Pin
+from microcontroller.pin import uartPorts
+
+# pylint: disable=protected-access, no-self-use
+class UART:
+    """Custom UART Class for RP2040"""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, tx, rx, baudrate=9600, bits=8, parity=None, stop=1):
+        # check tx and rx have hardware support
+        for portId, txPin, rxPin in uartPorts:
+            if txPin == tx and rxPin == rx:
+                self._uart = _UART(
+                    portId,
+                    baudrate,
+                    bits=bits,
+                    parity=parity,
+                    stop=stop,
+                    tx=Pin(txPin.id),
+                    rx=Pin(rxPin.id),
+                )
+                break
+        else:
+            raise ValueError(
+                "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format(
+                    (tx.id, rx.id), uartPorts
+                )
+            )
+
+    # pylint: enable=too-many-arguments
+
+    def read(self, nbytes=None):
+        """Read from the UART"""
+        return self._uart.read(nbytes)
+
+    def readinto(self, buf, nbytes=None):
+        """Read from the UART into a buffer"""
+        return self._uart.readinto(buf, nbytes)
+
+    def readline(self):
+        """Read a line of characters up to a newline charater from the UART"""
+        return self._uart.readline()
+
+    def write(self, buf):
+        """Write to the UART from a buffer"""
+        return self._uart.write(buf)

diff --git a/src/adafruit_blinka/microcontroller/stm32/stm32f405/pin.py b/src/adafruit_blinka/microcontroller/stm32/stm32f405/pin.py
index 52ec1c0e68428dde44d40ae42e07b3bf0daf7377..605015d4d696c6b5934f15ada415a46d123f2b49 100755 (executable)
--- a/src/adafruit_blinka/microcontroller/stm32/stm32f405/pin.py
+++ b/src/adafruit_blinka/microcontroller/stm32/stm32f405/pin.py
@@ -51,10 +51,10 @@ C13 = Pin("C13")
 D2 = Pin("D2")
 
 # ordered as spiId, sckId, mosiId, misoId
-SPI_PORTS = ((1, B13, B15, B14), (2, A5, A6, A7))
+spiPorts = ((1, B13, B15, B14), (2, A5, A7, A6))
 
 # ordered as uartId, txId, rxId
-UART_PORTS = (
+uartPorts = (
     (1, B6, B7),
     (2, A2, A3),
     (3, B10, B11),
@@ -62,7 +62,7 @@ UART_PORTS = (
     (6, C6, C7),
 )
 
-I2C_PORTS = (
+i2cPorts = (
     (1, B6, B7),
     (2, B10, B11),
 )

diff --git a/src/busio.py b/src/busio.py
index 3fd6b5b112ada16de279c606c652952778fa0358..c9b845e3dc84b2d14c2af6bbdafa35845fcbc142 100755 (executable)
--- a/src/busio.py
+++ b/src/busio.py
@@ -18,7 +18,7 @@ from adafruit_blinka import Enum, Lockable, agnostic
 from adafruit_blinka.agnostic import board_id, detector
 
 # pylint: disable=import-outside-toplevel,too-many-branches,too-many-statements
-# pylint: disable=too-many-arguments,too-many-function-args, consider-using-with
+# pylint: disable=too-many-arguments,too-many-function-args,consider-using-with
 
 
 class I2C(Lockable):
@@ -56,19 +56,28 @@ class I2C(Lockable):
         if detector.board.pico_u2if:
             from adafruit_blinka.microcontroller.pico_u2if.i2c import I2C as _I2C
 
+            self._i2c = _I2C(scl, sda, frequency=frequency)
+            return
+        if detector.chip.id == ap_chip.RP2040:
+            from adafruit_blinka.microcontroller.rp2040.i2c import I2C as _I2C
+
             self._i2c = _I2C(scl, sda, frequency=frequency)
             return
         if detector.board.any_embedded_linux:
             from adafruit_blinka.microcontroller.generic_linux.i2c import I2C as _I2C
         else:
-            from machine import I2C as _I2C
+            from adafruit_blinka.microcontroller.generic_micropython.i2c import (
+                I2C as _I2C,
+            )
         from microcontroller.pin import i2cPorts
 
         for portId, portScl, portSda in i2cPorts:
             try:
+                # pylint: disable=unexpected-keyword-arg
                 if scl == portScl and sda == portSda:
                     self._i2c = _I2C(portId, mode=_I2C.MASTER, baudrate=frequency)
                     break
+                # pylint: enable=unexpected-keyword-arg
             except RuntimeError:
                 pass
         else:
@@ -182,10 +191,18 @@ class SPI(Lockable):
             self._spi = _SPI(clock)  # this is really all that's needed
             self._pins = (clock, clock, clock)  # will determine MOSI/MISO from clock
             return
+        if detector.chip.id == ap_chip.RP2040:
+            from adafruit_blinka.microcontroller.rp2040.spi import SPI as _SPI
+
+            self._spi = _SPI(clock, MOSI, MISO)  # Pins configured on instantiation
+            self._pins = (clock, clock, clock)  # These don't matter, they're discarded
+            return
         if detector.board.any_embedded_linux:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         else:
-            from machine import SPI as _SPI
+            from adafruit_blinka.microcontroller.generic_micropython.spi import (
+                SPI as _SPI,
+            )
         from microcontroller.pin import spiPorts
 
         for portId, portSck, portMosi, portMiso in spiPorts:
@@ -207,102 +224,72 @@ class SPI(Lockable):
     def configure(self, baudrate=100000, polarity=0, phase=0, bits=8):
         """Update the configuration"""
         if detector.board.any_raspberry_pi or detector.board.any_raspberry_pi_40_pin:
-            from adafruit_blinka.microcontroller.bcm283x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.BEAGLEBONE_AI:
-            from adafruit_blinka.microcontroller.dra74x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.any_beaglebone:
-            from adafruit_blinka.microcontroller.am335x.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.any_orange_pi:
-            if detector.chip.id == ap_chip.SUN8I:
-                from adafruit_blinka.microcontroller.allwinner.h3.pin import Pin
-            elif detector.chip.id == ap_chip.H5:
-                from adafruit_blinka.microcontroller.allwinner.h5.pin import Pin
-            elif detector.chip.id == ap_chip.H616:
-                from adafruit_blinka.microcontroller.allwinner.h616.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.any_nanopi and detector.chip.id == ap_chip.SUN8I:
-            from adafruit_blinka.microcontroller.allwinner.h3.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.GIANT_BOARD:
-            from adafruit_blinka.microcontroller.sama5.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.CORAL_EDGE_TPU_DEV:
-            from adafruit_blinka.microcontroller.nxp_imx8m.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.CORAL_EDGE_TPU_DEV_MINI:
-            from adafruit_blinka.microcontroller.mt8167.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.ODROID_C2:
-            from adafruit_blinka.microcontroller.amlogic.s905.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.ODROID_C4:
-            from adafruit_blinka.microcontroller.amlogic.s905x3.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.ODROID_XU4:
-            from adafruit_blinka.microcontroller.samsung.exynos5422.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.DRAGONBOARD_410C:
-            from adafruit_blinka.microcontroller.snapdragon.apq8016.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.JETSON_NANO:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.tegra.t210.pin import Pin
         elif board_id == ap_board.JETSON_TX1:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.tegra.t210.pin import Pin
         elif board_id == ap_board.JETSON_TX2:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.tegra.t186.pin import Pin
         elif board_id == ap_board.JETSON_XAVIER:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.tegra.t194.pin import Pin
         elif board_id == ap_board.JETSON_NX:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.tegra.t194.pin import Pin
         elif detector.board.ROCK_PI_S:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.rockchip.rk3308.pin import Pin
         elif detector.board.ROCK_PI_4:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.rockchip.rk3399.pin import Pin
         elif detector.board.SIFIVE_UNLEASHED:
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.hfu540.pin import Pin
         elif detector.board.ftdi_ft232h:
             from adafruit_blinka.microcontroller.ft232h.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.ft232h.pin import Pin
         elif detector.board.binho_nova:
             from adafruit_blinka.microcontroller.nova.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.nova.pin import Pin
         elif detector.board.greatfet_one:
             from adafruit_blinka.microcontroller.nxp_lpc4330.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.nxp_lpc4330.pin import Pin
         elif board_id in (
             ap_board.PINE64,
             ap_board.PINEBOOK,
             ap_board.PINEPHONE,
             ap_board.SOPINE,
         ):
-            from adafruit_blinka.microcontroller.allwinner.a64.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.CLOCKWORK_CPI3:
-            from adafruit_blinka.microcontroller.allwinner.a33.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif board_id == ap_board.ONION_OMEGA2:
-            from adafruit_blinka.microcontroller.mips24kec.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.any_lubancat and detector.chip.id == ap_chip.IMX6ULL:
-            from adafruit_blinka.microcontroller.nxp_imx6ull.pin import Pin
             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
         elif detector.board.pico_u2if:
             from adafruit_blinka.microcontroller.pico_u2if.spi import SPI as _SPI
-            from adafruit_blinka.microcontroller.pico_u2if.pin import Pin
+        elif detector.chip.id == ap_chip.RP2040:
+            from adafruit_blinka.microcontroller.rp2040.spi import SPI as _SPI
         else:
-            from machine import SPI as _SPI
-            from machine import Pin
+            from adafruit_blinka.microcontroller.generic_micropython.spi import (
+                SPI as _SPI,
+            )
 
         if self._locked:
             # TODO check if #init ignores MOSI=None rather than unsetting, to save _pinIds attribute
@@ -312,9 +299,6 @@ class SPI(Lockable):
                 phase=phase,
                 bits=bits,
                 firstbit=_SPI.MSB,
-                sck=Pin(self._pins[0].id),
-                mosi=Pin(self._pins[1].id),
-                miso=Pin(self._pins[2].id),
             )
         else:
             raise RuntimeError("First call try_lock()")
@@ -385,13 +369,12 @@ class UART(Lockable):
             from adafruit_blinka.microcontroller.nova.uart import UART as _UART
         elif detector.board.greatfet_one:
             from adafruit_blinka.microcontroller.nxp_lpc4330.uart import UART as _UART
+        elif detector.chip.id == ap_chip.RP2040:
+            from adafruit_blinka.microcontroller.rp2040.uart import UART as _UART
         else:
             from machine import UART as _UART
 
-        if detector.board.binho_nova:
-            from adafruit_blinka.microcontroller.nova.pin import uartPorts
-        else:
-            from microcontroller.pin import uartPorts
+        from microcontroller.pin import uartPorts
 
         self.baudrate = baudrate
 
@@ -410,25 +393,35 @@ class UART(Lockable):
         else:
             raise ValueError("Invalid parity")
 
-        # check tx and rx have hardware support
-        for portId, portTx, portRx in uartPorts:  #
-            if portTx == tx and portRx == rx:
-                self._uart = _UART(
-                    portId,
-                    baudrate,
-                    bits=bits,
-                    parity=parity,
-                    stop=stop,
-                    timeout=timeout,
-                    read_buf_len=receiver_buffer_size,
-                )
-                break
+        if detector.chip.id == ap_chip.RP2040:
+            self._uart = _UART(
+                tx,
+                rx,
+                baudrate=baudrate,
+                bits=bits,
+                parity=parity,
+                stop=stop,
+            )
         else:
-            raise ValueError(
-                "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format(
-                    (tx, rx), uartPorts
+            # check tx and rx have hardware support
+            for portId, portTx, portRx in uartPorts:  #
+                if portTx == tx and portRx == rx:
+                    self._uart = _UART(
+                        portId,
+                        baudrate,
+                        bits=bits,
+                        parity=parity,
+                        stop=stop,
+                        timeout=timeout,
+                        read_buf_len=receiver_buffer_size,
+                    )
+                    break
+            else:
+                raise ValueError(
+                    "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format(
+                        (tx, rx), uartPorts
+                    )
                 )
-            )
 
     def deinit(self):
         """Deinitialization"""