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_epd_u2if:
 381             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 382                 SPI_Feather_EPD as _SPI,
 383             )
 384         elif detector.board.itsybitsy_u2if:
 385             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 386                 SPI_ItsyBitsy as _SPI,
 387             )
 388         elif detector.board.macropad_u2if:
 389             from adafruit_blinka.microcontroller.rp2040_u2if.spi import (
 390                 SPI_MacroPad as _SPI,
 391             )
 392         elif detector.board.qtpy_u2if:
 393             from adafruit_blinka.microcontroller.rp2040_u2if.spi import SPI_QTPY as _SPI
 394         elif detector.chip.id == ap_chip.RP2040:
 395             from adafruit_blinka.microcontroller.rp2040.spi import SPI as _SPI
 396         elif detector.board.any_siemens_iot2000:
 397             from adafruit_blinka.microcontroller.am65xx.spi import SPI as _SPI
 398             from adafruit_blinka.microcontroller.am65xx.pin import Pin
 399         elif detector.board.any_embedded_linux:
 400             from adafruit_blinka.microcontroller.generic_linux.spi import SPI as _SPI
 401         else:
 402             from adafruit_blinka.microcontroller.generic_micropython.spi import (
 403                 SPI as _SPI,
 404             )
 405
 406         if self._locked:
 407             # TODO check if #init ignores MOSI=None rather than unsetting, to save _pinIds attribute
 408             self._spi.init(
 409                 baudrate=baudrate,
 410                 polarity=polarity,
 411                 phase=phase,
 412                 bits=bits,
 413                 firstbit=_SPI.MSB,
 414             )
 415         else:
 416             raise RuntimeError("First call try_lock()")
 417
 418     def deinit(self):
 419         """Deinitialization"""
 420         self._spi = None
 421         self._pinIds = None
 422
 423     @property
 424     def frequency(self):
 425         """Return the baud rate if implemented"""
 426         try:
 427             return self._spi.frequency
 428         except AttributeError as error:
 429             raise NotImplementedError(
 430                 "Frequency attribute not implemented for this platform"
 431             ) from error
 432
 433     def write(self, buf, start=0, end=None):
 434         """Write to the SPI device"""
 435         return self._spi.write(buf, start, end)
 436
 437     def readinto(self, buf, start=0, end=None, write_value=0):
 438         """Read from the SPI device into a buffer"""
 439         return self._spi.readinto(buf, start, end, write_value=write_value)
 440
 441     def write_readinto(
 442         self, buffer_out, buffer_in, out_start=0, out_end=None, in_start=0, in_end=None
 443     ):
 444         """Write to the SPI device and read from the SPI device into a buffer"""
 445         return self._spi.write_readinto(
 446             buffer_out, buffer_in, out_start, out_end, in_start, in_end
 447         )
 448
 449
 450 class UART(Lockable):
 451     """
 452     Busio UART Class for CircuitPython Compatibility. Used
 453     for MicroPython and a few other non-Linux boards.
 454     """
 455
 456     class Parity(Enum):
 457         """Parity Enumeration"""
 458
 459         pass  # pylint: disable=unnecessary-pass
 460
 461     Parity.ODD = Parity()
 462     Parity.EVEN = Parity()
 463
 464     def __init__(
 465         self,
 466         tx,
 467         rx,
 468         baudrate=9600,
 469         bits=8,
 470         parity=None,
 471         stop=1,
 472         timeout=1000,
 473         receiver_buffer_size=64,
 474         flow=None,
 475     ):
 476         if detector.board.any_embedded_linux:
 477             raise RuntimeError(
 478                 "busio.UART not supported on this platform. Please use pyserial instead."
 479             )
 480         if detector.board.binho_nova:
 481             from adafruit_blinka.microcontroller.nova.uart import UART as _UART
 482         elif detector.board.greatfet_one:
 483             from adafruit_blinka.microcontroller.nxp_lpc4330.uart import UART as _UART
 484         elif detector.chip.id == ap_chip.RP2040:
 485             from adafruit_blinka.microcontroller.rp2040.uart import UART as _UART
 486         else:
 487             from machine import UART as _UART
 488
 489         from microcontroller.pin import uartPorts
 490
 491         self.baudrate = baudrate
 492
 493         if flow is not None:  # default 0
 494             raise NotImplementedError(
 495                 "Parameter '{}' unsupported on {}".format("flow", agnostic.board_id)
 496             )
 497
 498         # translate parity flag for Micropython
 499         if parity is UART.Parity.ODD:
 500             parity = 1
 501         elif parity is UART.Parity.EVEN:
 502             parity = 0
 503         elif parity is None:
 504             pass
 505         else:
 506             raise ValueError("Invalid parity")
 507
 508         if detector.chip.id == ap_chip.RP2040:
 509             self._uart = _UART(
 510                 tx,
 511                 rx,
 512                 baudrate=baudrate,
 513                 bits=bits,
 514                 parity=parity,
 515                 stop=stop,
 516             )
 517         else:
 518             # check tx and rx have hardware support
 519             for portId, portTx, portRx in uartPorts:  #
 520                 if portTx == tx and portRx == rx:
 521                     self._uart = _UART(
 522                         portId,
 523                         baudrate,
 524                         bits=bits,
 525                         parity=parity,
 526                         stop=stop,
 527                         timeout=timeout,
 528                         read_buf_len=receiver_buffer_size,
 529                     )
 530                     break
 531             else:
 532                 raise ValueError(
 533                     "No Hardware UART on (tx,rx)={}\nValid UART ports: {}".format(
 534                         (tx, rx), uartPorts
 535                     )
 536                 )
 537
 538     def deinit(self):
 539         """Deinitialization"""
 540         if detector.board.binho_nova:
 541             self._uart.deinit()
 542         self._uart = None
 543
 544     def read(self, nbytes=None):
 545         """Read from the UART"""
 546         return self._uart.read(nbytes)
 547
 548     def readinto(self, buf, nbytes=None):
 549         """Read from the UART into a buffer"""
 550         return self._uart.readinto(buf, nbytes)
 551
 552     def readline(self):
 553         """Read a line of characters up to a newline character from the UART"""
 554         return self._uart.readline()
 555
 556     def write(self, buf):
 557         """Write to the UART from a buffer"""
 558         return self._uart.write(buf)