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