src/busio.py

   1 """
   2 `busio` - Bus protocol support like I2C and SPI
   3 =================================================
   4
   5 See `CircuitPython:busio` in CircuitPython for more details.
   6
   7 * Author(s): cefn
   8 """
   9
  10 try:
  11     import threading
  12 except ImportError:
  13     threading = None
  14
  15 # pylint: disable=unused-import
  16 import adafruit_platformdetect.constants.boards as ap_board
  17 import adafruit_platformdetect.constants.chips as ap_chip
  18 from adafruit_blinka import Enum, Lockable, agnostic
  19 from adafruit_blinka.agnostic import board_id, detector
  20
  21 # pylint: disable=import-outside-toplevel,too-many-branches,too-many-statements
  22 # pylint: disable=too-many-arguments,too-many-function-args,too-many-return-statements
  23
  24
  25 class I2C(Lockable):
  26     """
  27     Busio I2C Class for CircuitPython Compatibility. Used
  28     for both MicroPython and Linux.
  29     """
  30
  31     def __init__(self, scl, sda, frequency=100000):
  32         self.init(scl, sda, frequency)
  33
  34     def init(self, scl, sda, frequency):
  35         """Initialization"""
  36         self.deinit()
  37         if detector.board.ftdi_ft232h:
  38             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.i2c import I2C as _I2C
  39
  40             self._i2c = _I2C(frequency=frequency)
  41             return
  42         if detector.board.binho_nova:
  43             from adafruit_blinka.microcontroller.nova.i2c import I2C as _I2C
  44
  45             self._i2c = _I2C(frequency=frequency)
  46             return
  47         if detector.board.microchip_mcp2221:
  48             from adafruit_blinka.microcontroller.mcp2221.i2c import I2C as _I2C
  49
  50             self._i2c = _I2C(frequency=frequency)
  51             return
  52         if detector.board.greatfet_one:
  53             from adafruit_blinka.microcontroller.nxp_lpc4330.i2c import I2C as _I2C
  54
  55             self._i2c = _I2C(frequency=frequency)
  56             return
  57         if detector.board.pico_u2if:
  58             from adafruit_blinka.microcontroller.rp2040_u2if.i2c import I2C_Pico as _I2C
  59
  60             self._i2c = _I2C(scl, sda, frequency=frequency)
  61             return
  62         if detector.board.feather_u2if:
  63             from adafruit_blinka.microcontroller.rp2040_u2if.i2c import (
  64                 I2C_Feather as _I2C,
  65             )
  66
  67             self._i2c = _I2C(scl, sda, frequency=frequency)
  68             return
  69         if detector.board.qtpy_u2if:
  70             from adafruit_blinka.microcontroller.rp2040_u2if.i2c import I2C_QTPY as _I2C
  71
  72             self._i2c = _I2C(scl, sda, frequency=frequency)
  73             return
  74         if detector.board.itsybitsy_u2if:
  75             from adafruit_blinka.microcontroller.rp2040_u2if.i2c import (
  76                 I2C_ItsyBitsy as _I2C,
  77             )
  78
  79             self._i2c = _I2C(scl, sda, frequency=frequency)
  80             return
  81         if detector.board.qt2040_trinkey_u2if:
  82             from adafruit_blinka.microcontroller.rp2040_u2if.i2c import (
  83                 I2C_QT2040_Trinkey as _I2C,
  84             )
  85
  86             self._i2c = _I2C(scl, sda, frequency=frequency)
  87             return
  88         if detector.chip.id == ap_chip.RP2040:
  89             from adafruit_blinka.microcontroller.rp2040.i2c import I2C as _I2C
  90
  91             self._i2c = _I2C(scl, sda, frequency=frequency)
  92             return
  93         if detector.board.any_embedded_linux:
  94             from adafruit_blinka.microcontroller.generic_linux.i2c import I2C as _I2C
  95         elif detector.board.ftdi_ft2232h:
  96             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.i2c import I2C as _I2C
  97         else:
  98             from adafruit_blinka.microcontroller.generic_micropython.i2c import (
  99                 I2C as _I2C,
 100             )
 101         from microcontroller.pin import i2cPorts
 102
 103         for portId, portScl, portSda in i2cPorts:
 104             try:
 105                 # pylint: disable=unexpected-keyword-arg
 106                 if scl == portScl and sda == portSda:
 107                     self._i2c = _I2C(portId, mode=_I2C.MASTER, baudrate=frequency)
 108                     break
 109                 # pylint: enable=unexpected-keyword-arg
 110             except RuntimeError:
 111                 pass
 112         else:
 113             raise ValueError(
 114                 "No Hardware I2C on (scl,sda)={}\nValid I2C ports: {}".format(
 115                     (scl, sda), i2cPorts
 116                 )
 117             )
 118         if threading is not None:
 119             self._lock = threading.RLock()
 120
 121     def deinit(self):
 122         """Deinitialization"""
 123         try:
 124             del self._i2c
 125         except AttributeError:
 126             pass
 127
 128     def __enter__(self):
 129         if threading is not None:
 130             self._lock.acquire()
 131         return self
 132
 133     def __exit__(self, exc_type, exc_value, traceback):
 134         if threading is not None:
 135             self._lock.release()
 136         self.deinit()
 137
 138     def scan(self):
 139         """Scan for attached devices"""
 140         return self._i2c.scan()
 141
 142     def readfrom_into(self, address, buffer, *, start=0, end=None):
 143         """Read from a device at specified address into a buffer"""
 144         if start != 0 or end is not None:
 145             if end is None:
 146                 end = len(buffer)
 147             buffer = memoryview(buffer)[start:end]
 148         stop = True  # remove for efficiency later
 149         return self._i2c.readfrom_into(address, buffer, stop=stop)
 150
 151     def writeto(self, address, buffer, *, start=0, end=None, stop=True):
 152         """Write to a device at specified address from a buffer"""
 153         if isinstance(buffer, str):
 154             buffer = bytes([ord(x) for x in buffer])
 155         if start != 0 or end is not None:
 156             if end is None:
 157                 return self._i2c.writeto(address, memoryview(buffer)[start:], stop=stop)
 158             return self._i2c.writeto(address, memoryview(buffer)[start:end], stop=stop)
 159         return self._i2c.writeto(address, buffer, stop=stop)
 160
 161     def writeto_then_readfrom(
 162         self,
 163         address,
 164         buffer_out,
 165         buffer_in,
 166         *,
 167         out_start=0,
 168         out_end=None,
 169         in_start=0,
 170         in_end=None,
 171         stop=False,
 172     ):
 173         """ "Write to a device at specified address from a buffer then read
 174         from a device at specified address into a buffer
 175         """
 176         return self._i2c.writeto_then_readfrom(
 177             address,
 178             buffer_out,
 179             buffer_in,
 180             out_start=out_start,
 181             out_end=out_end,
 182             in_start=in_start,
 183             in_end=in_end,
 184             stop=stop,
 185         )
 186
 187
 188 class SPI(Lockable):
 189     """
 190     Busio SPI Class for CircuitPython Compatibility. Used
 191     for both MicroPython and Linux.
 192     """
 193
 194     def __init__(self, clock, MOSI=None, MISO=None):
 195         self.deinit()
 196         if detector.board.ftdi_ft232h:
 197             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.spi import SPI as _SPI
 198             from adafruit_blinka.microcontroller.ftdi_mpsse.ft232h.pin import (
 199                 SCK,
 200                 MOSI,
 201                 MISO,
 202             )
 203
 204             self._spi = _SPI()
 205             self._pins = (SCK, MOSI, MISO)
 206             return
 207         if detector.board.binho_nova:
 208             from adafruit_blinka.microcontroller.nova.spi import SPI as _SPI
 209             from adafruit_blinka.microcontroller.nova.pin import SCK, MOSI, MISO
 210
 211             self._spi = _SPI(clock)
 212             self._pins = (SCK, MOSI, MISO)
 213             return
 214         if detector.board.greatfet_one:
 215             from adafruit_blinka.microcontroller.nxp_lpc4330.spi import SPI as _SPI
 216             from adafruit_blinka.microcontroller.nxp_lpc4330.pin import SCK, MOSI, MISO
 217
 218             self._spi = _SPI()
 219             self._pins = (SCK, MOSI, MISO)
 220             return
 221         if detector.board.pico_u2if:
 222             from adafruit_blinka.microcontroller.rp2040_u2if.spi import SPI_Pico as _SPI
 223
 224             self._spi = _SPI(clock)  # this is really all that's needed
 225             self._pins = (clock, clock, clock)  # will determine MOSI/MISO from clock
 226             return
 227         if detector.board.feather_u2if:
 228             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 229                 SPI_Feather as _SPI,
 230             )
 231
 232             self._spi = _SPI(clock)  # this is really all that's needed
 233             self._pins = (clock, clock, clock)  # will determine MOSI/MISO from clock
 234             return
 235         if detector.board.itsybitsy_u2if:
 236             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 237                 SPI_ItsyBitsy as _SPI,
 238             )
 239
 240             self._spi = _SPI(clock)  # this is really all that's needed
 241             self._pins = (clock, clock, clock)  # will determine MOSI/MISO from clock
 242             return
 243         if detector.board.qtpy_u2if:
 244             from adafruit_blinka.microcontroller.rp2040_u2if.spi import SPI_QTPY as _SPI
 245
 246             self._spi = _SPI(clock)  # this is really all that's needed
 247             self._pins = (clock, clock, clock)  # will determine MOSI/MISO from clock
 248             return
 249         if detector.chip.id == ap_chip.RP2040:
 250             from adafruit_blinka.microcontroller.rp2040.spi import SPI as _SPI
 251
 252             self._spi = _SPI(clock, MOSI, MISO)  # Pins configured on instantiation
 253             self._pins = (clock, clock, clock)  # These don't matter, they're discarded
 254             return
 255         if detector.board.any_embedded_linux:
 256             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
 257         elif detector.board.ftdi_ft2232h:
 258             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.spi import SPI as _SPI
 259         else:
 260             from adafruit_blinka.microcontroller.generic_micropython.spi import (
 261                 SPI as _SPI,
 262             )
 263         from microcontroller.pin import spiPorts
 264
 265         for portId, portSck, portMosi, portMiso in spiPorts:
 266             if (
 267                 (clock == portSck)
 268                 and MOSI in (portMosi, None)  # Clock is required!
 269                 and MISO in (portMiso, None)  # But can do with just output
 270             ):  # Or just input
 271                 self._spi = _SPI(portId)
 272                 self._pins = (portSck, portMosi, portMiso)
 273                 break
 274         else:
 275             raise ValueError(
 276                 "No Hardware SPI on (SCLK, MOSI, MISO)={}\nValid SPI ports:{}".format(
 277                     (clock, MOSI, MISO), spiPorts
 278                 )
 279             )
 280
 281     def configure(self, baudrate=100000, polarity=0, phase=0, bits=8):
 282         """Update the configuration"""
 283         if detector.board.any_nanopi and detector.chip.id == ap_chip.SUN8I:
 284             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
 285         elif detector.board.ftdi_ft232h:
 286             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.spi import (
 287                 SPI as _SPI,
 288             )
 289         elif detector.board.ftdi_ft2232h:
 290             from adafruit_blinka.microcontroller.ftdi_mpsse.mpsse.spi import (
 291                 SPI as _SPI,
 292             )
 293         elif detector.board.binho_nova:
 294             from adafruit_blinka.microcontroller.nova.spi import SPI as _SPI
 295         elif detector.board.greatfet_one:
 296             from adafruit_blinka.microcontroller.nxp_lpc4330.spi import SPI as _SPI
 297         elif detector.board.any_lubancat and detector.chip.id == ap_chip.IMX6ULL:
 298             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
 299         elif detector.board.pico_u2if:
 300             from adafruit_blinka.microcontroller.rp2040_u2if.spi import SPI_Pico as _SPI
 301         elif detector.board.feather_u2if:
 302             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 303                 SPI_Feather as _SPI,
 304             )
 305         elif detector.board.itsybitsy_u2if:
 306             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 307                 SPI_ItsyBitsy as _SPI,
 308             )
 309         elif detector.board.qtpy_u2if:
 310             from adafruit_blinka.microcontroller.rp2040_u2if.spi import SPI_QTPY as _SPI
 311         elif detector.chip.id == ap_chip.RP2040:
 312             from adafruit_blinka.microcontroller.rp2040.spi import SPI as _SPI
 313         elif detector.board.any_embedded_linux:
 314             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
 315         else:
 316             from adafruit_blinka.microcontroller.generic_micropython.spi import (
 317                 SPI as _SPI,
 318             )
 319
 320         if self._locked:
 321             # TODO check if #init ignores MOSI=None rather than unsetting, to save _pinIds attribute
 322             self._spi.init(
 323                 baudrate=baudrate,
 324                 polarity=polarity,
 325                 phase=phase,
 326                 bits=bits,
 327                 firstbit=_SPI.MSB,
 328             )
 329         else:
 330             raise RuntimeError("First call try_lock()")
 331
 332     def deinit(self):
 333         """Deinitialization"""
 334         self._spi = None
 335         self._pinIds = None
 336
 337     @property
 338     def frequency(self):
 339         """Return the baud rate if implemented"""
 340         try:
 341             return self._spi.frequency
 342         except AttributeError as error:
 343             raise NotImplementedError(
 344                 "Frequency attribute not implemented for this platform"
 345             ) from error
 346
 347     def write(self, buf, start=0, end=None):
 348         """Write to the SPI device"""
 349         return self._spi.write(buf, start, end)
 350
 351     def readinto(self, buf, start=0, end=None, write_value=0):
 352         """Read from the SPI device into a buffer"""
 353         return self._spi.readinto(buf, start, end, write_value=write_value)
 354
 355     def write_readinto(
 356         self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
 357     ):
 358         """Write to the SPI device and read from the SPI device into a buffer"""
 359         return self._spi.write_readinto(
 360             buffer_out, buffer_in, out_start, out_end, in_start, in_end
 361         )
 362
 363
 364 class UART(Lockable):
 365     """
 366     Busio UART Class for CircuitPython Compatibility. Used
 367     for MicroPython and a few other non-Linux boards.
 368     """
 369
 370     class Parity(Enum):
 371         """Parity Enumeration"""
 372
 373         pass  # pylint: disable=unnecessary-pass
 374
 375     Parity.ODD = Parity()
 376     Parity.EVEN = Parity()
 377
 378     def __init__(
 379         self,
 380         tx,
 381         rx,
 382         baudrate=9600,
 383         bits=8,
 384         parity=None,
 385         stop=1,
 386         timeout=1000,
 387         receiver_buffer_size=64,
 388         flow=None,
 389     ):
 390         if detector.board.any_embedded_linux:
 391             raise RuntimeError(
 392                 "busio.UART not supported on this platform. Please use pyserial instead."
 393             )
 394         if detector.board.binho_nova:
 395             from adafruit_blinka.microcontroller.nova.uart import UART as _UART
 396         elif detector.board.greatfet_one:
 397             from adafruit_blinka.microcontroller.nxp_lpc4330.uart import UART as _UART
 398         elif detector.chip.id == ap_chip.RP2040:
 399             from adafruit_blinka.microcontroller.rp2040.uart import UART as _UART
 400         else:
 401             from machine import UART as _UART
 402
 403         from microcontroller.pin import uartPorts
 404
 405         self.baudrate = baudrate
 406
 407         if flow is not None:  # default 0
 408             raise NotImplementedError(
 409                 "Parameter '{}' unsupported on {}".format("flow", agnostic.board_id)
 410             )
 411
 412         # translate parity flag for Micropython
 413         if parity is UART.Parity.ODD:
 414             parity = 1
 415         elif parity is UART.Parity.EVEN:
 416             parity = 0
 417         elif parity is None:
 418             pass
 419         else:
 420             raise ValueError("Invalid parity")
 421
 422         if detector.chip.id == ap_chip.RP2040:
 423             self._uart = _UART(
 424                 tx,
 425                 rx,
 426                 baudrate=baudrate,
 427                 bits=bits,
 428                 parity=parity,
 429                 stop=stop,
 430             )
 431         else:
 432             # check tx and rx have hardware support
 433             for portId, portTx, portRx in uartPorts:  #
 434                 if portTx == tx and portRx == rx:
 435                     self._uart = _UART(
 436                         portId,
 437                         baudrate,
 438                         bits=bits,
 439                         parity=parity,
 440                         stop=stop,
 441                         timeout=timeout,
 442                         read_buf_len=receiver_buffer_size,
 443                     )
 444                     break
 445             else:
 446                 raise ValueError(
 447                     "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format(
 448                         (tx, rx), uartPorts
 449                     )
 450                 )
 451
 452     def deinit(self):
 453         """Deinitialization"""
 454         if detector.board.binho_nova:
 455             self._uart.deinit()
 456         self._uart = None
 457
 458     def read(self, nbytes=None):
 459         """Read from the UART"""
 460         return self._uart.read(nbytes)
 461
 462     def readinto(self, buf, nbytes=None):
 463         """Read from the UART into a buffer"""
 464         return self._uart.readinto(buf, nbytes)
 465
 466     def readline(self):
 467         """Read a line of characters up to a newline charater from the UART"""
 468         return self._uart.readline()
 469
 470     def write(self, buf):
 471         """Write to the UART from a buffer"""
 472         return self._uart.write(buf)
 473
 474
 475 class OneWire:
 476     """
 477     Stub class for OneWire, which is currently not implemented
 478     """
 479
 480     def __init__(self, pin):
 481         raise NotImplementedError("OneWire has not been implemented")
 482
 483     def deinit(self):
 484         """
 485         Deinitialize the OneWire bus and release any hardware resources for reuse.
 486         """
 487         raise NotImplementedError("OneWire has not been implemented")
 488
 489     def reset(self):
 490         """
 491         Reset the OneWire bus and read presence
 492         """
 493         raise NotImplementedError("OneWire has not been implemented")
 494
 495     def read_bit(self):
 496         """
 497         Read in a bit
 498         """
 499         raise NotImplementedError("OneWire has not been implemented")
 500
 501     def write_bit(self, value):
 502         """
 503         Write out a bit based on value.
 504         """
 505         raise NotImplementedError("OneWire has not been implemented")