From: Melissa LeBlanc-Williams Date: Thu, 13 Mar 2025 22:16:00 +0000 (-0700) Subject: Merge branch 'lgpio-native' of https://github.com/frank-pet/Adafruit_Blinka into... X-Git-Tag: 8.56.0^2~2 X-Git-Url: https://git.ayoreis.com/Adafruit_Blinka-hackapet.git/commitdiff_plain/ad088b416700669016cdf1a5ca3c3f44ce347d82?hp=58a8e1716d6f424c11f10d8d967dcfb02e71d9ea Merge branch 'lgpio-native' of https://github.com/frank-pet/Adafruit_Blinka into lgpio-native --- diff --git a/src/adafruit_blinka/microcontroller/bcm2711/pin.py b/src/adafruit_blinka/microcontroller/bcm2711/pin.py index ffc508b..59ac99a 100644 --- a/src/adafruit_blinka/microcontroller/bcm2711/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm2711/pin.py @@ -2,11 +2,12 @@ # # 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! +# pylint: disable=unused-import +# importing CHIP to make the lgpio CHIP handle available +from adafruit_blinka.microcontroller.bcm283x.pin import Pin, CHIP + +# pylint: enable=unused-import D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pin.py b/src/adafruit_blinka/microcontroller/bcm283x/pin.py index a24ed22..ddd377f 100644 --- a/src/adafruit_blinka/microcontroller/bcm283x/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm283x/pin.py @@ -2,29 +2,68 @@ # # SPDX-License-Identifier: MIT """Broadcom BCM283x pin names""" -from RPi import GPIO +from pathlib import Path +import lgpio -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! + +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!""" - IN = 0 - OUT = 1 LOW = 0 HIGH = 1 - PULL_NONE = 0 - PULL_UP = 1 - PULL_DOWN = 2 + 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 + self.id = bcm_number # pylint: disable=invalid-name def __repr__(self): return str(self.id) @@ -35,40 +74,60 @@ class Pin: 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) + if mode == Pin.IN: + self._mode = Pin.IN + self._set_gpio_mode_in() elif mode == self.OUT: - self._mode = self.OUT - GPIO.setup(self.id, GPIO.OUT) + self._mode = Pin.OUT + Pin._check_result(lgpio.gpio_claim_output(CHIP, self.id, Pin.LOW)) else: - raise RuntimeError("Invalid mode for pin: %s" % self.id) + raise RuntimeError(f"Invalid mode for pin: {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) + 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("Invalid pull for pin: %s" % self.id) + 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 == self.LOW: + if val == Pin.LOW: self._value = val - GPIO.output(self.id, val) - elif val == self.HIGH: + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) + elif val == Pin.HIGH: self._value = val - GPIO.output(self.id, val) + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) else: raise RuntimeError("Invalid value for pin") return None - return GPIO.input(self.id) + 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)) -# Pi 1B rev1 only? D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py b/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py index 3b7b57f..009ae36 100644 --- a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py +++ b/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py @@ -1,11 +1,12 @@ +# pylint: disable=invalid-name # SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries # # SPDX-License-Identifier: MIT -"""Custom PWMOut Wrapper for Rpi.GPIO PWM Class""" -from RPi import GPIO +# pylint: enable=invalid-name +""" PWMOut Class for lgpio lg library tx_pwm library """ -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! +import lgpio +import board # need board to get access to the CHIP object in the pin module # pylint: disable=unnecessary-pass @@ -18,13 +19,26 @@ class PWMError(IOError): # pylint: enable=unnecessary-pass -class PWMOut: +class PWMOut: # pylint: disable=invalid-name """Pulse Width Modulation Output Class""" def __init__(self, pin, *, frequency=500, duty_cycle=0, variable_frequency=False): - self._pwmpin = None + if variable_frequency: + print("Variable Frequency is not supported, ignoring...") + self._pin = pin + result = lgpio.gpio_claim_output( + board.pin.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 - self._open(pin, duty_cycle, frequency, variable_frequency) + # set frequency + self._frequency = frequency + # set duty + self.duty_cycle = duty_cycle + self.enabled = True def __del__(self): self.deinit() @@ -32,33 +46,19 @@ class PWMOut: def __enter__(self): return self - def __exit__(self, t, value, traceback): + def __exit__(self, exc_type, exc_val, exc_tb): self.deinit() - def _open(self, pin, duty=0, freq=500, variable_frequency=False): - self._pin = pin - GPIO.setup(pin.id, GPIO.OUT) - self._pwmpin = GPIO.PWM(pin.id, freq) - - if variable_frequency: - print("Variable Frequency is not supported, continuing without it...") - - # set frequency - self.frequency = freq - # set duty - self.duty_cycle = duty - - self.enabled = True - def deinit(self): """Deinit the PWM.""" - if self._pwmpin is not None: - self._pwmpin.stop() - GPIO.cleanup(self._pin.id) - self._pwmpin = None + if not self._deinited: + if self.enabled: + self._enabled = False # turn off the pwm + self._deinited = True def _is_deinited(self): - if self._pwmpin is None: + """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." @@ -109,7 +109,8 @@ class PWMOut: duty_cycle /= 65535.0 self._duty_cycle = duty_cycle - self._pwmpin.ChangeDutyCycle(round(self._duty_cycle * 100)) + if self._enabled: + self.enabled = True # turn on with new values @property def frequency(self): @@ -129,8 +130,9 @@ class PWMOut: if not isinstance(frequency, (int, float)): raise TypeError("Invalid frequency type, should be int or float.") - self._pwmpin.ChangeFrequency(round(frequency)) self._frequency = frequency + if self.enabled: + self.enabled = True # turn on with new values @property def enabled(self): @@ -147,19 +149,19 @@ class PWMOut: @enabled.setter def enabled(self, value): if not isinstance(value, bool): - raise TypeError("Invalid enabled type, should be string.") - - if value: - self._pwmpin.start(round(self._duty_cycle * 100)) - else: - self._pwmpin.stop() + 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(board.pin.CHIP, self._pin.id, frequency, duty_cycle) + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + return result # String representation def __str__(self): - return "pin %s (freq=%f Hz, duty_cycle=%f%%)" % ( - self._pin, - self.frequency, - self.duty_cycle, + return ( + f"pin {self._pin} (freq={self.frequency:f} Hz, duty_cycle=" + f"{self.duty_cycle}({round(self.duty_cycle / 655.35)}%)" )