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