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