Merge branch 'lgpio-native' of https://github.com/frank-pet/Adafruit_Blinka into lgpio-native

Author: makermelissa

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)

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 @@ def __eq__(self, 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)
+            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)
 

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,47 +19,46 @@ 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()
 
     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 @@ def duty_cycle(self, duty_cycle):
         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 @@ def frequency(self, frequency):
         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 @@ def enabled(self):
     @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)}%)"
         )