src/busio.py

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