From: Moshe Libenson Date: Tue, 22 Apr 2025 13:40:25 +0000 (+0300) Subject: Merge branch 'adafruit:main' into Support_for_Orange_Pi_Zero2W X-Git-Tag: 8.57.0~1^2 X-Git-Url: https://git.ayoreis.com/Adafruit_Blinka-hackapet.git/commitdiff_plain/21e2f930ada6afd0a031ffe93393f3a4820346d0?hp=62e6197622f9c94c71c326f9a3eeff132ed0b978 Merge branch 'adafruit:main' into Support_for_Orange_Pi_Zero2W --- diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index ea5eab5..80940d0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -16,10 +16,10 @@ jobs: - name: Translate Repo Name For Build Tools filename_prefix id: repo-name run: echo "repo-name=Adafruit-Blinka" >> $GITHUB_OUTPUT - - name: Set up Python 3.7 + - name: Set up Python 3.8 uses: actions/setup-python@v4 with: - python-version: 3.7 + python-version: 3.8 - name: Versions run: | python3 --version diff --git a/LICENSES/BSD-3-Clause.txt b/LICENSES/BSD-3-Clause.txt new file mode 100644 index 0000000..2109eca --- /dev/null +++ b/LICENSES/BSD-3-Clause.txt @@ -0,0 +1,24 @@ +Copyright (c) 2023, Raspberry Pi Ltd. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the copyright holder nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..891ae04 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,5 @@ +# SPDX-FileCopyrightText: 2025 Justin Myers +# +# SPDX-License-Identifier: MIT +[pytest] +pythonpath = src diff --git a/setup.py b/setup.py index 4ed24be..b793194 100755 --- a/setup.py +++ b/setup.py @@ -24,10 +24,18 @@ board_reqs = [] if os.path.exists("/proc/device-tree/compatible"): with open("/proc/device-tree/compatible", "rb") as f: compat = f.read() + # Jetson Nano, TX2, Xavier, etc if b"nvidia,tegra" in compat: board_reqs = ["Jetson.GPIO"] + # Pi 5 + elif b"brcm,bcm2712" in compat: + board_reqs = [ + "rpi_ws281x>=4.0.0", + "lgpio", + "Adafruit-Blinka-Raspberry-Pi5-Neopixel", + ] # Pi 4 and Earlier - if ( + elif ( b"brcm,bcm2835" in compat or b"brcm,bcm2836" in compat or b"brcm,bcm2837" in compat @@ -35,12 +43,8 @@ if os.path.exists("/proc/device-tree/compatible"): or b"brcm,bcm2711" in compat ): board_reqs = ["RPi.GPIO", "rpi_ws281x>=4.0.0"] - # Pi 5 - if b"brcm,bcm2712" in compat: - board_reqs = ["rpi_ws281x>=4.0.0", "rpi-lgpio"] - if ( - b"ti,am335x" in compat - ): # BeagleBone Black, Green, PocketBeagle, BeagleBone AI, etc. + # BeagleBone Black, Green, PocketBeagle, BeagleBone AI, etc. + elif b"ti,am335x" in compat: board_reqs = ["Adafruit_BBIO"] setup( @@ -95,6 +99,7 @@ setup( "pyftdi>=0.40.0", "adafruit-circuitpython-typing", "sysv_ipc>=1.1.0;sys_platform=='linux' and platform_machine!='mips'", + "toml>=0.10.2;python_version<'3.11'", ] + board_reqs, license="MIT", diff --git a/src/adafruit_blinka/__init__.py b/src/adafruit_blinka/__init__.py index a4ef215..38ccec4 100755 --- a/src/adafruit_blinka/__init__.py +++ b/src/adafruit_blinka/__init__.py @@ -8,6 +8,13 @@ * Author(s): cefn """ +import os + +try: + import tomllib +except ImportError: + import toml as tomllib + class Enum: """ @@ -74,6 +81,39 @@ class Lockable(ContextManaged): self._locked = False +def load_settings_toml(): + """Load values from settings.toml into os.environ, so that os.getenv returns them.""" + if not os.path.isfile("settings.toml"): + raise FileNotFoundError("settings.toml not cound in current directory.") + + print("settings.toml found. Updating environment variables:") + with open("settings.toml", "rb") as toml_file: + try: + settings = tomllib.load(toml_file) + except tomllib.TOMLDecodeError as e: + raise tomllib.TOMLDecodeError("Error with settings.toml file.") from e + + invalid_types = set() + for key, value in settings.items(): + if not isinstance(value, (bool, int, float, str)): + invalid_types.add(type(value).__name__) + if invalid_types: + invalid_types_string = ", ".join(invalid_types) + raise ValueError( + f"The types: '{invalid_types_string}' are not supported in settings.toml." + ) + + for key, value in settings.items(): + key = str(key) + if key in os.environ: + print(f" - {key} already exists in environment") + continue + os.environ[key] = str(value) + print(f" - {key} added") + + return settings + + def patch_system(): """Patch modules that may be different due to the platform.""" # pylint: disable=import-outside-toplevel diff --git a/src/adafruit_blinka/board/orangepi/orangepi3lts.py b/src/adafruit_blinka/board/orangepi/orangepi3lts.py new file mode 100644 index 0000000..25ef624 --- /dev/null +++ b/src/adafruit_blinka/board/orangepi/orangepi3lts.py @@ -0,0 +1,34 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Pin definitions for the Orange Pi 3 LTS.""" + +from adafruit_blinka.microcontroller.allwinner.h6 import pin + +PD26 = pin.PD26 +SDA = pin.PD26 +PD25 = pin.PD25 +SCL = pin.PD25 +PD22 = pin.PD22 +PL2 = pin.PL2 +PL3 = pin.PL3 +PD24 = pin.PD24 +UART3_RX = pin.PD24 +PD18 = pin.PD18 +PD23 = pin.PD23 +UART3_TX = pin.PD23 +PL10 = pin.PL10 +PD15 = pin.PD15 +PD16 = pin.PD16 +PH5 = pin.PH5 +PH6 = pin.PH6 +PD21 = pin.PD21 +PH4 = pin.PH4 +SPI1_CLK = pin.PH4 +PH3 = pin.PH3 +SPI1_CS = pin.PH3 +PL8 = pin.PL8 + +SCLK = pin.PH4 +MOSI = pin.PH5 +MISO = pin.PH6 diff --git a/src/adafruit_blinka/board/raspberrypi/raspi_5.py b/src/adafruit_blinka/board/raspberrypi/raspi_5.py new file mode 100644 index 0000000..ef09c3a --- /dev/null +++ b/src/adafruit_blinka/board/raspberrypi/raspi_5.py @@ -0,0 +1,58 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Pin definitions for Raspberry Pi 5 models using the BCM2712.""" + +from adafruit_blinka.microcontroller.bcm2712 import pin + +D0 = pin.D0 +D1 = pin.D1 + +D2 = pin.D2 +SDA = pin.SDA +D3 = pin.D3 +SCL = pin.SCL + +D4 = pin.D4 +D5 = pin.D5 +D6 = pin.D6 + +D7 = pin.D7 +CE1 = pin.D7 +D8 = pin.D8 +CE0 = pin.D8 +D9 = pin.D9 +MISO = pin.D9 +D10 = pin.D10 +MOSI = pin.D10 +D11 = pin.D11 +SCLK = pin.D11 +SCK = pin.D11 + +D12 = pin.D12 +D13 = pin.D13 + +D14 = pin.D14 +TXD = pin.D14 +D15 = pin.D15 +RXD = pin.D15 +# create alias for most of the examples +TX = pin.D14 +RX = pin.D15 + +D16 = pin.D16 +D17 = pin.D17 +D18 = pin.D18 +D19 = pin.D19 +MISO_1 = pin.D19 +D20 = pin.D20 +MOSI_1 = pin.D20 +D21 = pin.D21 +SCLK_1 = pin.D21 +SCK_1 = pin.D21 +D22 = pin.D22 +D23 = pin.D23 +D24 = pin.D24 +D25 = pin.D25 +D26 = pin.D26 +D27 = pin.D27 diff --git a/src/adafruit_blinka/microcontroller/bcm2711/pin.py b/src/adafruit_blinka/microcontroller/bcm2711/pin.py index ffc508b..69e0a53 100644 --- a/src/adafruit_blinka/microcontroller/bcm2711/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm2711/pin.py @@ -2,11 +2,9 @@ # # SPDX-License-Identifier: MIT """Broadcom BCM2711 pin names""" -from RPi import GPIO -from adafruit_blinka.microcontroller.bcm283x.pin import Pin -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! +# Use RPi.GPIO pins for Raspberry Pi 4 +from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pin import Pin D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/__init__.py b/src/adafruit_blinka/microcontroller/bcm2712/__init__.py similarity index 100% rename from src/adafruit_blinka/microcontroller/bcm283x/pwmio/__init__.py rename to src/adafruit_blinka/microcontroller/bcm2712/__init__.py diff --git a/src/adafruit_blinka/microcontroller/bcm2712/pin.py b/src/adafruit_blinka/microcontroller/bcm2712/pin.py new file mode 100644 index 0000000..736114f --- /dev/null +++ b/src/adafruit_blinka/microcontroller/bcm2712/pin.py @@ -0,0 +1,100 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Broadcom BCM2712 pin names""" + +# Use lgpio pins for Raspberry Pi 5 +from adafruit_blinka.microcontroller.generic_linux.lgpio_pin import Pin + +D0 = Pin(0) +D1 = Pin(1) + +D2 = Pin(2) +SDA = Pin(2) +D3 = Pin(3) +SCL = Pin(3) + +D4 = Pin(4) +D5 = Pin(5) +D6 = Pin(6) + +D7 = Pin(7) +CE1 = Pin(7) +D8 = Pin(8) +CE0 = Pin(8) +D9 = Pin(9) +MISO = Pin(9) +D10 = Pin(10) +MOSI = Pin(10) +D11 = Pin(11) +SCLK = Pin(11) # Raspberry Pi naming +SCK = Pin(11) # CircuitPython naming + +D12 = Pin(12) +D13 = Pin(13) + +D14 = Pin(14) +TXD = Pin(14) +D15 = Pin(15) +RXD = Pin(15) + +D16 = Pin(16) +D17 = Pin(17) +D18 = Pin(18) +D19 = Pin(19) +MISO_1 = Pin(19) +D20 = Pin(20) +MOSI_1 = Pin(20) +D21 = Pin(21) +SCLK_1 = Pin(21) +SCK_1 = Pin(21) +D22 = Pin(22) +D23 = Pin(23) +D24 = Pin(24) +D25 = Pin(25) +D26 = Pin(26) +D27 = Pin(27) +D28 = Pin(28) +D29 = Pin(29) +D30 = Pin(30) +D31 = Pin(31) +D32 = Pin(32) +D33 = Pin(33) +D34 = Pin(34) +D35 = Pin(35) +D36 = Pin(36) +D37 = Pin(37) +D38 = Pin(38) +D39 = Pin(39) +D40 = Pin(40) +MISO_2 = Pin(40) +D41 = Pin(41) +MOSI_2 = Pin(41) +D42 = Pin(42) +SCLK_2 = Pin(42) +SCK_2 = Pin(43) +D43 = Pin(43) +D44 = Pin(44) +D45 = Pin(45) + +# ordered as spiId, sckId, mosiId, misoId +spiPorts = ( + (0, SCLK, MOSI, MISO), + (1, SCLK_1, MOSI_1, MISO_1), + (2, SCLK_2, MOSI_2, MISO_2), + (3, D3, D2, D1), + (4, D7, D6, D5), + (5, D15, D14, D13), +) + +# ordered as uartId, txId, rxId +uartPorts = ((1, TXD, RXD),) + +# These are the known hardware I2C ports / pins. +# For software I2C ports created with the i2c-gpio overlay, see: +# https://github.com/adafruit/Adafruit_Python_Extended_Bus +i2cPorts = ( + (1, SCL, SDA), + (0, D1, D0), # both pi 1 and pi 2 i2c ports! + (10, D45, D44), # internal i2c bus for the CM4 +) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pin.py b/src/adafruit_blinka/microcontroller/bcm283x/pin.py index a24ed22..d741ada 100644 --- a/src/adafruit_blinka/microcontroller/bcm283x/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm283x/pin.py @@ -2,73 +2,10 @@ # # SPDX-License-Identifier: MIT """Broadcom BCM283x pin names""" -from RPi import GPIO -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! +# Use RPi.GPIO pins for Raspberry Pi 1-3B+ +from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pin import Pin - -class Pin: - """Pins dont exist in CPython so...lets make our own!""" - - IN = 0 - OUT = 1 - LOW = 0 - HIGH = 1 - PULL_NONE = 0 - PULL_UP = 1 - PULL_DOWN = 2 - - id = None - _value = LOW - _mode = IN - - def __init__(self, bcm_number): - self.id = bcm_number - - def __repr__(self): - return str(self.id) - - def __eq__(self, other): - return self.id == other - - def init(self, mode=IN, pull=None): - """Initialize the Pin""" - if mode is not None: - if mode == self.IN: - self._mode = self.IN - GPIO.setup(self.id, GPIO.IN) - elif mode == self.OUT: - self._mode = self.OUT - GPIO.setup(self.id, GPIO.OUT) - else: - raise RuntimeError("Invalid mode for pin: %s" % self.id) - if pull is not None: - if self._mode != self.IN: - raise RuntimeError("Cannot set pull resistor on output") - if pull == self.PULL_UP: - GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_UP) - elif pull == self.PULL_DOWN: - GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) - else: - raise RuntimeError("Invalid pull for pin: %s" % self.id) - - def value(self, val=None): - """Set or return the Pin Value""" - if val is not None: - if val == self.LOW: - self._value = val - GPIO.output(self.id, val) - elif val == self.HIGH: - self._value = val - GPIO.output(self.id, val) - else: - raise RuntimeError("Invalid value for pin") - return None - return GPIO.input(self.id) - - -# Pi 1B rev1 only? D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/rotaryio.py b/src/adafruit_blinka/microcontroller/bcm283x/rotaryio.py new file mode 100644 index 0000000..d7017ff --- /dev/null +++ b/src/adafruit_blinka/microcontroller/bcm283x/rotaryio.py @@ -0,0 +1,192 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +# SPDX-License-Identifier: BSD-3-Clause +""" +`rotaryio` - Support for reading rotation sensors +=========================================================== +See `CircuitPython:rotaryio` in CircuitPython for more details. + +Raspberry Pi PIO implementation + +* Author(s): Melissa LeBlanc-Williams +""" + +from __future__ import annotations +import array +import microcontroller + +try: + import adafruit_pioasm + from adafruit_rp1pio import StateMachine +except ImportError as exc: + raise ImportError( + "adafruit_pioasm and adafruit_rp1pio are required for this module" + ) from exc + +_n_read = 17 +_program = adafruit_pioasm.Program( + """ +; +; Copyright (c) 2023 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; +.pio_version 0 // only requires PIO version 0 + +.program quadrature_encoder + +; the code must be loaded at address 0, because it uses computed jumps +.origin 0 + + +; the code works by running a loop that continuously shifts the 2 phase pins into +; ISR and looks at the lower 4 bits to do a computed jump to an instruction that +; does the proper "do nothing" | "increment" | "decrement" action for that pin +; state change (or no change) + +; ISR holds the last state of the 2 pins during most of the code. The Y register +; keeps the current encoder count and is incremented / decremented according to +; the steps sampled + +; the program keeps trying to write the current count to the RX FIFO without +; blocking. To read the current count, the user code must drain the FIFO first +; and wait for a fresh sample (takes ~4 SM cycles on average). The worst case +; sampling loop takes 10 cycles, so this program is able to read step rates up +; to sysclk / 10 (e.g., sysclk 125MHz, max step rate = 12.5 Msteps/sec) + +; 00 state + jmp update ; read 00 + jmp decrement ; read 01 + jmp increment ; read 10 + jmp update ; read 11 + +; 01 state + jmp increment ; read 00 + jmp update ; read 01 + jmp update ; read 10 + jmp decrement ; read 11 + +; 10 state + jmp decrement ; read 00 + jmp update ; read 01 + jmp update ; read 10 + jmp increment ; read 11 + +; to reduce code size, the last 2 states are implemented in place and become the +; target for the other jumps + +; 11 state + jmp update ; read 00 + jmp increment ; read 01 +decrement: + ; note: the target of this instruction must be the next address, so that + ; the effect of the instruction does not depend on the value of Y. The + ; same is true for the "jmp y--" below. Basically "jmp y--, " + ; is just a pure "decrement y" instruction, with no other side effects + jmp y--, update ; read 10 + + ; this is where the main loop starts +.wrap_target +update: + mov isr, y ; read 11 + push noblock + +sample_pins: + ; we shift into ISR the last state of the 2 input pins (now in OSR) and + ; the new state of the 2 pins, thus producing the 4 bit target for the + ; computed jump into the correct action for this state. Both the PUSH + ; above and the OUT below zero out the other bits in ISR + out isr, 2 + in pins, 2 + + ; save the state in the OSR, so that we can use ISR for other purposes + mov osr, isr + ; jump to the correct state machine action + mov pc, isr + + ; the PIO does not have a increment instruction, so to do that we do a + ; negate, decrement, negate sequence +increment: + mov y, ~y + jmp y--, increment_cont +increment_cont: + mov y, ~y +.wrap ; the .wrap here avoids one jump instruction and saves a cycle too +""" +) + +_zero_y = adafruit_pioasm.assemble("set y 0") + + +class IncrementalEncoder: + """ + IncrementalEncoder determines the relative rotational position based on two series of + pulses. It assumes that the encoder’s common pin(s) are connected to ground,and enables + pull-ups on pin_a and pin_b. + + Create an IncrementalEncoder object associated with the given pins. It tracks the + positional state of an incremental rotary encoder (also known as a quadrature encoder.) + Position is relative to the position when the object is constructed. + """ + + def __init__( + self, pin_a: microcontroller.Pin, pin_b: microcontroller.Pin, divisor: int = 4 + ): + """Create an incremental encoder on pin_a and the next higher pin + + Always operates in "x4" mode (one count per quadrature edge) + + Assumes but does not check that pin_b is one above pin_a.""" + if pin_b is not None and pin_b.id != pin_a.id + 1: + raise ValueError("pin_b must be None or one higher than pin_a") + + try: + self._sm = StateMachine( + _program.assembled, + frequency=0, + init=_zero_y, + first_in_pin=pin_a, + in_pin_count=2, + pull_in_pin_up=0x3, + auto_push=True, + push_threshold=32, + in_shift_right=False, + **_program.pio_kwargs, + ) + except RuntimeError as e: + if "(error -13)" in e.args[0]: + raise RuntimeError( + "This feature requires a rules file to allow access to PIO. See " + "https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/" + "using-neopixels-on-the-pi-5#updating-permissions-3189429" + ) from e + raise + self._buffer = array.array("i", [0] * _n_read) + self.divisor = divisor + self._position = 0 + + def deinit(self): + """Deinitializes the IncrementalEncoder and releases any hardware resources for reuse.""" + self._sm.deinit() + + def __enter__(self) -> IncrementalEncoder: + """No-op used by Context Managers.""" + return self + + def __exit__(self, _type, _value, _traceback): + """ + Automatically deinitializes when exiting a context. See + :ref:`lifetime-and-contextmanagers` for more info. + """ + self.deinit() + + @property + def position(self): + """The current position in terms of pulses. The number of pulses per rotation is defined + by the specific hardware and by the divisor.""" + self._sm.readinto(self._buffer) # read N stale values + 1 fresh value + raw_position = self._buffer[-1] + delta = int((raw_position - self._position * self.divisor) / self.divisor) + self._position += delta + return self._position diff --git a/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py new file mode 100644 index 0000000..25a8268 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py @@ -0,0 +1,129 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""A Pin class for use with lgpio.""" + +from pathlib import Path +import lgpio + + +def _get_gpiochip(): + """ + Determines the handle of the GPIO chip device to access. + + iterate through sysfs to find a GPIO chip device with a driver known to be + used for userspace GPIO access. + """ + for dev in Path("/sys/bus/gpio/devices").glob("gpiochip*"): + drivers = set((dev / "of_node/compatible").read_text().split("\0")) + # check if driver names are intended for userspace control + if drivers & { + "raspberrypi,rp1-gpio", + "raspberrypi,bcm2835-gpio", + "raspberrypi,bcm2711-gpio", + }: + return lgpio.gpiochip_open(int(dev.name[-1])) + # return chip0 as a fallback + return lgpio.gpiochip_open(0) + + +CHIP = _get_gpiochip() + + +class Pin: + """Pins dont exist in CPython so...lets make our own!""" + + LOW = 0 + HIGH = 1 + OFF = LOW + ON = HIGH + + # values of lg mode constants + PULL_NONE = 0x80 + PULL_UP = 0x20 + PULL_DOWN = 0x40 + ACTIVE_LOW = 0x02 + + # drive mode lg constants + OPEN_DRAIN = 0x04 + IN = 0x0100 + OUT = 0x0200 + + # LG mode constants + _LG_ALERT = 0x400 + _LG_GROUP = 0x800 + _LG_MODES = IN | OUT | _LG_ALERT | _LG_GROUP + _LG_PULLS = PULL_NONE | PULL_UP | PULL_NONE | ACTIVE_LOW + _LG_DRIVES = OPEN_DRAIN + + id = None + _value = LOW + _mode = IN + + # we want exceptions + lgpio.exceptions = True + + def __init__(self, bcm_number): + self.id = bcm_number + + def __repr__(self): + return str(self.id) + + def __eq__(self, other): + return self.id == other + + def init(self, mode=IN, pull=None): + """Initialize the Pin""" + if mode is not None: + if mode == Pin.IN: + self._mode = Pin.IN + self._set_gpio_mode_in() + elif mode == self.OUT: + self._mode = Pin.OUT + Pin._check_result(lgpio.gpio_claim_output(CHIP, self.id, Pin.LOW)) + else: + raise RuntimeError(f"Invalid mode for pin: {self.id}") + if pull is not None: + if self._mode != Pin.IN: + raise RuntimeError("Can only set pull resistor on input") + if pull in {Pin.PULL_UP, Pin.PULL_DOWN, Pin.PULL_NONE}: + self._set_gpio_mode_in(lflags=pull) + else: + raise RuntimeError(f"Invalid pull for pin: {self.id}") + + def value(self, val=None): + """Set or return the Pin Value""" + if val is not None: + if val == Pin.LOW: + self._value = val + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) + elif val == Pin.HIGH: + self._value = val + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) + else: + raise RuntimeError("Invalid value for pin") + return None + return Pin._check_result(lgpio.gpio_read(CHIP, self.id)) + + @staticmethod + def _check_result(result): + """ + convert any result other than zero to a text message and pass it back + as a runtime exception. Typical usage: use the lgpio call as the + argument. + """ + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + return result + + def _set_gpio_mode_in(self, lflags=0): + """ + claim a gpio as input, or modify the flags (PULL_UP, PULL_DOWN, ... ) + """ + # This gpio_free may seem redundant, but is required when + # changing the line-flags of an already acquired input line + try: + lgpio.gpio_free(CHIP, self.id) + except lgpio.error: + pass + Pin._check_result(lgpio.gpio_claim_input(CHIP, self.id, lFlags=lflags)) diff --git a/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py new file mode 100644 index 0000000..e4cf5a7 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py @@ -0,0 +1,158 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT + +""" PWMOut Class for lgpio lg library tx_pwm library """ + +import lgpio +from adafruit_blinka.microcontroller.generic_linux.lgpio_pin import CHIP + + +class PWMError(IOError): + """Base class for PWM errors.""" + + +class PWMOut: + """Pulse Width Modulation Output Class""" + + def __init__(self, pin, *, frequency=500, duty_cycle=0, variable_frequency=False): + if variable_frequency: + print("Variable Frequency is not supported, ignoring...") + self._pin = pin + result = lgpio.gpio_claim_output(CHIP, self._pin.id, lFlags=lgpio.SET_PULL_NONE) + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + self._enabled = False + self._deinited = False + self._period = 0 + # set frequency + self._frequency = frequency + # set duty + self.duty_cycle = duty_cycle + self.enabled = True + + def __del__(self): + self.deinit() + + def __enter__(self): + return self + + def __exit__(self, _exc_type, _exc_val, _exc_tb): + self.deinit() + + def deinit(self): + """Deinit the PWM.""" + if not self._deinited: + if self.enabled: + self._enabled = False # turn off the pwm + self._deinited = True + + def _is_deinited(self): + """raise Value error if the object has been de-inited""" + if self._deinited: + raise ValueError( + "Object has been deinitialize and can no longer " + "be used. Create a new object." + ) + + @property + def period(self): + """Get or set the PWM's output period in seconds. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + return 1.0 / self.frequency + + @period.setter + def period(self, period): + if not isinstance(period, (int, float)): + raise TypeError("Invalid period type, should be int or float.") + + self.frequency = 1.0 / period + + @property + def duty_cycle(self): + """Get or set the PWM's output duty cycle which is the fraction of + each pulse which is high. 16-bit + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + ValueError: if value is out of bounds of 0.0 to 1.0. + + :type: int, float + """ + return int(self._duty_cycle * 65535) + + @duty_cycle.setter + def duty_cycle(self, duty_cycle): + if not isinstance(duty_cycle, (int, float)): + raise TypeError("Invalid duty cycle type, should be int or float.") + + if not 0 <= duty_cycle <= 65535: + raise ValueError("Invalid duty cycle value, should be between 0 and 65535") + + # convert from 16-bit + duty_cycle /= 65535.0 + + self._duty_cycle = duty_cycle + if self._enabled: + self.enabled = True # turn on with new values + + @property + def frequency(self): + """Get or set the PWM's output frequency in Hertz. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + + return self._frequency + + @frequency.setter + def frequency(self, frequency): + if not isinstance(frequency, (int, float)): + raise TypeError("Invalid frequency type, should be int or float.") + + self._frequency = frequency + if self.enabled: + self.enabled = True # turn on with new values + + @property + def enabled(self): + """Get or set the PWM's output enabled state. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not bool. + + :type: bool + """ + return self._enabled + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError("Invalid enabled type, should be bool.") + + frequency = self._frequency if value else 0 + duty_cycle = round(self._duty_cycle * 100) + self._enabled = value + result = lgpio.tx_pwm(CHIP, self._pin.id, frequency, duty_cycle) + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + return result + + # String representation + def __str__(self): + return ( + f"pin {self._pin} (freq={self.frequency:f} Hz, duty_cycle=" + f"{self.duty_cycle}({round(self.duty_cycle / 655.35)}%)" + ) diff --git a/src/adafruit_blinka/microcontroller/generic_linux/rotaryio.py b/src/adafruit_blinka/microcontroller/generic_linux/rotaryio.py new file mode 100644 index 0000000..f2a55d0 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/rotaryio.py @@ -0,0 +1,139 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +""" +`rotaryio` - Support for reading rotation sensors +=========================================================== +See `CircuitPython:rotaryio` in CircuitPython for more details. + +Generic Threading/DigitalIO implementation for Linux + +* Author(s): Melissa LeBlanc-Williams +""" + +from __future__ import annotations +import threading +import microcontroller +import digitalio + +# Define the state transition table for the quadrature encoder +transitions = [ + 0, # 00 -> 00 no movement + -1, # 00 -> 01 3/4 ccw (11 detent) or 1/4 ccw (00 at detent) + +1, # 00 -> 10 3/4 cw or 1/4 cw + 0, # 00 -> 11 non-Gray-code transition + +1, # 01 -> 00 2/4 or 4/4 cw + 0, # 01 -> 01 no movement + 0, # 01 -> 10 non-Gray-code transition + -1, # 01 -> 11 4/4 or 2/4 ccw + -1, # 10 -> 00 2/4 or 4/4 ccw + 0, # 10 -> 01 non-Gray-code transition + 0, # 10 -> 10 no movement + +1, # 10 -> 11 4/4 or 2/4 cw + 0, # 11 -> 00 non-Gray-code transition + +1, # 11 -> 01 1/4 or 3/4 cw + -1, # 11 -> 10 1/4 or 3/4 ccw + 0, # 11 -> 11 no movement +] + + +class IncrementalEncoder: + """ + IncrementalEncoder determines the relative rotational position based on two series of + pulses. It assumes that the encoder’s common pin(s) are connected to ground,and enables + pull-ups on pin_a and pin_b. + + Create an IncrementalEncoder object associated with the given pins. It tracks the + positional state of an incremental rotary encoder (also known as a quadrature encoder.) + Position is relative to the position when the object is constructed. + """ + + def __init__( + self, pin_a: microcontroller.Pin, pin_b: microcontroller.Pin, divisor: int = 4 + ): + """ + Create an IncrementalEncoder object associated with the given pins. It tracks the + positional state of an incremental rotary encoder (also known as a quadrature encoder.) + Position is relative to the position when the object is constructed. + + :param microcontroller.Pin pin_a: The first pin connected to the encoder. + :param microcontroller.Pin pin_b: The second pin connected to the encoder. + :param int divisor: The number of pulses per encoder step. Default is 4. + """ + self._pin_a = digitalio.DigitalInOut(pin_a) + self._pin_a.switch_to_input(pull=digitalio.Pull.UP) + self._pin_b = digitalio.DigitalInOut(pin_b) + self._pin_b.switch_to_input(pull=digitalio.Pull.UP) + self._position = 0 + self._last_state = 0 + self._divisor = divisor + self._sub_count = 0 + self._poll_thread = threading.Thread(target=self._polling_loop, daemon=True) + self._poll_thread.start() + + def deinit(self): + """Deinitializes the IncrementalEncoder and releases any hardware resources for reuse.""" + self._pin_a.deinit() + self._pin_b.deinit() + if self._poll_thread.is_alive(): + self._poll_thread.join() + + def __enter__(self) -> IncrementalEncoder: + """No-op used by Context Managers.""" + return self + + def __exit__(self, _type, _value, _traceback): + """ + Automatically deinitializes when exiting a context. See + :ref:`lifetime-and-contextmanagers` for more info. + """ + self.deinit() + + @property + def divisor(self) -> int: + """The divisor of the quadrature signal. Use 1 for encoders without detents, or encoders + with 4 detents per cycle. Use 2 for encoders with 2 detents per cycle. Use 4 for encoders + with 1 detent per cycle.""" + return self._divisor + + @divisor.setter + def divisor(self, value: int): + self._divisor = value + + @property + def position(self) -> int: + """The current position in terms of pulses. The number of pulses per rotation is defined + by the specific hardware and by the divisor.""" + return self._position + + @position.setter + def position(self, value: int): + self._position = value + + def _get_pin_state(self) -> int: + """Returns the current state of the pins.""" + return self._pin_a.value << 1 | self._pin_b.value + + def _polling_loop(self): + while True: + self._poll_encoder() + + def _poll_encoder(self): + # Check the state of the pins + # if either pin has changed, update the state + new_state = self._get_pin_state() + if new_state != self._last_state: + self._state_update(new_state) + self._last_state = new_state + + def _state_update(self, new_state: int): + new_state &= 3 + index = self._last_state << 2 | new_state + sub_increment = transitions[index] + self._sub_count += sub_increment + if self._sub_count >= self._divisor: + self._position += 1 + self._sub_count = 0 + elif self._sub_count <= -self._divisor: + self._position -= 1 + self._sub_count = 0 diff --git a/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py new file mode 100644 index 0000000..cf3acbd --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""A Pin class for use with Rpi.GPIO.""" + +from RPi import GPIO + +GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 +GPIO.setwarnings(False) # shh! + + +class Pin: + """Pins dont exist in CPython so...lets make our own!""" + + IN = 0 + OUT = 1 + LOW = 0 + HIGH = 1 + PULL_NONE = 0 + PULL_UP = 1 + PULL_DOWN = 2 + + id = None + _value = LOW + _mode = IN + + def __init__(self, bcm_number): + self.id = bcm_number + + def __repr__(self): + return str(self.id) + + def __eq__(self, other): + return self.id == other + + def init(self, mode=IN, pull=None): + """Initialize the Pin""" + if mode is not None: + if mode == self.IN: + self._mode = self.IN + GPIO.setup(self.id, GPIO.IN) + elif mode == self.OUT: + self._mode = self.OUT + GPIO.setup(self.id, GPIO.OUT) + else: + raise RuntimeError("Invalid mode for pin: %s" % self.id) + if pull is not None: + if self._mode != self.IN: + raise RuntimeError("Cannot set pull resistor on output") + if pull == self.PULL_UP: + GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_UP) + elif pull == self.PULL_DOWN: + GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) + else: + raise RuntimeError("Invalid pull for pin: %s" % self.id) + + def value(self, val=None): + """Set or return the Pin Value""" + if val is not None: + if val == self.LOW: + self._value = val + GPIO.output(self.id, val) + elif val == self.HIGH: + self._value = val + GPIO.output(self.id, val) + else: + raise RuntimeError("Invalid value for pin") + return None + return GPIO.input(self.id) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pwmout.py similarity index 100% rename from src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py rename to src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pwmout.py diff --git a/src/board.py b/src/board.py index c0d141e..3aa60bd 100644 --- a/src/board.py +++ b/src/board.py @@ -41,13 +41,10 @@ elif board_id == ap_board.PYBOARD: elif board_id == ap_board.RASPBERRY_PI_PICO: from adafruit_blinka.board.raspberrypi.pico import * -elif ( - detector.board.RASPBERRY_PI_4B - or detector.board.RASPBERRY_PI_CM4 - or detector.board.RASPBERRY_PI_CM4S - or detector.board.RASPBERRY_PI_400 - or detector.board.RASPBERRY_PI_5 -): +elif detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.board.raspberrypi.raspi_5 import * + +elif detector.board.any_raspberry_pi_4_board: from adafruit_blinka.board.raspberrypi.raspi_4b import * elif detector.board.any_raspberry_pi_40_pin: @@ -134,6 +131,9 @@ elif board_id == ap_board.ORANGE_PI_ZERO_2: elif board_id == ap_board.ORANGE_PI_3: from adafruit_blinka.board.orangepi.orangepi3 import * +elif board_id == ap_board.ORANGE_PI_3_LTS: + from adafruit_blinka.board.orangepi.orangepi3lts import * + elif board_id == ap_board.ORANGE_PI_3B: from adafruit_blinka.board.orangepi.orangepi3b import * diff --git a/src/digitalio.py b/src/digitalio.py index 6f04984..c56f349 100644 --- a/src/digitalio.py +++ b/src/digitalio.py @@ -15,14 +15,10 @@ from adafruit_blinka.agnostic import board_id, detector # By Chip Class if detector.chip.BCM2XXX: - if board_id in ( - "RASPBERRY_PI_4B", - "RASPBERRY_PI_400", - "RASPBERRY_PI_CM4", - "RASPBERRY_PI_CM4S", - "RASPBERRY_PI_5", - ): - from adafruit_blinka.microcontroller.bcm2711.pin import * + if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.bcm2712.pin import Pin + elif detector.board.any_raspberry_pi_4_board: + from adafruit_blinka.microcontroller.bcm2711.pin import Pin else: from adafruit_blinka.microcontroller.bcm283x.pin import Pin elif detector.chip.AM33XX: diff --git a/src/microcontroller/pin.py b/src/microcontroller/pin.py index 3d4a560..c461538 100644 --- a/src/microcontroller/pin.py +++ b/src/microcontroller/pin.py @@ -4,7 +4,7 @@ """Pins named after their chip name.""" import sys from adafruit_platformdetect.constants import chips as ap_chip, boards as ap_boards -from adafruit_blinka.agnostic import board_id, chip_id +from adafruit_blinka.agnostic import board_id, chip_id, detector # We intentionally are patching into this namespace so skip the wildcard check. # pylint: disable=unused-wildcard-import,wildcard-import,ungrouped-imports @@ -16,13 +16,9 @@ elif chip_id == ap_chip.STM32F405: elif chip_id == ap_chip.RP2040: from adafruit_blinka.microcontroller.rp2040.pin import * elif chip_id == ap_chip.BCM2XXX: - if board_id in ( - "RASPBERRY_PI_4B", - "RASPBERRY_PI_400", - "RASPBERRY_PI_CM4", - "RASPBERRY_PI_CM4S", - "RASPBERRY_PI_5", - ): + if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.bcm2712.pin import * + elif detector.board.any_raspberry_pi_4_board: from adafruit_blinka.microcontroller.bcm2711.pin import * else: from adafruit_blinka.microcontroller.bcm283x.pin import * diff --git a/src/neopixel_write.py b/src/neopixel_write.py index 77e5776..cc9835a 100644 --- a/src/neopixel_write.py +++ b/src/neopixel_write.py @@ -10,13 +10,16 @@ Currently supported on Raspberry Pi only. * Author(s): ladyada """ -# pylint: disable=too-many-boolean-expressions +# pylint: disable=too-many-boolean-expressions, ungrouped-imports import sys from adafruit_blinka.agnostic import detector if detector.board.any_raspberry_pi: - from adafruit_blinka.microcontroller.bcm283x import neopixel as _neopixel + if detector.board.any_raspberry_pi_5_board: + import adafruit_raspberry_pi5_neopixel_write as _neopixel + else: + from adafruit_blinka.microcontroller.bcm283x import neopixel as _neopixel elif detector.board.pico_u2if: from adafruit_blinka.microcontroller.rp2040_u2if import neopixel as _neopixel elif detector.board.OS_AGNOSTIC_BOARD: diff --git a/src/pwmio.py b/src/pwmio.py index 72ce0d8..f6452f8 100644 --- a/src/pwmio.py +++ b/src/pwmio.py @@ -16,8 +16,11 @@ from adafruit_blinka.agnostic import detector # pylint: disable=unused-import -if detector.board.any_raspberry_pi: - from adafruit_blinka.microcontroller.bcm283x.pwmio.PWMOut import PWMOut +if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.generic_linux.lgpio_pwmout import PWMOut +elif detector.board.any_raspberry_pi: + # Pi 4 or lower + from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pwmout import PWMOut elif detector.board.any_bananapi: from adafruit_blinka.microcontroller.generic_linux.sysfs_pwmout import PWMOut elif detector.board.any_coral_board: diff --git a/src/rotaryio.py b/src/rotaryio.py new file mode 100644 index 0000000..b8bf4cb --- /dev/null +++ b/src/rotaryio.py @@ -0,0 +1,26 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +""" +`rotaryio` - Support for reading rotation sensors +=========================================================== +See `CircuitPython:rotaryio` in CircuitPython for more details. + +* Author(s): Melissa LeBlanc-Williams +""" + +from adafruit_blinka.agnostic import detector + +# pylint: disable=unused-import + +# Import any board specific modules here +if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.bcm283x.rotaryio import IncrementalEncoder +elif detector.board.any_embedded_linux: + # fall back to the generic linux implementation + from adafruit_blinka.microcontroller.generic_linux.rotaryio import ( + IncrementalEncoder, + ) +else: + # For non-Linux Boards, threading likely will work in the same way + raise NotImplementedError("Board not supported") diff --git a/tests/test_load_settings_toml.py b/tests/test_load_settings_toml.py new file mode 100644 index 0000000..4257108 --- /dev/null +++ b/tests/test_load_settings_toml.py @@ -0,0 +1,144 @@ +# SPDX-FileCopyrightText: 2025 Justin Myers +# +# SPDX-License-Identifier: MIT +import os +from unittest import mock +import pytest +from adafruit_blinka import load_settings_toml + +try: + import tomllib +except ImportError: + import toml as tomllib + +# pylint: disable=no-self-use,unused-argument + +CONVERTED_TOML = { + "123": 123, + "test": "test", + "test-hyphen": "test-hyphen", + "test_bool": True, + "test_number": 123, + "test_space": "test space", + "test_underscore": "test_underscore", + "true": False, +} + + +INVALID_TOML = b""" +# strings +test=test +""" + + +VALID_TOML = b""" +# strings +test="test" +test_space="test space" +test_underscore="test_underscore" +test-hyphen="test-hyphen" +# number +test_number=123 +# bool +test_bool=true +# other +123=123 +true=false +""" + +VALID_TOML_WITH_UNSUPPORTED_DATA_DICT = b""" +# dict +data = { key_1 = "value", key_2 = "value" } +""" + +VALID_TOML_WITH_UNSUPPORTED_DATA_LIST = b""" +# list +numbers = [ 1, 2, 3 ] +""" + +VALID_TOML_WITH_UNSUPPORTED_DATA_MANY = b""" +# dict +data = { key_1 = "value", key_2 = "value" } + +# list +numbers = [ 1, 2, 3 ] + +[nested] +test="test" +""" + +VALID_TOML_WITH_UNSUPPORTED_DATA_NESTED = b""" +[nested] +test="test" +""" + + +class TestLoadSettingsToml: + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=False)) + def test_raises_with_no_file(self): + with pytest.raises( + FileNotFoundError, match="settings.toml not cound in current directory." + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch("builtins.open", mock.mock_open(read_data=INVALID_TOML)) + def test_raises_with_invalid_file(self): + with pytest.raises( + tomllib.TOMLDecodeError, match="Error with settings.toml file." + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch( + "builtins.open", mock.mock_open(read_data=VALID_TOML_WITH_UNSUPPORTED_DATA_DICT) + ) + def test_raises_with_invalid_file_dict(self): + with pytest.raises( + ValueError, match="The types: 'dict' are not supported in settings.toml." + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch( + "builtins.open", mock.mock_open(read_data=VALID_TOML_WITH_UNSUPPORTED_DATA_LIST) + ) + def test_raises_with_invalid_file_list(self): + with pytest.raises( + ValueError, match="The types: 'list' are not supported in settings.toml." + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch( + "builtins.open", mock.mock_open(read_data=VALID_TOML_WITH_UNSUPPORTED_DATA_MANY) + ) + def test_raises_with_invalid_file_many(self): + with pytest.raises( + ValueError, + match="The types: 'dict, list' are not supported in settings.toml.", + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch( + "builtins.open", + mock.mock_open(read_data=VALID_TOML_WITH_UNSUPPORTED_DATA_NESTED), + ) + def test_raises_with_invalid_file_nested(self): + with pytest.raises( + ValueError, match="The types: 'dict' are not supported in settings.toml." + ): + load_settings_toml() + + @mock.patch("adafruit_blinka.os.path.isfile", mock.Mock(return_value=True)) + @mock.patch("builtins.open", mock.mock_open(read_data=VALID_TOML)) + @mock.patch.dict(os.environ, {}, clear=True) + def test_returns_data(self): + for key in CONVERTED_TOML: + assert os.getenv(key) is None + + assert load_settings_toml() == CONVERTED_TOML + + for key, value in CONVERTED_TOML.items(): + assert os.getenv(key) == str(value)