python-periphery 2.4.3__py2.py3-none-any.whl → 2.5.0__py2.py3-none-any.whl

periphery/__init__.py

@@ -1,9 +1,9 @@
 import time
 
-__version__ = "2.4.3"
+__version__ = "2.5.0"
 "Module version string."
 
-version = (2, 4, 3)
+version = (2, 5, 0)
 "Module version tuple."
 
 

periphery/__init__.pyi

@@ -12,6 +12,7 @@ from periphery.pwm import PWM as PWM, PWMError as PWMError
 from periphery.serial import Serial as Serial, SerialError as SerialError
 from periphery.spi import SPI as SPI, SPIError as SPIError
 
+__version__: str
 version: tuple[int, int, int]
 
 def sleep(seconds: float) -> None: ...

periphery/gpio.py

@@ -9,14 +9,12 @@ class GPIOError(IOError):
 
 
 class EdgeEvent(collections.namedtuple('EdgeEvent', ['edge', 'timestamp'])):
-    def __new__(cls, edge, timestamp):
-        """EdgeEvent containing the event edge and event time reported by Linux.
+    """EdgeEvent containing the event edge and event time reported by Linux.
 
-        Args:
-            edge (str): event edge, either "rising" or "falling".
-            timestamp (int): event time in nanoseconds.
-        """
-        return super(EdgeEvent, cls).__new__(cls, edge, timestamp)
+    Attributes:
+        edge (str): event edge, either "rising" or "falling".
+        timestamp (int): event time in nanoseconds.
+    """
 
 
 class GPIO(object):
@@ -295,6 +293,45 @@ class GPIO(object):
     :type: str
     """
 
+    def _get_event_clock(self):
+        raise NotImplementedError()
+
+    def _set_event_clock(self, event_clock):
+        raise NotImplementedError()
+
+    event_clock = property(_get_event_clock, _set_event_clock)
+    """Get or set the GPIO's event clock. Can be "realtime", "monotonic",
+    "hte".
+
+    This property is not supported by sysfs GPIOs.
+
+    Raises:
+        GPIOError: if an I/O or OS error occurs.
+        TypeError: if `event_clock` type is not str.
+        ValueError: if `event_clock` value is invalid.
+
+    :type: str
+    """
+
+    def _get_debounce_us(self):
+        raise NotImplementedError()
+
+    def _set_debounce_us(self, debounce_us):
+        raise NotImplementedError()
+
+    debounce_us = property(_get_debounce_us, _set_debounce_us)
+    """Get or set the GPIO's debounce period in microseconds.
+
+    This property is not supported by sysfs GPIOs, nor by ABI version 1
+    character device GPIOs.
+
+    Raises:
+        GPIOError: if an I/O or OS error occurs.
+        TypeError: if `debounce_us` type is not int.
+
+    :type: int
+    """
+
     def _get_bias(self):
         raise NotImplementedError()
 

periphery/gpio.pyi

@@ -1,8 +1,6 @@
 from types import TracebackType
 from typing import Any
 
-KERNEL_VERSION: tuple[int, int]
-
 class GPIOError(IOError): ...
 
 class EdgeEvent:
@@ -38,6 +36,8 @@ class GPIO:
     def chip_label(self) -> str: ...
     direction: property
     edge: property
+    event_clock: property
+    debounce_us: property
     bias: property
     drive: property
     inverted: property
@@ -53,6 +53,8 @@ class CdevGPIO(GPIO):
         drive: str = ...,
         inverted: bool = ...,
         label: str | None = ...,
+        event_clock: str = ...,
+        debounce_us: int = ...,
     ) -> None: ...
     def __new__(self, path: str, line: int | str, direction: str, **kwargs: Any) -> CdevGPIO: ...  # noqa: Y034
 

periphery/gpio_cdev1.py

@@ -97,7 +97,7 @@ class Cdev1GPIO(GPIO):
 
         Instantiate a GPIO object and open the character device GPIO with the
         specified line and direction at the specified GPIO chip path (e.g.
-        "/dev/gpiochip0"). Defaults properties can be overridden with keyword
+        "/dev/gpiochip0"). Default properties can be overridden with keyword
         arguments.
 
         Args:
@@ -170,7 +170,7 @@ class Cdev1GPIO(GPIO):
             raise ValueError("Invalid drive, can be: \"default\", \"open_drain\", \"open_source\".")
 
         if not isinstance(inverted, bool):
-            raise TypeError("Invalid drive type, should be bool.")
+            raise TypeError("Invalid inverted type, should be bool.")
 
         if not isinstance(label, (type(None), str)):
             raise TypeError("Invalid label type, should be None or str.")
@@ -504,6 +504,33 @@ class Cdev1GPIO(GPIO):
 
     edge = property(_get_edge, _set_edge)
 
+    def _get_event_clock(self):
+        return "realtime"
+
+    def _set_event_clock(self, event_clock):
+        if not isinstance(event_clock, str):
+            raise TypeError("Invalid event_clock type, should be string.")
+        if event_clock not in ["realtime", "monotonic", "hte"]:
+            raise ValueError("Invalid event_clock, can be: \"realtime\", \"monotonic\", \"hte\".")
+
+        if event_clock != "realtime":
+            raise GPIOError(None, "Kernel version does not support configuring event clock")
+
+    event_clock = property(_get_event_clock, _set_event_clock)
+
+    def _get_debounce_us(self):
+        return 0
+
+    def _set_debounce_us(self, debounce_us):
+        if not isinstance(debounce_us, int):
+            raise TypeError("Invalid debounce_us type, should be integer.")
+        if debounce_us < 0:
+            raise ValueError("Invalid debounce_us value, should be zero or positive.")
+
+        raise GPIOError(None, "Kernel version does not support configuring debounce")
+
+    debounce_us = property(_get_debounce_us, _set_debounce_us)
+
     def _get_bias(self):
         return self._bias
 
@@ -544,7 +571,7 @@ class Cdev1GPIO(GPIO):
 
     def _set_inverted(self, inverted):
         if not isinstance(inverted, bool):
-            raise TypeError("Invalid drive type, should be bool.")
+            raise TypeError("Invalid inverted type, should be bool.")
 
         if self._inverted == inverted:
             return
@@ -566,30 +593,11 @@ class Cdev1GPIO(GPIO):
         except GPIOError:
             str_label = "<error>"
 
-        try:
-            str_direction = self.direction
-        except GPIOError:
-            str_direction = "<error>"
-
-        try:
-            str_edge = self.edge
-        except GPIOError:
-            str_edge = "<error>"
-
-        try:
-            str_bias = self.bias
-        except GPIOError:
-            str_bias = "<error>"
-
-        try:
-            str_drive = self.drive
-        except GPIOError:
-            str_drive = "<error>"
-
-        try:
-            str_inverted = str(self.inverted)
-        except GPIOError:
-            str_inverted = "<error>"
+        str_direction = self._direction
+        str_edge = self._edge
+        str_bias = self._bias
+        str_drive = self._drive
+        str_inverted = str(self._inverted)
 
         try:
             str_chip_name = self.chip_name

periphery/gpio_cdev2.py

@@ -109,6 +109,7 @@ class Cdev2GPIO(GPIO):
     _GPIO_V2_LINE_SET_CONFIG_IOCTL = 0xc110b40d
     _GPIO_V2_LINE_SET_VALUES_IOCTL = 0xc010b40f
     _GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES = 0x2
+    _GPIO_V2_LINE_ATTR_ID_DEBOUNCE = 0x3
     _GPIO_V2_LINE_EVENT_RISING_EDGE = 0x1
     _GPIO_V2_LINE_EVENT_FALLING_EDGE = 0x2
     _GPIO_V2_LINE_FLAG_ACTIVE_LOW = 0x2
@@ -122,15 +123,18 @@ class Cdev2GPIO(GPIO):
     _GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN = 0x200
     _GPIO_V2_LINE_FLAG_BIAS_DISABLED = 0x400
     _GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME = 0x800
+    _GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE = 0x1000
 
     SUPPORTED = KERNEL_VERSION >= (5, 10)
 
-    def __init__(self, path, line, direction, edge="none", bias="default", drive="default", inverted=False, label=None):
+    _SUPPORTS_EVENT_CLOCK_HTE = KERNEL_VERSION >= (5, 19)
+
+    def __init__(self, path, line, direction, edge="none", bias="default", drive="default", inverted=False, label=None, event_clock="realtime", debounce_us=0):
         """**Character device GPIO (ABI version 2)**
 
         Instantiate a GPIO object and open the character device GPIO with the
         specified line and direction at the specified GPIO chip path (e.g.
-        "/dev/gpiochip0"). Defaults properties can be overridden with keyword
+        "/dev/gpiochip0"). Default properties can be overridden with keyword
         arguments.
 
         Args:
@@ -146,6 +150,9 @@ class Cdev2GPIO(GPIO):
                          "open_source".
             inverted (bool): GPIO is inverted (active low).
             label (str, None): GPIO line consumer label.
+            event_clock (str): GPIO event clock, can be "realtime",
+                               "monotonic", or "hte".
+            debounce_us (int): GPIO debounce period in microseconds.
 
         Returns:
             Cdev2GPIO: GPIO object.
@@ -153,9 +160,10 @@ class Cdev2GPIO(GPIO):
         Raises:
             GPIOError: if an I/O or OS error occurs.
             TypeError: if `path`, `line`, `direction`, `edge`, `bias`, `drive`,
-                       `inverted`, or `label` types are invalid.
-            ValueError: if `direction`, `edge`, `bias`, or `drive` value is
-                        invalid.
+                       `inverted`, `label`, `event_clock`, or `debounce_us`
+                       types are invalid.
+            ValueError: if `direction`, `edge`, `bias`, `drive`, `event_clock`,
+                        or `debounce_us` value is invalid.
             LookupError: if the GPIO line was not found by the provided name.
 
         """
@@ -165,17 +173,19 @@ class Cdev2GPIO(GPIO):
         self._chip_fd = None
         self._direction = None
         self._edge = None
+        self._event_clock = None
+        self._debounce_us = None
         self._bias = None
         self._drive = None
         self._inverted = None
         self._label = None
 
-        self._open(path, line, direction, edge, bias, drive, inverted, label)
+        self._open(path, line, direction, edge, event_clock, debounce_us, bias, drive, inverted, label)
 
     def __new__(self, path, line, direction, **kwargs):
         return object.__new__(Cdev2GPIO)
 
-    def _open(self, path, line, direction, edge, bias, drive, inverted, label):
+    def _open(self, path, line, direction, edge, event_clock, debounce_us, bias, drive, inverted, label):
         if not isinstance(path, str):
             raise TypeError("Invalid path type, should be string.")
 
@@ -192,6 +202,16 @@ class Cdev2GPIO(GPIO):
         elif edge not in ["none", "rising", "falling", "both"]:
             raise ValueError("Invalid edge, can be: \"none\", \"rising\", \"falling\", \"both\".")
 
+        if not isinstance(event_clock, str):
+            raise TypeError("Invalid event_clock type, should be string.")
+        elif event_clock not in ["realtime", "monotonic", "hte"]:
+            raise ValueError("Invalid event_clock, can be: \"realtime\", \"monotonic\", \"hte\".")
+
+        if not isinstance(debounce_us, int):
+            raise TypeError("Invalid debounce_us type, should be integer.")
+        elif debounce_us < 0:
+            raise ValueError("Invalid debounce_us value, should be zero or positive.")
+
         if not isinstance(bias, str):
             raise TypeError("Invalid bias type, should be string.")
         elif bias not in ["default", "pull_up", "pull_down", "disable"]:
@@ -203,7 +223,7 @@ class Cdev2GPIO(GPIO):
             raise ValueError("Invalid drive, can be: \"default\", \"open_drain\", \"open_source\".")
 
         if not isinstance(inverted, bool):
-            raise TypeError("Invalid drive type, should be bool.")
+            raise TypeError("Invalid inverted type, should be bool.")
 
         if not isinstance(label, (type(None), str)):
             raise TypeError("Invalid label type, should be None or str.")
@@ -221,11 +241,14 @@ class Cdev2GPIO(GPIO):
         self._line = line
         self._label = label.encode() if label is not None else b"periphery"
 
-        self._reopen(direction, edge, bias, drive, inverted)
+        self._reopen(direction, edge, event_clock, debounce_us, bias, drive, inverted)
 
-    def _reopen(self, direction, edge, bias, drive, inverted):
+    def _reopen(self, direction, edge, event_clock, debounce_us, bias, drive, inverted):
         flags = 0
 
+        if event_clock == "hte" and not Cdev2GPIO._SUPPORTS_EVENT_CLOCK_HTE:
+            raise GPIOError(None, "Kernel version does not support GPIO event clock HTE")
+
         if bias == "pull_up":
             flags |= Cdev2GPIO._GPIO_V2_LINE_FLAG_BIAS_PULL_UP
         elif bias == "pull_down":
@@ -258,13 +281,19 @@ class Cdev2GPIO(GPIO):
 
         if direction == "in":
             flags |= Cdev2GPIO._GPIO_V2_LINE_FLAG_EDGE_RISING if edge == "rising" else Cdev2GPIO._GPIO_V2_LINE_FLAG_EDGE_FALLING if edge == "falling" else (Cdev2GPIO._GPIO_V2_LINE_FLAG_EDGE_RISING | Cdev2GPIO._GPIO_V2_LINE_FLAG_EDGE_FALLING) if edge == "both" else 0
-            flags |= Cdev2GPIO._GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME if edge != "none" else 0
+            flags |= (Cdev2GPIO._GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME if event_clock == "realtime" else Cdev2GPIO._GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE if event_clock == "hte" else 0) if edge != "none" else 0
 
             line_request.offsets[0] = self._line
             line_request.consumer = self._label
             line_request.config.flags = flags | Cdev2GPIO._GPIO_V2_LINE_FLAG_INPUT
             line_request.num_lines = 1
 
+            if debounce_us:
+                line_request.config.num_attrs = 1
+                line_request.config.attrs[0].attr.id = Cdev2GPIO._GPIO_V2_LINE_ATTR_ID_DEBOUNCE
+                line_request.config.attrs[0].attr.data.debounce_period_us = debounce_us
+                line_request.config.attrs[0].mask = 0x1
+
             try:
                 fcntl.ioctl(self._chip_fd, Cdev2GPIO._GPIO_V2_GET_LINE_IOCTL, line_request)
             except (OSError, IOError) as e:
@@ -291,6 +320,8 @@ class Cdev2GPIO(GPIO):
 
         self._direction = "in" if direction == "in" else "out"
         self._edge = edge
+        self._event_clock = event_clock
+        self._debounce_us = debounce_us
         self._bias = bias
         self._drive = drive
         self._inverted = inverted
@@ -503,7 +534,7 @@ class Cdev2GPIO(GPIO):
         if self._direction == direction:
             return
 
-        self._reopen(direction, "none", self._bias, self._drive, self._inverted)
+        self._reopen(direction, "none", self._event_clock, self._debounce_us, self._bias, self._drive, self._inverted)
 
     direction = property(_get_direction, _set_direction)
 
@@ -522,10 +553,48 @@ class Cdev2GPIO(GPIO):
         if self._edge == edge:
             return
 
-        self._reopen(self._direction, edge, self._bias, self._drive, self._inverted)
+        self._reopen(self._direction, edge, self._event_clock, self._debounce_us, self._bias, self._drive, self._inverted)
 
     edge = property(_get_edge, _set_edge)
 
+    def _get_event_clock(self):
+        return self._event_clock
+
+    def _set_event_clock(self, event_clock):
+        if not isinstance(event_clock, str):
+            raise TypeError("Invalid event_clock type, should be string.")
+        if event_clock not in ["realtime", "monotonic", "hte"]:
+            raise ValueError("Invalid event_clock, can be: \"realtime\", \"monotonic\", \"hte\".")
+
+        if self._direction != "in":
+            raise GPIOError(None, "Invalid operation: cannot set event clock on output GPIO")
+
+        if self._event_clock == event_clock:
+            return
+
+        self._reopen(self._direction, self._edge, event_clock, self._debounce_us, self._bias, self._drive, self._inverted)
+
+    event_clock = property(_get_event_clock, _set_event_clock)
+
+    def _get_debounce_us(self):
+        return self._debounce_us
+
+    def _set_debounce_us(self, debounce_us):
+        if not isinstance(debounce_us, int):
+            raise TypeError("Invalid debounce_us type, should be integer.")
+        if debounce_us < 0:
+            raise ValueError("Invalid debounce_us value, should be zero or positive.")
+
+        if self._direction != "in":
+            raise GPIOError(None, "Invalid operation: cannot set debounce on output GPIO")
+
+        if self._debounce_us == debounce_us:
+            return
+
+        self._reopen(self._direction, self._edge, self._event_clock, debounce_us, self._bias, self._drive, self._inverted)
+
+    debounce_us = property(_get_debounce_us, _set_debounce_us)
+
     def _get_bias(self):
         return self._bias
 
@@ -538,7 +607,7 @@ class Cdev2GPIO(GPIO):
         if self._bias == bias:
             return
 
-        self._reopen(self._direction, self._edge, bias, self._drive, self._inverted)
+        self._reopen(self._direction, self._edge, self._event_clock, self._debounce_us, bias, self._drive, self._inverted)
 
     bias = property(_get_bias, _set_bias)
 
@@ -557,7 +626,7 @@ class Cdev2GPIO(GPIO):
         if self._drive == drive:
             return
 
-        self._reopen(self._direction, self._edge, self._bias, drive, self._inverted)
+        self._reopen(self._direction, self._edge, self._event_clock, self._debounce_us, self._bias, drive, self._inverted)
 
     drive = property(_get_drive, _set_drive)
 
@@ -566,12 +635,12 @@ class Cdev2GPIO(GPIO):
 
     def _set_inverted(self, inverted):
         if not isinstance(inverted, bool):
-            raise TypeError("Invalid drive type, should be bool.")
+            raise TypeError("Invalid inverted type, should be bool.")
 
         if self._inverted == inverted:
             return
 
-        self._reopen(self._direction, self._edge, self._bias, self._drive, inverted)
+        self._reopen(self._direction, self._edge, self._event_clock, self._debounce_us, self._bias, self._drive, inverted)
 
     inverted = property(_get_inverted, _set_inverted)
 
@@ -588,30 +657,13 @@ class Cdev2GPIO(GPIO):
         except GPIOError:
             str_label = "<error>"
 
-        try:
-            str_direction = self.direction
-        except GPIOError:
-            str_direction = "<error>"
-
-        try:
-            str_edge = self.edge
-        except GPIOError:
-            str_edge = "<error>"
-
-        try:
-            str_bias = self.bias
-        except GPIOError:
-            str_bias = "<error>"
-
-        try:
-            str_drive = self.drive
-        except GPIOError:
-            str_drive = "<error>"
-
-        try:
-            str_inverted = str(self.inverted)
-        except GPIOError:
-            str_inverted = "<error>"
+        str_direction = self._direction
+        str_edge = self._edge
+        str_event_clock = self._event_clock
+        str_debounce_us = str(self._debounce_us)
+        str_bias = self._bias
+        str_drive = self._drive
+        str_inverted = str(self._inverted)
 
         try:
             str_chip_name = self.chip_name
@@ -623,5 +675,5 @@ class Cdev2GPIO(GPIO):
         except GPIOError:
             str_chip_label = "<error>"
 
-        return "GPIO {:d} (name=\"{:s}\", label=\"{:s}\", device={:s}, line_fd={:d}, chip_fd={:d}, direction={:s}, edge={:s}, bias={:s}, drive={:s}, inverted={:s}, chip_name=\"{:s}\", chip_label=\"{:s}\", type=cdev)" \
-            .format(self._line, str_name, str_label, self._devpath, self._line_fd, self._chip_fd, str_direction, str_edge, str_bias, str_drive, str_inverted, str_chip_name, str_chip_label)
+        return "GPIO {:d} (name=\"{:s}\", label=\"{:s}\", device={:s}, line_fd={:d}, chip_fd={:d}, direction={:s}, edge={:s}, event_clock={:s}, debounce_us={:s}, bias={:s}, drive={:s}, inverted={:s}, chip_name=\"{:s}\", chip_label=\"{:s}\", type=cdev)" \
+            .format(self._line, str_name, str_label, self._devpath, self._line_fd, self._chip_fd, str_direction, str_edge, str_event_clock, str_debounce_us, str_bias, str_drive, str_inverted, str_chip_name, str_chip_label)

periphery/gpio_sysfs.py

@@ -83,7 +83,7 @@ class SysfsGPIO(GPIO):
                     with open(os.path.join(gpio_path, "direction"), 'w'):
                         break
                 except IOError as e:
-                    if e.errno != errno.EACCES or (e.errno == errno.EACCES and i == SysfsGPIO._GPIO_STAT_RETRIES - 1):
+                    if e.errno != errno.EACCES or i == SysfsGPIO._GPIO_STAT_RETRIES - 1:
                         raise GPIOError(e.errno, "Opening GPIO direction: " + e.strerror)
 
                 time.sleep(SysfsGPIO._GPIO_STAT_DELAY)
@@ -296,6 +296,22 @@ class SysfsGPIO(GPIO):
 
     edge = property(_get_edge, _set_edge)
 
+    def _get_event_clock(self):
+        raise NotImplementedError("Sysfs GPIO does not support event clock property.")
+
+    def _set_event_clock(self, event_clock):
+        raise NotImplementedError("Sysfs GPIO does not support event clock property.")
+
+    event_clock = property(_get_event_clock, _set_event_clock)
+
+    def _get_debounce_us(self):
+        raise NotImplementedError("Sysfs GPIO does not support debounce property.")
+
+    def _set_debounce_us(self, debounce_us):
+        raise NotImplementedError("Sysfs GPIO does not support debounce property.")
+
+    debounce_us = property(_get_debounce_us, _set_debounce_us)
+
     def _get_bias(self):
         raise NotImplementedError("Sysfs GPIO does not support line bias property.")
 
@@ -329,7 +345,7 @@ class SysfsGPIO(GPIO):
 
     def _set_inverted(self, inverted):
         if not isinstance(inverted, bool):
-            raise TypeError("Invalid drive type, should be bool.")
+            raise TypeError("Invalid inverted type, should be bool.")
 
         # Write active_low
         try:

periphery/i2c.py

@@ -90,40 +90,44 @@ class I2C(object):
 
     # Methods
 
-    def transfer(self, address, messages):
+    def transfer(self, address, messages, inplace=False):
         """Transfer `messages` to the specified I2C `address`. Modifies the
         `messages` array with the results of any read transactions.
 
         Args:
             address (int): I2C address.
-            messages (list): list of I2C.Message messages.
+            messages (list, tuple): list of I2C.Message messages.
+            inplace (bool): read into `messages` in-place. data must be of type
+                `bytearray`.
 
         Raises:
             I2CError: if an I/O or OS error occurs.
-            TypeError: if `messages` type is not list.
-            ValueError: if `messages` length is zero, or if message data is not valid bytes.
+            TypeError: if `messages` or message types are invalid.
+            ValueError: if `messages` length is zero.
 
         """
-        if not isinstance(messages, list):
-            raise TypeError("Invalid messages type, should be list of I2C.Message.")
+        if not isinstance(messages, (list, tuple)):
+            raise TypeError("Invalid messages type, should be list or tuple of I2C.Message.")
         elif len(messages) == 0:
-            raise ValueError("Invalid messages data, should be non-zero length.")
+            raise ValueError("Invalid messages, should contain at least one message.")
+        for message in messages:
+            if not isinstance(message, I2C.Message):
+                raise TypeError("Invalid message type, should be I2C.Message.")
 
         # Convert I2C.Message messages to _CI2CMessage messages
         cmessages = (_CI2CMessage * len(messages))()
+        bufs = []
+
         for i in range(len(messages)):
-            # Convert I2C.Message data to bytes
-            if isinstance(messages[i].data, bytes):
-                data = messages[i].data
-            elif isinstance(messages[i].data, bytearray):
-                data = bytes(messages[i].data)
-            elif isinstance(messages[i].data, list):
-                data = bytes(bytearray(messages[i].data))
+            # Convert data to bytearray (or re-use it if inplace)
+            buf = messages[i].data if inplace and isinstance(messages[i].data, bytearray) else bytearray(messages[i].data)
 
             cmessages[i].addr = address
             cmessages[i].flags = messages[i].flags | (I2C._I2C_M_RD if messages[i].read else 0)
-            cmessages[i].len = len(data)
-            cmessages[i].buf = ctypes.cast(ctypes.create_string_buffer(data, len(data)), ctypes.POINTER(ctypes.c_ubyte))
+            cmessages[i].len = len(buf)
+            cmessages[i].buf = ctypes.cast((ctypes.c_ubyte * len(buf)).from_buffer(buf), ctypes.POINTER(ctypes.c_ubyte))
+
+            bufs.append(buf)
 
         # Prepare transfer structure
         i2c_xfer = _CI2CIocTransfer()
@@ -139,14 +143,13 @@ class I2C(object):
         # Update any read I2C.Message messages
         for i in range(len(messages)):
             if messages[i].read:
-                data = [cmessages[i].buf[j] for j in range(cmessages[i].len)]
                 # Convert read data to type used in I2C.Message messages
                 if isinstance(messages[i].data, list):
-                    messages[i].data = data
+                    messages[i].data = list(bufs[i])
                 elif isinstance(messages[i].data, bytearray):
-                    messages[i].data = bytearray(data)
+                    messages[i].data = bufs[i]
                 elif isinstance(messages[i].data, bytes):
-                    messages[i].data = bytes(bytearray(data))
+                    messages[i].data = bytes(bufs[i])
 
     def close(self):
         """Close the i2c-dev I2C device.

periphery/i2c.pyi

@@ -13,7 +13,7 @@ class I2C:
     def __del__(self) -> None: ...
     def __enter__(self) -> I2C: ...  # noqa: Y034
     def __exit__(self, t: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None) -> None: ...
-    def transfer(self, address: int, messages: list[Message]) -> None: ...
+    def transfer(self, address: int, messages: list[Message], inplace: bool = ...) -> None: ...
     def close(self) -> None: ...
     @property
     def fd(self) -> int: ...

periphery/led.py

@@ -154,6 +154,34 @@ class LED(object):
 
         self._fd = None
 
+    def _read_trigger(self):
+        """Read and parse the LED "trigger" file.
+
+        Returns:
+            (list, str or None): a list of the available triggers, and the
+            active trigger or None if no active trigger was found.
+
+        Raises:
+            LEDError: if an I/O or OS error occurs.
+
+        """
+        try:
+            with open(os.path.join(self._path, "trigger"), "r") as f_trigger:
+                content = f_trigger.read()
+        except IOError as e:
+            raise LEDError(e.errno, "Reading LED trigger: " + e.strerror)
+
+        triggers = []
+        active_trigger = None
+        for token in content.split():
+            if token.startswith("[") and token.endswith("]"):
+                active_trigger = token[1:-1]
+                triggers.append(active_trigger)
+            else:
+                triggers.append(token)
+
+        return triggers, active_trigger
+
     # Immutable properties
 
     @property
@@ -189,6 +217,21 @@ class LED(object):
         """
         return self._max_brightness
 
+    @property
+    def triggers(self):
+        """Get the LED's available triggers.
+
+        Returns:
+            list: list of available triggers.
+
+        Raises:
+            LEDError: if an I/O or OS error occurs.
+
+        :type: list
+        """
+        triggers, _ = self._read_trigger()
+        return triggers
+
     # Mutable properties
 
     def _get_brightness(self):
@@ -212,7 +255,41 @@ class LED(object):
     :type: int
     """
 
+    def _get_trigger(self):
+        _, active_trigger = self._read_trigger()
+
+        if active_trigger is None:
+            raise LEDError(None, "Active LED trigger not found.")
+
+        return active_trigger
+
+    def _set_trigger(self, trigger):
+        if not isinstance(trigger, str):
+            raise TypeError("Invalid trigger type, should be string.")
+
+        try:
+            with open(os.path.join(self._path, "trigger"), "w") as f_trigger:
+                f_trigger.write(trigger + "\n")
+        except IOError as e:
+            raise LEDError(e.errno, "Setting LED trigger: " + e.strerror)
+
+    trigger = property(_get_trigger, _set_trigger)
+    """Get or set the LED's active trigger.
+
+    Raises:
+        LEDError: if an I/O or OS error occurs, or if no active trigger is
+        found.
+        TypeError: if `trigger` type is not str.
+
+    :type: str
+    """
+
     # String representation
 
     def __str__(self):
-        return "LED {:s} (device={:s}, fd={:d}, max_brightness={:d})".format(self._name, self._path, self._fd, self._max_brightness)
+        try:
+            str_trigger = self.trigger
+        except LEDError:
+            str_trigger = "<error>"
+
+        return "LED {:s} (device={:s}, fd={:d}, max_brightness={:d}, trigger={:s})".format(self._name, self._path, self._fd, self._max_brightness, str_trigger)

periphery/led.pyi

@@ -18,4 +18,7 @@ class LED:
     def name(self) -> str: ...
     @property
     def max_brightness(self) -> int: ...
+    @property
+    def triggers(self) -> list[str]: ...
+    trigger: str
     brightness: int

periphery/mmio.py

@@ -84,6 +84,28 @@ class MMIO(object):
         if (offset + length) > self._aligned_size:
             raise ValueError("Offset out of bounds.")
 
+    def read64(self, offset):
+        """Read 64-bits from the specified `offset` in bytes, relative to the
+        base physical address of the MMIO region.
+
+        Args:
+            offset (int, long): offset from base physical address, in bytes.
+
+        Returns:
+            int: 64-bit value read.
+
+        Raises:
+            TypeError: if `offset` type is invalid.
+            ValueError: if `offset` is out of bounds.
+
+        """
+        if not isinstance(offset, (int, long)):
+            raise TypeError("Invalid offset type, should be integer.")
+
+        offset = self._adjust_offset(offset)
+        self._validate_offset(offset, 8)
+        return ctypes.c_uint64.from_buffer(self.mapping, offset).value
+
     def read32(self, offset):
         """Read 32-bits from the specified `offset` in bytes, relative to the
         base physical address of the MMIO region.
@@ -173,6 +195,30 @@ class MMIO(object):
         self._validate_offset(offset, length)
         return bytes(self.mapping[offset:offset + length])
 
+    def write64(self, offset, value):
+        """Write 64-bits to the specified `offset` in bytes, relative to the
+        base physical address of the MMIO region.
+
+        Args:
+            offset (int, long): offset from base physical address, in bytes.
+            value (int, long): 64-bit value to write.
+
+        Raises:
+            TypeError: if `offset` or `value` type are invalid.
+            ValueError: if `offset` or `value` are out of bounds.
+
+        """
+        if not isinstance(offset, (int, long)):
+            raise TypeError("Invalid offset type, should be integer.")
+        if not isinstance(value, (int, long)):
+            raise TypeError("Invalid value type, should be integer.")
+        if value < 0 or value > 0xffffffffffffffff:
+            raise ValueError("Value out of bounds.")
+
+        offset = self._adjust_offset(offset)
+        self._validate_offset(offset, 8)
+        ctypes.c_uint64.from_buffer(self.mapping, offset).value = value
+
     def write32(self, offset, value):
         """Write 32-bits to the specified `offset` in bytes, relative to the
         base physical address of the MMIO region.
@@ -278,8 +324,6 @@ class MMIO(object):
         self.mapping.close()
         self.mapping = None
 
-        self._fd = None
-
     # Immutable properties
 
     @property

periphery/mmio.pyi

@@ -8,10 +8,12 @@ class MMIO:
     def __del__(self) -> None: ...
     def __enter__(self) -> MMIO: ...  # noqa: Y034
     def __exit__(self, t: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None) -> None: ...
+    def read64(self, offset: int) -> int: ...
     def read32(self, offset: int) -> int: ...
     def read16(self, offset: int) -> int: ...
     def read8(self, offset: int) -> int: ...
     def read(self, offset: int, length: int) -> bytes: ...
+    def write64(self, offset: int, value: int) -> None: ...
     def write32(self, offset: int, value: int) -> None: ...
     def write16(self, offset: int, value: int) -> None: ...
     def write8(self, offset: int, value: int) -> None: ...

periphery/pwm.py

@@ -11,7 +11,7 @@ class PWMError(IOError):
 class PWM(object):
     # Number of retries to check for successful PWM export on open
     _PWM_STAT_RETRIES = 10
-    # Delay between check for scucessful PWM export on open (100ms)
+    # Delay between check for successful PWM export on open (100ms)
     _PWM_STAT_DELAY = 0.1
 
     def __init__(self, chip, channel):
@@ -86,7 +86,7 @@ class PWM(object):
                     with open(os.path.join(channel_path, "period"), 'w'):
                         break
                 except IOError as e:
-                    if e.errno != errno.EACCES or (e.errno == errno.EACCES and i == PWM._PWM_STAT_RETRIES - 1):
+                    if e.errno != errno.EACCES or i == PWM._PWM_STAT_RETRIES - 1:
                         raise PWMError(e.errno, "Opening PWM period: " + e.strerror)
 
                 time.sleep(PWM._PWM_STAT_DELAY)

periphery/serial.py

@@ -168,8 +168,6 @@ class Serial(object):
         except termios.error as e:
             raise SerialError(e.errno, "Setting serial port attributes: " + e.strerror)
 
-        self._use_termios_timeout = False
-
     # Methods
 
     def read(self, length, timeout=None):
@@ -268,7 +266,7 @@ class Serial(object):
         """
         p = select.poll()
         p.register(self._fd, select.POLLIN | select.POLLPRI)
-        events = p.poll(int(timeout * 1000))
+        events = p.poll(int(timeout * 1000) if timeout is not None else None)
 
         if len(events) > 0:
             return True
@@ -317,7 +315,7 @@ class Serial(object):
             SerialError: if an I/O or OS error occurs.
 
         """
-        # Get input waiting
+        # Get output waiting
         buf = array.array('I', [0])
         try:
             fcntl.ioctl(self._fd, termios.TIOCOUTQ, buf, True)

periphery/spi.py

@@ -27,7 +27,8 @@ class _CSpiIocTransfer(ctypes.Structure):
         ('cs_change', ctypes.c_ubyte),
         ('tx_nbits', ctypes.c_ubyte),
         ('rx_nbits', ctypes.c_ubyte),
-        ('pad', ctypes.c_ushort),
+        ('word_delay_usecs', ctypes.c_ubyte),
+        ('pad', ctypes.c_ubyte),
     ]
 
 
@@ -45,8 +46,10 @@ class SPI(object):
     _SPI_IOC_WR_BITS_PER_WORD = 0x40016b03
     _SPI_IOC_RD_BITS_PER_WORD = 0x80016b03
     _SPI_IOC_MESSAGE_1 = 0x40206b00
+    _SPI_IOC_MAGIC = 0x6b
 
     _SUPPORTS_MODE32 = KERNEL_VERSION >= (3, 15)
+    _SUPPORTS_WORD_DELAY = KERNEL_VERSION >= (5, 2)
 
     def __init__(self, devpath, mode, max_speed, bit_order="msb", bits_per_word=8, extra_flags=0):
         """Instantiate a SPI object and open the spidev device at the specified
@@ -149,11 +152,14 @@ class SPI(object):
 
     # Methods
 
-    def transfer(self, data):
+    def transfer(self, data, inplace=False):
         """Shift out `data` and return shifted in data.
 
         Args:
-            data (bytes, bytearray, list): a byte array or list of 8-bit integers to shift out.
+            data (bytes, bytearray, list): a byte array or list of 8-bit
+                integers to shift out.
+            inplace (bool): read into `data` in-place. data must be of type
+                `bytearray`.
 
         Returns:
             bytes, bytearray, list: data shifted in.
@@ -161,25 +167,19 @@ class SPI(object):
         Raises:
             SPIError: if an I/O or OS error occurs.
             TypeError: if `data` type is invalid.
-            ValueError: if data is not valid bytes.
 
         """
         if not isinstance(data, (bytes, bytearray, list)):
             raise TypeError("Invalid data type, should be bytes, bytearray, or list.")
 
-        # Create mutable array
-        try:
-            buf = array.array('B', data)
-        except OverflowError:
-            raise ValueError("Invalid data bytes.")
-
-        buf_addr, buf_len = buf.buffer_info()
+        # Convert data to bytearray (or re-use it if inplace)
+        buf = data if inplace and isinstance(data, bytearray) else bytearray(data)
 
         # Prepare transfer structure
         spi_xfer = _CSpiIocTransfer()
-        spi_xfer.tx_buf = buf_addr
-        spi_xfer.rx_buf = buf_addr
-        spi_xfer.len = buf_len
+        spi_xfer.tx_buf = ctypes.addressof((ctypes.c_ubyte * len(data)).from_buffer(buf))
+        spi_xfer.rx_buf = spi_xfer.tx_buf
+        spi_xfer.len = len(data)
 
         # Transfer
         try:
@@ -189,11 +189,90 @@ class SPI(object):
 
         # Return shifted out data with the same type as shifted in data
         if isinstance(data, bytes):
-            return bytes(bytearray(buf))
+            return bytes(buf)
         elif isinstance(data, bytearray):
-            return bytearray(buf)
+            return buf
         elif isinstance(data, list):
-            return buf.tolist()
+            return list(buf)
+
+    def transfer_advanced(self, messages, inplace=False):
+        """Transfer multiple messages, shifting out `data` of each message,
+        while shifting the same length in, modifying the `messages` list with
+        the shifted in data of each message. If `deselect` is true, deselect
+        the device before reselecting it for the following transfer.
+
+        `deselect_delay_us` specifies a delay in microseconds before
+        deselection when `deselect` is true. `word_delay_us` specifies a delay
+        in microseconds between words within a message. Note that
+        `deselect_delay_us` and `word_delay_us` may not be supported by all SPI
+        controllers and may be silently ignored.
+
+        Args:
+            messages (list, tuple): list of SPI.Message messages to transfer.
+            inplace (bool): read into `messages` in-place. data must be of type
+                `bytearray`.
+
+        Raises:
+            SPIError: if an I/O or OS error occurs.
+            TypeError: if `messages` or message types are invalid.
+            ValueError: if `messages` length is zero.
+
+        """
+        if not isinstance(messages, (list, tuple)):
+            raise TypeError("Invalid messages type, should be list or tuple of SPI.Message.")
+        elif len(messages) == 0:
+            raise ValueError("Invalid messages, should contain at least one message.")
+        for message in messages:
+            if not isinstance(message, SPI.Message):
+                raise TypeError("Invalid message type, should be SPI.Message.")
+
+        # Prepare transfer structures
+        spi_xfer = (_CSpiIocTransfer * len(messages))()
+        bufs = []
+
+        for i, message in enumerate(messages):
+            # Validate message
+            if not isinstance(message.data, (bytes, bytearray, list)):
+                raise TypeError("Invalid data type in message {:d}, should be bytes, bytearray, or list.".format(i))
+            if not isinstance(message.deselect, bool):
+                raise TypeError("Invalid deselect type in message {:d}, should be bool.".format(i))
+            if not isinstance(message.deselect_delay_us, int):
+                raise TypeError("Invalid deselect_delay_us type in message {:d}, should be integer.".format(i))
+            if not isinstance(message.word_delay_us, int):
+                raise TypeError("Invalid word_delay_us type in message {:d}, should be integer.".format(i))
+
+            # Convert data to bytearray (or re-use it if inplace)
+            buf = message.data if inplace and isinstance(message.data, bytearray) else bytearray(message.data)
+
+            spi_xfer[i].tx_buf = ctypes.addressof((ctypes.c_ubyte * len(buf)).from_buffer(buf))
+            spi_xfer[i].rx_buf = spi_xfer[i].tx_buf
+            spi_xfer[i].len = len(buf)
+            spi_xfer[i].delay_usecs = message.deselect_delay_us
+            spi_xfer[i].cs_change = int(message.deselect)
+            if SPI._SUPPORTS_WORD_DELAY:
+                spi_xfer[i].word_delay_usecs = message.word_delay_us
+
+            bufs.append(buf)
+
+        # Prepare the SPI_IOC_MESSAGE ioctl number for message count:
+        #   _IOW(SPI_IOC_MAGIC, 0, struct spi_ioc_transfer[count])
+        spi_ioc_message = (1 << 30) | ((ctypes.sizeof(_CSpiIocTransfer) * len(messages)) << 16) | (SPI._SPI_IOC_MAGIC << 8) | 0x0
+
+        # Transfer
+        try:
+            fcntl.ioctl(self._fd, spi_ioc_message, spi_xfer)
+        except (OSError, IOError) as e:
+            raise SPIError(e.errno, "SPI transfer: " + e.strerror)
+
+        # Update SPI.Message data with the shifted in data
+        for i in range(len(messages)):
+            # Convert shifted in data to type used in SPI.Message messages
+            if isinstance(messages[i].data, list):
+                messages[i].data = list(bufs[i])
+            elif isinstance(messages[i].data, bytearray):
+                messages[i].data = bufs[i]
+            elif isinstance(messages[i].data, bytes):
+                messages[i].data = bytes(bufs[i])
 
     def close(self):
         """Close the spidev SPI device.
@@ -453,3 +532,26 @@ class SPI(object):
     def __str__(self):
         return "SPI (device={:s}, fd={:d}, mode={:d}, max_speed={:d}, bit_order={:s}, bits_per_word={:d}, extra_flags=0x{:08x})" \
             .format(self.devpath, self.fd, self.mode, self.max_speed, self.bit_order, self.bits_per_word, self.extra_flags)
+
+    class Message:
+        def __init__(self, data, deselect=False, deselect_delay_us=0, word_delay_us=0):
+            """Instantiate an SPI Message object.
+
+            Args:
+                data (bytes, bytearray, list): a byte array or list of 8-bit
+                    integers to shift out.
+                deselect (bool): deselect the device before reselecting it for
+                    the following transfer.
+                deselect_delay_us (int): delay in microseconds before
+                    deselection when `deselect` is true.
+                word_delay_us (int): delay in microseconds between words within
+                    the transfer.
+
+            Returns:
+                Message: Message object.
+
+            """
+            self.data = data
+            self.deselect = deselect
+            self.deselect_delay_us = deselect_delay_us
+            self.word_delay_us = word_delay_us

periphery/spi.pyi

@@ -5,13 +5,21 @@ KERNEL_VERSION: tuple[int, int]
 class SPIError(IOError): ...
 
 class SPI:
+    class Message:
+        data: bytes | bytearray | list[int]
+        deselect: bool
+        deselect_delay_us: int
+        word_delay_us: int
+        def __init__(self, data: bytes | bytearray | list[int], deselect: bool = ..., deselect_delay_us: int = ..., word_delay_us: int = ...) -> None: ...
+
     def __init__(
         self, devpath: str, mode: int, max_speed: float, bit_order: str = ..., bits_per_word: int = ..., extra_flags: int = ...
     ) -> None: ...
     def __del__(self) -> None: ...
     def __enter__(self) -> SPI: ...  # noqa: Y034
     def __exit__(self, t: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None) -> None: ...
-    def transfer(self, data: bytes | bytearray | list[int]) -> bytes | bytearray | list[int]: ...
+    def transfer(self, data: bytes | bytearray | list[int], inplace: bool = ...) -> bytes | bytearray | list[int]: ...
+    def transfer_advanced(self, messages: list[Message], inplace: bool = ...) -> None: ...
     def close(self) -> None: ...
     @property
     def fd(self) -> int: ...

{python_periphery-2.4.3.dist-info → python_periphery-2.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-periphery
-Version: 2.4.3
+Version: 2.5.0
 Summary: A pure Python 2/3 library for peripheral I/O (GPIO, LED, PWM, SPI, I2C, MMIO, Serial) in Linux.
 Home-page: https://github.com/vsergeev/python-periphery
 Author: vsergeev

python_periphery-2.5.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+periphery/__init__.py,sha256=BxvDYdmw2XYtIWBnFOTBgoSWVEp8s1HdjD45a3SdoVk,1030
+periphery/__init__.pyi,sha256=i2GDAnpXrUiDJTHGRop9VQqbSbyPc5bxwTXgEa0_T04,715
+periphery/gpio.py,sha256=Gr63tO6AkBxFnozqbm_VueL-vp5LxTtAmLzzFUHEUO8,10903
+periphery/gpio.pyi,sha256=McFZrDm1CVjw34uiK6LNGb94nSTpU5wBaDI84E1Q3lg,2018
+periphery/gpio_cdev1.py,sha256=m14lAszb3VWTaxtJnypPTvDfmtyINGUH1JFlwIKvLOY,21348
+periphery/gpio_cdev2.py,sha256=TnCprCQOr5ZxLl9HY7ati6_zt1OT-NsSbZXNoaLHGbU,24511
+periphery/gpio_sysfs.py,sha256=ur-NclCxF7-uycbrPh1sE8Ny7GJMtkMzhvZam98kwns,12504
+periphery/i2c.py,sha256=bBM0752cBr6Qwkk5edl7dGPTKCD7rNXKYzgYzXQTlcs,6858
+periphery/i2c.pyi,sha256=StHTVYD1G6l37OEoKi-weKVuEykbtF9HjswsakxFanQ,773
+periphery/led.py,sha256=5l5XwG2weKKQpkapmfhA7PEJJiBltQsbXSU6cK2KeL0,8234
+periphery/led.pyi,sha256=EYVIRvuWXiZvThuGl_w3fKIPb4c1bXiViph8fwnsOO8,776
+periphery/mmio.py,sha256=0rup6NJADc9XGhxFXH1sK5DNdhmta5ho945-ckTRW20,12134
+periphery/mmio.pyi,sha256=8jI5e5z43XnZRtlpwUxPywmMTdt-BF4mtrurZ3iJwEg,1138
+periphery/pwm.py,sha256=8opSA9ZJmrW_5rrRiIynAlJbIYTXNd7vSskZPVAv_kQ,10190
+periphery/pwm.pyi,sha256=bHNZzrtRGRv7KSVL_-4zR8bjBt1JXYFlf1mhc0vu5TE,749
+periphery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+periphery/serial.py,sha256=qmcQo5gKk2SC7jcDtjNGRfa7WFUQJEPi4jn2zZUF46M,25266
+periphery/serial.pyi,sha256=LCU7XhhD-yyCGG5cWM7C-K0r-FOaUydGo4GB1v9KD_Y,1114
+periphery/spi.py,sha256=iMrl70HX1P5IqNYgxNs_RnKJ3Z7URdnsYc2iAYRvRus,20647
+periphery/spi.pyi,sha256=902eU5rHGilmub6D1NtGHWLofZHRQHFEL4ll9utuftk,1218
+python_periphery-2.5.0.dist-info/licenses/LICENSE,sha256=uv-e__4tQsDlgnHRd8NFan5DbsfFxHoC2pG7x23oOHc,1099
+python_periphery-2.5.0.dist-info/METADATA,sha256=vpRvyehCsjPMkPZgyDKyr_glLto9fJLSzkc5aqq6uk4,1629
+python_periphery-2.5.0.dist-info/WHEEL,sha256=Uvlg2aNlEKdilsyFSJt1QX5me0eEbCjQzR3nZeFkvy4,109
+python_periphery-2.5.0.dist-info/top_level.txt,sha256=b4Woy5NSzNa7ZPLaz2cmCExhZP2-5zOgtUZog8ASZy0,10
+python_periphery-2.5.0.dist-info/RECORD,,

{python_periphery-2.4.3.dist-info → python_periphery-2.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

python_periphery-2.4.3.dist-info/RECORD

@@ -1,25 +0,0 @@
-periphery/__init__.py,sha256=bFlQwbt4Eo3p9VjzuaRpVIhbPyIKhX50EOXmNi_Maak,1030
-periphery/__init__.pyi,sha256=kNV-srVZuc_gxTFhINQaQhFYhwfxePFOoW4zwZysiyA,698
-periphery/gpio.py,sha256=JhDIEcC2BEmpSKXlnAxNkeM3pvzaVClE42yAER_lEuw,9960
-periphery/gpio.pyi,sha256=3xHOcsmXxdcc-sXy3KNb0beuCp-KCW759Duq1jr88J4,1935
-periphery/gpio_cdev1.py,sha256=QdGcPRLQlboz64M1_TL-cjcrQcqdcIMRT1HnHC0Ksxk,20665
-periphery/gpio_cdev2.py,sha256=84nMmPrtJ0StJcAwE8iw45YadV45CpHBrmLBruomzGw,21199
-periphery/gpio_sysfs.py,sha256=da-8uMziBAA_wQOaEWO8DXysilOndOMVrRLmtQUc8zs,11903
-periphery/i2c.py,sha256=tMS7XQ10DAblbqinSHHjYB6xNUPns71_JZvfm1cLZPc,6769
-periphery/i2c.pyi,sha256=dfWclTARt3iCvIwMoV1IwiUS5WyssSrPm_nE-gLyUHg,752
-periphery/led.py,sha256=waQ3nrlzyvTBKqZQpPva4AuyITGoUirJ5ROVUeklxAE,5997
-periphery/led.pyi,sha256=f_lUJNlamKkbbH2Ivj-ZUGylXC4bVVINp2NcQXzYTSY,704
-periphery/mmio.py,sha256=fsdycYJ2GqLTRN_AIWV-GpTCYsU0jBoe_T9MZfiIw8E,10469
-periphery/mmio.pyi,sha256=_Ysa_DI6d6PRoepMD_CY4zb2wHmDo6smGEtnHP4fk4E,1032
-periphery/pwm.py,sha256=5Z-eIHnE3SXozUOWD5bB3R1LVHuLaFWqOw28Qbm4BFg,10220
-periphery/pwm.pyi,sha256=bHNZzrtRGRv7KSVL_-4zR8bjBt1JXYFlf1mhc0vu5TE,749
-periphery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-periphery/serial.py,sha256=L-tNg7aOTL_-c4tJ2qOXtp1I8LMRgYFmQWLnMmW2VCo,25275
-periphery/serial.pyi,sha256=LCU7XhhD-yyCGG5cWM7C-K0r-FOaUydGo4GB1v9KD_Y,1114
-periphery/spi.py,sha256=LTEpKBvvrhIdfcav-Zr08JKt_75BMYLaPoOYBCPzvtg,15568
-periphery/spi.pyi,sha256=xpDxe72ffXmjT905fMwJDHTMZgTSxOY4Wtpk-JJiBrU,806
-python_periphery-2.4.3.dist-info/licenses/LICENSE,sha256=uv-e__4tQsDlgnHRd8NFan5DbsfFxHoC2pG7x23oOHc,1099
-python_periphery-2.4.3.dist-info/METADATA,sha256=B7WyU7pOHadweyN-LfD02Uq74NCfAU29W-VWQJa9wgU,1629
-python_periphery-2.4.3.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
-python_periphery-2.4.3.dist-info/top_level.txt,sha256=b4Woy5NSzNa7ZPLaz2cmCExhZP2-5zOgtUZog8ASZy0,10
-python_periphery-2.4.3.dist-info/RECORD,,