#
# 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)
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)
+# 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
# 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."
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):
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):
@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)}%)"
)
projects / Adafruit_Blinka-hackapet.git / commitdiff