Initial commit

ros2_ws_arm/arm/arm/test_servo.py

@@ -0,0 +1,62 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import Int32MultiArray
+import sys
+import time
+
+from smbus2 import SMBus
+from adafruit_pca9685 import PCA9685
+from adafruit_motor import servo
+
+print("Python:", sys.executable)
+
+class TestServo(Node):
+    def __init__(self):
+        super().__init__('test_servo')
+        self.subscription = self.create_subscription(
+            Int32MultiArray,
+            'servo_angle',
+            self.listener_callback,
+            10)
+        self.get_logger().info("test_servo node started")
+
+        # Set up I2C bus and PCA9685
+        self.bus = SMBus(1)  # I2C-1 is the default on Raspberry Pi
+        self.pca = PCA9685(i2c=self.bus)
+        self.pca.frequency = 50
+
+        # Create 16 servo channels
+        self.servos = [servo.Servo(self.pca.channels[i]) for i in range(16)]
+
+    def listener_callback(self, msg):
+        try:
+            channel = msg.data[0]
+            angle = msg.data[1]
+            if 0 <= channel < 16 and 0 <= angle <= 180:
+                self.servos[channel].angle = angle
+                self.get_logger().info(f"Moved servo {channel} to {angle}°")
+            else:
+                self.get_logger().warn("Invalid channel or angle")
+        except Exception as e:
+            self.get_logger().error(f"Error: {e}")
+
+    def destroy_node(self):
+        self.pca.deinit()
+        self.bus.close()
+        super().destroy_node()
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = TestServo()
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

ros2_ws_arm/arm/env/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

ros2_ws_arm/arm/env/bin/activate

@@ -0,0 +1,70 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
+    # transform D:\path\to\venv to /d/path/to/venv on MSYS
+    # and to /cygdrive/d/path/to/venv on Cygwin
+    export VIRTUAL_ENV=$(cygpath /home/arm/Desktop/ros2_ws_arm/arm/env)
+else
+    # use the path as-is
+    export VIRTUAL_ENV=/home/arm/Desktop/ros2_ws_arm/arm/env
+fi
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1='(env) '"${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT='(env) '
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

ros2_ws_arm/arm/env/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /home/arm/Desktop/ros2_ws_arm/arm/env
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = '(env) '"$prompt"
+    setenv VIRTUAL_ENV_PROMPT '(env) '
+endif
+
+alias pydoc python -m pydoc
+
+rehash

ros2_ws_arm/arm/env/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /home/arm/Desktop/ros2_ws_arm/arm/env
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) '(env) ' (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT '(env) '
+end

ros2_ws_arm/arm/env/bin/ftconf.py

@@ -0,0 +1,194 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+
+"""Simple FTDI EEPROM configurator.
+"""
+
+# Copyright (c) 2019-2024, Emmanuel Blot <emmanuel.blot@free.fr>
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+from argparse import ArgumentParser, FileType
+from io import StringIO
+from logging import Formatter, StreamHandler, DEBUG, ERROR
+from sys import exit as sys_exit, modules, stderr, stdout
+from textwrap import fill
+from traceback import format_exc
+from pyftdi import FtdiLogger
+from pyftdi.eeprom import FtdiEeprom
+from pyftdi.ftdi import Ftdi
+from pyftdi.misc import add_custom_devices, hexdump
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-branches
+# pylint: disable=too-many-statements
+
+
+def main():
+    """Main routine"""
+    debug = False
+    try:
+        argparser = ArgumentParser(description=modules[__name__].__doc__)
+        argparser.add_argument('device', nargs='?', default='ftdi:///?',
+                               help='serial port device name')
+
+        files = argparser.add_argument_group(title='Files')
+        files.add_argument('-i', '--input', type=FileType('rt'),
+                           help='input ini file to load EEPROM content')
+        files.add_argument('-l', '--load', default='all',
+                           choices=('all', 'raw', 'values'),
+                           help='section(s) to load from input file')
+        files.add_argument('-o', '--output',
+                           help='output ini file to save EEPROM content')
+        files.add_argument('-V', '--virtual', type=FileType('r'),
+                           help='use a virtual device, specified as YaML')
+
+        device = argparser.add_argument_group(title='Device')
+        device.add_argument('-P', '--vidpid', action='append',
+                            help='specify a custom VID:PID device ID '
+                                 '(search for FTDI devices)')
+        device.add_argument('-M', '--eeprom',
+                            help='force an EEPROM model')
+        device.add_argument('-S', '--size', type=int,
+                            choices=FtdiEeprom.eeprom_sizes,
+                            help='force an EEPROM size')
+
+        fmt = argparser.add_argument_group(title='Format')
+        fmt.add_argument('-x', '--hexdump', action='store_true',
+                         help='dump EEPROM content as ASCII')
+        fmt.add_argument('-X', '--hexblock', type=int,
+                         help='dump EEPROM as indented hexa blocks')
+
+        config = argparser.add_argument_group(title='Configuration')
+        config.add_argument('-s', '--serial-number',
+                            help='set serial number')
+        config.add_argument('-m', '--manufacturer',
+                            help='set manufacturer name')
+        config.add_argument('-p', '--product',
+                            help='set product name')
+        config.add_argument('-c', '--config', action='append',
+                            help='change/configure a property as key=value '
+                                 'pair')
+        config.add_argument('--vid', type=lambda x: int(x, 16),
+                            help='shortcut to configure the USB vendor ID')
+        config.add_argument('--pid', type=lambda x: int(x, 16),
+                            help='shortcut to configure the USB product ID')
+
+        action = argparser.add_argument_group(title='Action')
+        action.add_argument('-e', '--erase', action='store_true',
+                            help='erase the whole EEPROM content')
+        action.add_argument('-E', '--full-erase', action='store_true',
+                            default=False,
+                            help='erase the whole EEPROM content, including '
+                                 'the CRC')
+        action.add_argument('-u', '--update', action='store_true',
+                            help='perform actual update, use w/ care')
+
+        extra = argparser.add_argument_group(title='Extras')
+        extra.add_argument('-v', '--verbose', action='count', default=0,
+                           help='increase verbosity')
+        extra.add_argument('-d', '--debug', action='store_true',
+                           help='enable debug mode')
+        args = argparser.parse_args()
+        debug = args.debug
+
+        if not args.device:
+            argparser.error('Serial device not specified')
+
+        loglevel = max(DEBUG, ERROR - (10 * args.verbose))
+        loglevel = min(ERROR, loglevel)
+        if debug:
+            formatter = Formatter('%(asctime)s.%(msecs)03d %(name)-20s '
+                                  '%(message)s', '%H:%M:%S')
+        else:
+            formatter = Formatter('%(message)s')
+        FtdiLogger.set_formatter(formatter)
+        FtdiLogger.set_level(loglevel)
+        FtdiLogger.log.addHandler(StreamHandler(stderr))
+
+        if args.virtual:
+            # pylint: disable=import-outside-toplevel
+            from pyftdi.usbtools import UsbTools
+            # Force PyUSB to use PyFtdi test framework for USB backends
+            UsbTools.BACKENDS = ('pyftdi.tests.backend.usbvirt', )
+            # Ensure the virtual backend can be found and is loaded
+            backend = UsbTools.find_backend()
+            loader = backend.create_loader()()
+            loader.load(args.virtual)
+
+        try:
+            add_custom_devices(Ftdi, args.vidpid, force_hex=True)
+        except ValueError as exc:
+            argparser.error(str(exc))
+
+        eeprom = FtdiEeprom()
+        eeprom.open(args.device, size=args.size, model=args.eeprom)
+        if args.erase or args.full_erase:
+            eeprom.erase()
+        if args.input:
+            eeprom.load_config(args.input, args.load)
+        if args.serial_number:
+            eeprom.set_serial_number(args.serial_number)
+        if args.manufacturer:
+            eeprom.set_manufacturer_name(args.manufacturer)
+        if args.product:
+            eeprom.set_product_name(args.product)
+        for conf in args.config or []:
+            if conf in ('?', 'help'):
+                helpstr = ', '.join(sorted(eeprom.properties))
+                print(fill(helpstr, initial_indent='  ',
+                           subsequent_indent='  '))
+                sys_exit(1)
+            for sep in ':=':
+                if sep in conf:
+                    name, value = conf.split(sep, 1)
+                    if not value:
+                        argparser.error(f'Configuration {conf} without value')
+                    if value == 'help':
+                        value = '?'
+                    helpio = StringIO()
+                    eeprom.set_property(name, value, helpio)
+                    helpstr = helpio.getvalue()
+                    if helpstr:
+                        print(fill(helpstr, initial_indent='  ',
+                                   subsequent_indent='  '))
+                        sys_exit(1)
+                    break
+            else:
+                argparser.error(f'Missing name:value separator in {conf}')
+        if args.vid:
+            eeprom.set_property('vendor_id', args.vid)
+        if args.pid:
+            eeprom.set_property('product_id', args.pid)
+        if args.hexdump:
+            print(hexdump(eeprom.data))
+        if args.hexblock is not None:
+            indent = ' ' * args.hexblock
+            for pos in range(0, len(eeprom.data), 16):
+                hexa = ' '.join([f'{x:02x}' for x in eeprom.data[pos:pos+16]])
+                print(indent, hexa, sep='')
+        if args.update:
+            if eeprom.commit(False, no_crc=args.full_erase):
+                eeprom.reset_device()
+        if args.verbose > 0:
+            eeprom.dump_config()
+        if args.output:
+            if args.output == '-':
+                eeprom.save_config(stdout)
+            else:
+                with open(args.output, 'wt') as ofp:
+                    eeprom.save_config(ofp)
+
+    except (ImportError, IOError, NotImplementedError, ValueError) as exc:
+        print(f'\nError: {exc}', file=stderr)
+        if debug:
+            print(format_exc(chain=False), file=stderr)
+        sys_exit(1)
+    except KeyboardInterrupt:
+        sys_exit(2)
+    finally:
+        eeprom.close()
+
+
+if __name__ == '__main__':
+    main()

ros2_ws_arm/arm/env/bin/ftdi_urls.py

@@ -0,0 +1,74 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+
+# Copyright (c) 2019-2024, Emmanuel Blot <emmanuel.blot@free.fr>
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""List valid FTDI device URLs and descriptors."""
+
+from argparse import ArgumentParser, FileType
+from logging import Formatter, StreamHandler, DEBUG, ERROR
+from sys import exit as sys_exit, modules, stderr
+from traceback import format_exc
+from pyftdi import FtdiLogger
+from pyftdi.ftdi import Ftdi
+from pyftdi.misc import add_custom_devices
+
+
+def main():
+    """Entry point."""
+    debug = False
+    try:
+        argparser = ArgumentParser(description=modules[__name__].__doc__)
+        argparser.add_argument('-P', '--vidpid', action='append',
+                               help='specify a custom VID:PID device ID, '
+                                    'may be repeated')
+        argparser.add_argument('-V', '--virtual', type=FileType('r'),
+                               help='use a virtual device, specified as YaML')
+        argparser.add_argument('-v', '--verbose', action='count', default=0,
+                               help='increase verbosity')
+        argparser.add_argument('-d', '--debug', action='store_true',
+                               help='enable debug mode')
+        args = argparser.parse_args()
+        debug = args.debug
+
+        loglevel = max(DEBUG, ERROR - (10 * args.verbose))
+        loglevel = min(ERROR, loglevel)
+        if debug:
+            formatter = Formatter('%(asctime)s.%(msecs)03d %(name)-20s '
+                                  '%(message)s', '%H:%M:%S')
+        else:
+            formatter = Formatter('%(message)s')
+        FtdiLogger.set_formatter(formatter)
+        FtdiLogger.set_level(loglevel)
+        FtdiLogger.log.addHandler(StreamHandler(stderr))
+
+        if args.virtual:
+            # pylint: disable=import-outside-toplevel
+            from pyftdi.usbtools import UsbTools
+            # Force PyUSB to use PyFtdi test framework for USB backends
+            UsbTools.BACKENDS = ('pyftdi.tests.backend.usbvirt', )
+            # Ensure the virtual backend can be found and is loaded
+            backend = UsbTools.find_backend()
+            loader = backend.create_loader()()
+            loader.load(args.virtual)
+
+        try:
+            add_custom_devices(Ftdi, args.vidpid, force_hex=True)
+        except ValueError as exc:
+            argparser.error(str(exc))
+
+        Ftdi.show_devices()
+
+    except (ImportError, IOError, NotImplementedError, ValueError) as exc:
+        print(f'\nError: {exc}', file=stderr)
+        if debug:
+            print(format_exc(chain=False), file=stderr)
+        sys_exit(1)
+    except KeyboardInterrupt:
+        sys_exit(2)
+
+
+if __name__ == '__main__':
+    main()

ros2_ws_arm/arm/env/bin/i2cscan.py

@@ -0,0 +1,155 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2018-2024, Emmanuel Blot <emmanuel.blot@free.fr>
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Tiny I2C bus scanner."""
+
+# pylint: disable=broad-except
+
+from argparse import ArgumentParser, FileType
+from logging import Formatter, StreamHandler, getLogger, DEBUG, ERROR
+from sys import exit as sys_exit, modules, stderr
+from traceback import format_exc
+from pyftdi import FtdiLogger
+from pyftdi.ftdi import Ftdi
+from pyftdi.i2c import I2cController, I2cNackError
+from pyftdi.misc import add_custom_devices
+
+
+class I2cBusScanner:
+    """Scan I2C bus to find slave.
+
+       Emit the I2C address message, but no data. Detect any ACK on each valid
+       address.
+    """
+
+    SMB_READ_RANGE = list(range(0x30, 0x38)) + list(range(0x50, 0x60))
+
+    HIGHEST_I2C_SLAVE_ADDRESS = 0x78
+
+    @classmethod
+    def scan(cls, url: str, smb_mode: bool = True, force: bool = False) \
+            -> None:
+        """Scan an I2C bus to detect slave device.
+
+           :param url: FTDI URL
+           :param smb_mode: whether to use SMBbus restrictions or regular I2C
+                            mode.
+        """
+        i2c = I2cController()
+        slaves = []
+        getLogger('pyftdi.i2c').setLevel(ERROR)
+        try:
+            i2c.set_retry_count(1)
+            i2c.force_clock_mode(force)
+            i2c.configure(url)
+            for addr in range(cls.HIGHEST_I2C_SLAVE_ADDRESS+1):
+                port = i2c.get_port(addr)
+                if smb_mode:
+                    try:
+                        if addr in cls.SMB_READ_RANGE:
+                            port.read(0)
+                            slaves.append('R')
+                        else:
+                            port.write([])
+                            slaves.append('W')
+                    except I2cNackError:
+                        slaves.append('.')
+                else:
+                    try:
+                        port.read(0)
+                        slaves.append('R')
+                        continue
+                    except I2cNackError:
+                        pass
+                    try:
+                        port.write([])
+                        slaves.append('W')
+                    except I2cNackError:
+                        slaves.append('.')
+        finally:
+            i2c.terminate()
+        columns = 16
+        row = 0
+        print('  ', ''.join(f' {col:01X} ' for col in range(columns)))
+        while True:
+            chunk = slaves[row:row+columns]
+            if not chunk:
+                break
+            print(f' {row//columns:01X}:', '  '.join(chunk))
+            row += columns
+
+
+def main():
+    """Entry point."""
+    debug = False
+    try:
+        argparser = ArgumentParser(description=modules[__name__].__doc__)
+        argparser.add_argument('device', nargs='?', default='ftdi:///?',
+                               help='serial port device name')
+        argparser.add_argument('-S', '--no-smb', action='store_true',
+                               default=False,
+                               help='use regular I2C mode vs. SMBbus scan')
+        argparser.add_argument('-P', '--vidpid', action='append',
+                               help='specify a custom VID:PID device ID, '
+                                    'may be repeated')
+        argparser.add_argument('-V', '--virtual', type=FileType('r'),
+                               help='use a virtual device, specified as YaML')
+        argparser.add_argument('-v', '--verbose', action='count', default=0,
+                               help='increase verbosity')
+        argparser.add_argument('-d', '--debug', action='store_true',
+                               help='enable debug mode')
+        argparser.add_argument('-F', '--force', action='store_true',
+                               help='force clock mode (for FT2232D)')
+        args = argparser.parse_args()
+        debug = args.debug
+
+        if not args.device:
+            argparser.error('Serial device not specified')
+
+        loglevel = max(DEBUG, ERROR - (10 * args.verbose))
+        loglevel = min(ERROR, loglevel)
+        if debug:
+            formatter = Formatter('%(asctime)s.%(msecs)03d %(name)-20s '
+                                  '%(message)s', '%H:%M:%S')
+        else:
+            formatter = Formatter('%(message)s')
+        FtdiLogger.log.addHandler(StreamHandler(stderr))
+        FtdiLogger.set_formatter(formatter)
+        FtdiLogger.set_level(loglevel)
+
+        if args.virtual:
+            # pylint: disable=import-outside-toplevel
+            from pyftdi.usbtools import UsbTools
+            # Force PyUSB to use PyFtdi test framework for USB backends
+            UsbTools.BACKENDS = ('pyftdi.tests.backend.usbvirt', )
+            # Ensure the virtual backend can be found and is loaded
+            backend = UsbTools.find_backend()
+            loader = backend.create_loader()()
+            loader.load(args.virtual)
+
+        try:
+            add_custom_devices(Ftdi, args.vidpid, force_hex=True)
+        except ValueError as exc:
+            argparser.error(str(exc))
+
+        I2cBusScanner.scan(args.device, not args.no_smb, args.force)
+
+    except (ImportError, IOError, NotImplementedError, ValueError) as exc:
+        print(f'\nError: {exc}', file=stderr)
+        if debug:
+            print(format_exc(chain=False), file=stderr)
+        sys_exit(1)
+    except KeyboardInterrupt:
+        sys_exit(2)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except Exception as _exc:
+        print(str(_exc), file=stderr)

ros2_ws_arm/arm/env/bin/pip

@@ -0,0 +1,8 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

ros2_ws_arm/arm/env/bin/pip3

@@ -0,0 +1,8 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

ros2_ws_arm/arm/env/bin/pip3.12

@@ -0,0 +1,8 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

ros2_ws_arm/arm/env/bin/pyterm.py

@@ -0,0 +1,367 @@
+#!/home/arm/Desktop/ros2_ws_arm/arm/env/bin/python3
+
+"""Simple Python serial terminal
+"""
+
+# Copyright (c) 2010-2024, Emmanuel Blot <emmanuel.blot@free.fr>
+# Copyright (c) 2016, Emmanuel Bouaziz <ebouaziz@free.fr>
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+# pylint: disable=broad-except
+# pylint: disable=wrong-import-position
+
+from argparse import ArgumentParser, FileType
+from atexit import register
+from collections import deque
+from logging import Formatter, StreamHandler, DEBUG, ERROR
+from os import environ, linesep, stat
+from re import search
+from sys import exit as sys_exit, modules, platform, stderr, stdout
+from time import sleep
+from threading import Event, Thread
+from traceback import format_exc
+from _thread import interrupt_main
+
+# pylint: disable=import-error
+# pylint: disable=import-outside-toplevel
+
+from pyftdi import FtdiLogger
+from pyftdi.ftdi import Ftdi
+from pyftdi.misc import to_bps, add_custom_devices
+from pyftdi.term import Terminal
+
+
+class MiniTerm:
+    """A mini serial terminal to demonstrate pyserial extensions"""
+
+    DEFAULT_BAUDRATE = 115200
+
+    def __init__(self, device, baudrate=None, parity=None, rtscts=False,
+                 debug=False):
+        self._terminal = Terminal()
+        self._device = device
+        self._baudrate = baudrate or self.DEFAULT_BAUDRATE
+        self._port = self._open_port(self._device, self._baudrate, parity,
+                                     rtscts, debug)
+        self._resume = False
+        self._silent = False
+        self._rxq = deque()
+        self._rxe = Event()
+        self._debug = debug
+        register(self._cleanup)
+
+    def run(self, fullmode=False, loopback=False, silent=False,
+            localecho=False, autocr=False):
+        """Switch to a pure serial terminal application"""
+
+        self._terminal.init(fullmode)
+        print(f'Entering minicom mode @ { self._port.baudrate} bps')
+        stdout.flush()
+        self._resume = True
+        # start the reader (target to host direction) within a dedicated thread
+        args = [loopback]
+        if self._device.startswith('ftdi://'):
+            # with pyftdi/pyusb/libusb stack, there is no kernel buffering
+            # which means that a UART source with data burst may overflow the
+            # FTDI HW buffer while the SW stack is dealing with formatting
+            # and console output. Use an intermediate thread to pop out data
+            # out from the HW as soon as it is made available, and use a deque
+            # to serve the actual reader thread
+            args.append(self._get_from_source)
+            sourcer = Thread(target=self._sourcer, daemon=True)
+            sourcer.start()
+        else:
+            # regular kernel buffered device
+            args.append(self._get_from_port)
+        reader = Thread(target=self._reader, args=tuple(args), daemon=True)
+        reader.start()
+        # start the writer (host to target direction)
+        self._writer(fullmode, silent, localecho, autocr)
+
+    def _sourcer(self):
+        try:
+            while self._resume:
+                data = self._port.read(4096)
+                if not data:
+                    continue
+                self._rxq.append(data)
+                self._rxe.set()
+        except Exception as ex:
+            self._resume = False
+            print(str(ex), file=stderr)
+            interrupt_main()
+
+    def _get_from_source(self):
+        while not self._rxq and self._resume:
+            if self._rxe.wait(0.1):
+                self._rxe.clear()
+                break
+        if not self._rxq:
+            return bytearray()
+        return self._rxq.popleft()
+
+    def _get_from_port(self):
+        try:
+            return self._port.read(4096)
+        except OSError as ex:
+            self._resume = False
+            print(str(ex), file=stderr)
+            interrupt_main()
+            return bytearray()
+        except Exception as ex:
+            print(str(ex), file=stderr)
+            return bytearray()
+
+    def _reader(self, loopback, getfunc):
+        """Loop forever, processing received serial data in terminal mode"""
+        try:
+            # Try to read as many bytes as possible at once, and use a short
+            # timeout to avoid blocking for more data
+            self._port.timeout = 0.050
+            while self._resume:
+                if self._silent:
+                    sleep(0.25)
+                    continue
+                data = getfunc()
+                if data:
+                    stdout.write(data.decode('utf8', errors='replace'))
+                    stdout.flush()
+                if loopback:
+                    self._port.write(data)
+        except KeyboardInterrupt:
+            return
+        except Exception as exc:
+            print(f'Exception: {exc}')
+            if self._debug:
+                print(format_exc(chain=False), file=stderr)
+            interrupt_main()
+
+    def _writer(self, fullmode, silent, localecho, crlf=0):
+        """Loop and copy console->serial until EOF character is found"""
+        while self._resume:
+            try:
+                char = self._terminal.getkey()
+                if fullmode and ord(char) == 0x2:    # Ctrl+B
+                    self._cleanup(True)
+                    return
+                if self._terminal.IS_MSWIN:
+                    if ord(char) in (0, 224):
+                        char = self._terminal.getkey()
+                        self._port.write(self._terminal.getch_to_escape(char))
+                        continue
+                    if ord(char) == 0x3:    # Ctrl+C
+                        raise KeyboardInterrupt('Ctrl-C break')
+                if silent:
+                    if ord(char) == 0x6:    # Ctrl+F
+                        self._silent = True
+                        print('Silent\n')
+                        continue
+                    if ord(char) == 0x7:    # Ctrl+G
+                        self._silent = False
+                        print('Reg\n')
+                        continue
+                if localecho:
+                    stdout.write(char.decode('utf8', errors='replace'))
+                    stdout.flush()
+                if crlf:
+                    if char == b'\n':
+                        self._port.write(b'\r')
+                        if crlf > 1:
+                            continue
+                self._port.write(char)
+            except KeyError:
+                continue
+            except KeyboardInterrupt:
+                if fullmode:
+                    if self._terminal.IS_MSWIN:
+                        self._port.write(b'\x03')
+                    continue
+                self._cleanup(True)
+
+    def _cleanup(self, *args):
+        """Cleanup resource before exiting"""
+        if args and args[0]:
+            print(f'{linesep}Aborting...')
+        try:
+            self._resume = False
+            if self._port:
+                # wait till the other thread completes
+                sleep(0.5)
+                try:
+                    rem = self._port.inWaiting()
+                except IOError:
+                    # maybe a bug in underlying wrapper...
+                    rem = 0
+                # consumes all the received bytes
+                for _ in range(rem):
+                    self._port.read()
+                self._port.close()
+                self._port = None
+                print('Bye.')
+        except Exception as ex:
+            print(str(ex), file=stderr)
+        finally:
+            if self._terminal:
+                self._terminal.reset()
+                self._terminal = None
+
+    @staticmethod
+    def _open_port(device, baudrate, parity, rtscts, debug=False):
+        """Open the serial communication port"""
+        try:
+            from serial.serialutil import SerialException
+            from serial import PARITY_NONE
+        except ImportError as exc:
+            raise ImportError("Python serial module not installed") from exc
+        try:
+            from serial import serial_for_url, VERSION as serialver
+            # use a simple regex rather than adding a new dependency on the
+            # more complete 'packaging' module
+            vmo = search(r'^(\d+)\.(\d+)', serialver)
+            if not vmo:
+                # unable to parse version
+                raise ValueError()
+            if tuple(int(x) for x in vmo.groups()) < (3, 0):
+                # pysrial version is too old
+                raise ValueError()
+        except (ValueError, IndexError, ImportError) as exc:
+            raise ImportError("pyserial 3.0+ is required") from exc
+        # the following import enables serial protocol extensions
+        if device.startswith('ftdi:'):
+            try:
+                from pyftdi import serialext
+                serialext.touch()
+            except ImportError as exc:
+                raise ImportError("PyFTDI module not installed") from exc
+        try:
+            port = serial_for_url(device,
+                                  baudrate=baudrate,
+                                  parity=parity or PARITY_NONE,
+                                  rtscts=rtscts,
+                                  timeout=0)
+            if not port.is_open:
+                port.open()
+            if not port.is_open:
+                raise IOError(f"Cannot open port '{device}'")
+            if debug:
+                backend = port.BACKEND if hasattr(port, 'BACKEND') else '?'
+                print(f"Using serial backend '{backend}'")
+            return port
+        except SerialException as exc:
+            raise IOError(str(exc)) from exc
+
+
+def get_default_device() -> str:
+    """Return the default comm device, depending on the host/OS."""
+    envdev = environ.get('FTDI_DEVICE', '')
+    if envdev:
+        return envdev
+    if platform == 'win32':
+        device = 'COM1'
+    elif platform == 'darwin':
+        device = '/dev/cu.usbserial'
+    elif platform == 'linux':
+        device = '/dev/ttyS0'
+    else:
+        device = ''
+    try:
+        stat(device)
+    except OSError:
+        device = 'ftdi:///1'
+    return device
+
+
+def main():
+    """Main routine"""
+    debug = False
+    try:
+        default_device = get_default_device()
+        argparser = ArgumentParser(description=modules[__name__].__doc__)
+        argparser.add_argument('-f', '--fullmode', dest='fullmode',
+                               action='store_true',
+                               help='use full terminal mode, exit with '
+                                    '[Ctrl]+B')
+        argparser.add_argument('device', nargs='?', default=default_device,
+                               help=f'serial port device name '
+                                    f'(default: {default_device}')
+        argparser.add_argument('-b', '--baudrate',
+                               default=str(MiniTerm.DEFAULT_BAUDRATE),
+                               help=f'serial port baudrate '
+                                    f'(default: {MiniTerm.DEFAULT_BAUDRATE})')
+        argparser.add_argument('-w', '--hwflow',
+                               action='store_true',
+                               help='hardware flow control')
+        argparser.add_argument('-e', '--localecho',
+                               action='store_true',
+                               help='local echo mode (print all typed chars)')
+        argparser.add_argument('-r', '--crlf',
+                               action='count', default=0,
+                               help='prefix LF with CR char, use twice to '
+                                    'replace all LF with CR chars')
+        argparser.add_argument('-l', '--loopback',
+                               action='store_true',
+                               help='loopback mode (send back all received '
+                                    'chars)')
+        argparser.add_argument('-s', '--silent', action='store_true',
+                               help='silent mode')
+        argparser.add_argument('-P', '--vidpid', action='append',
+                               help='specify a custom VID:PID device ID, '
+                                    'may be repeated')
+        argparser.add_argument('-V', '--virtual', type=FileType('r'),
+                               help='use a virtual device, specified as YaML')
+        argparser.add_argument('-v', '--verbose', action='count',
+                               help='increase verbosity')
+        argparser.add_argument('-d', '--debug', action='store_true',
+                               help='enable debug mode')
+        args = argparser.parse_args()
+        debug = args.debug
+
+        if not args.device:
+            argparser.error('Serial device not specified')
+
+        loglevel = max(DEBUG, ERROR - (10 * (args.verbose or 0)))
+        loglevel = min(ERROR, loglevel)
+        if debug:
+            formatter = Formatter('%(asctime)s.%(msecs)03d %(name)-20s '
+                                  '%(message)s', '%H:%M:%S')
+        else:
+            formatter = Formatter('%(message)s')
+        FtdiLogger.set_formatter(formatter)
+        FtdiLogger.set_level(loglevel)
+        FtdiLogger.log.addHandler(StreamHandler(stderr))
+
+        if args.virtual:
+            from pyftdi.usbtools import UsbTools
+            # Force PyUSB to use PyFtdi test framework for USB backends
+            UsbTools.BACKENDS = ('pyftdi.tests.backend.usbvirt', )
+            # Ensure the virtual backend can be found and is loaded
+            backend = UsbTools.find_backend()
+            loader = backend.create_loader()()
+            loader.load(args.virtual)
+
+        try:
+            add_custom_devices(Ftdi, args.vidpid, force_hex=True)
+        except ValueError as exc:
+            argparser.error(str(exc))
+
+        miniterm = MiniTerm(device=args.device,
+                            baudrate=to_bps(args.baudrate),
+                            parity='N',
+                            rtscts=args.hwflow,
+                            debug=args.debug)
+        miniterm.run(args.fullmode, args.loopback, args.silent, args.localecho,
+                     args.crlf)
+
+    except (IOError, ValueError) as exc:
+        print(f'\nError: {exc}', file=stderr)
+        if debug:
+            print(format_exc(chain=False), file=stderr)
+        sys_exit(1)
+    except KeyboardInterrupt:
+        sys_exit(2)
+
+
+if __name__ == '__main__':
+    main()

ros2_ws_arm/arm/env/bin/python

@@ -0,0 +1 @@
+python3

ros2_ws_arm/arm/env/bin/python3

@@ -0,0 +1 @@
+/usr/bin/python3

ros2_ws_arm/arm/env/bin/python3.12

@@ -0,0 +1 @@
+python3

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Melissa LeBlanc-Williams for Adafruit Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.1
+Name: Adafruit-PureIO
+Version: 1.1.11
+Summary: Pure python (i.e. no native extensions) access to Linux IO    including I2C and SPI. Drop in replacement for smbus and spidev modules.
+Author-email: Adafruit Industries <circuitpython@adafruit.com>
+License: MIT
+Project-URL: Homepage, https://github.com/adafruit/Adafruit_Python_PureIO
+Keywords: adafruit,blinka,micropython,pureio,ioctl,spi,i2c,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Hardware
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.5.0
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: optional
+
+Introduction
+============
+
+.. image:: https://readthedocs.org/projects/adafruit-pureio/badge/?version=latest
+    :target: https://adafruit-pureio.readthedocs.io/en/latest/
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/discord/327254708534116352.svg
+    :target: https://adafru.it/discord
+    :alt: Discord
+
+.. image:: https://github.com/adafruit/Adafruit_Python_PureIO/workflows/Build%20CI/badge.svg
+    :target: https://github.com/adafruit/Adafruit_Python_PureIO/actions
+    :alt: Build Status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+    :alt: Code Style: Black
+
+Pure python (i.e. no native extensions) access to Linux IO including I2C and SPI. Drop in replacement for smbus and spidev modules.
+
+
+Dependencies
+=============
+This driver depends on:
+
+* Python 3.5 or higher
+
+Installing from PyPI
+=====================
+
+On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locally `from
+PyPI <https://pypi.org/project/Adafruit-PureIO/>`_. To install for current user:
+
+.. code-block:: shell
+
+    pip3 install Adafruit-PureIO
+
+To install system-wide (this may be required in some cases):
+
+.. code-block:: shell
+
+    sudo pip3 install Adafruit-PureIO
+
+To install in a virtual environment in your current project:
+
+.. code-block:: shell
+
+    mkdir project-name && cd project-name
+    python3 -m venv .env
+    source .env/bin/activate
+    pip3 install Adafruit-PureIO
+
+Contributing
+============
+
+Contributions are welcome! Please read our `Code of Conduct
+<https://github.com/adafruit/Adafruit_Python_PureIO/blob/master/CODE_OF_CONDUCT.md>`_
+before contributing to help this project stay welcoming.
+
+Documentation
+=============
+
+For information on building library documentation, please check out `this guide <https://learn.adafruit.com/creating-and-sharing-a-circuitpython-library/sharing-our-docs-on-readthedocs#sphinx-5-1>`_.

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+Adafruit_PureIO-1.1.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Adafruit_PureIO-1.1.11.dist-info/LICENSE,sha256=ql5UE2yEDtLjM_ZdQ_7LxsDo__Yuuuzk_ygc0qZnIIg,1115
+Adafruit_PureIO-1.1.11.dist-info/METADATA,sha256=ZFhWw2KZ9bID_Hw6y3F8wfgROxzB21QRJNeFHvtgR5U,2971
+Adafruit_PureIO-1.1.11.dist-info/RECORD,,
+Adafruit_PureIO-1.1.11.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+Adafruit_PureIO-1.1.11.dist-info/top_level.txt,sha256=SmMfnx3lOkpNy0PYzumNO0ilFHQbhyQG-l1LwNGJfqQ,16
+Adafruit_PureIO/__init__.py,sha256=2YZOh5vH36sr5osQMuBrvBYzL6CMvWq4g85z1Q6LYsQ,113
+Adafruit_PureIO/__pycache__/__init__.cpython-312.pyc,,
+Adafruit_PureIO/__pycache__/smbus.cpython-312.pyc,,
+Adafruit_PureIO/__pycache__/spi.cpython-312.pyc,,
+Adafruit_PureIO/smbus.py,sha256=1cWjGk03afhvRaKZqbFlSQT8j8SfmrJg-rlqxdOM3Gg,14872
+Adafruit_PureIO/spi.py,sha256=CfZr8GzsWpjnNaRe8Ymwel4QVvADG5oQNI5Rj2BMrW4,11485

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO-1.1.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+Adafruit_PureIO

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2020 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO/smbus.py

@@ -0,0 +1,386 @@
+# SPDX-FileCopyrightText: 2016 Tony DiCola for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+
+"""
+`Adafruit_PureIO.smbus`
+================================================================================
+
+Pure python (i.e. no native extensions) access to Linux IO I2C interface that mimics the
+Python SMBus API.
+
+* Author(s): Tony DiCola, Lady Ada, Melissa LeBlanc-Williams
+
+Implementation Notes
+--------------------
+
+**Software and Dependencies:**
+
+* Linux and Python 3.5 or Higher
+
+"""
+
+from ctypes import c_uint8, c_uint16, c_uint32, cast, pointer, POINTER
+from ctypes import create_string_buffer, Structure
+from fcntl import ioctl
+import struct
+
+# pylint: disable=fixme
+
+# I2C C API constants (from linux kernel headers)
+I2C_M_TEN = 0x0010  # this is a ten bit chip address
+I2C_M_RD = 0x0001  # read data, from slave to master
+I2C_M_STOP = 0x8000  # if I2C_FUNC_PROTOCOL_MANGLING
+I2C_M_NOSTART = 0x4000  # if I2C_FUNC_NOSTART
+I2C_M_REV_DIR_ADDR = 0x2000  # if I2C_FUNC_PROTOCOL_MANGLING
+I2C_M_IGNORE_NAK = 0x1000  # if I2C_FUNC_PROTOCOL_MANGLING
+I2C_M_NO_RD_ACK = 0x0800  # if I2C_FUNC_PROTOCOL_MANGLING
+I2C_M_RECV_LEN = 0x0400  # length will be first received byte
+
+I2C_SLAVE = 0x0703  # Use this slave address
+I2C_SLAVE_FORCE = 0x0706  # Use this slave address, even if
+# is already in use by a driver!
+I2C_TENBIT = 0x0704  # 0 for 7 bit addrs, != 0 for 10 bit
+I2C_FUNCS = 0x0705  # Get the adapter functionality mask
+I2C_RDWR = 0x0707  # Combined R/W transfer (one STOP only)
+I2C_PEC = 0x0708  # != 0 to use PEC with SMBus
+I2C_SMBUS = 0x0720  # SMBus transfer
+
+
+# ctypes versions of I2C structs defined by kernel.
+# Tone down pylint for the Python classes that mirror C structs.
+# pylint: disable=invalid-name,too-few-public-methods
+class i2c_msg(Structure):
+    """Linux i2c_msg struct."""
+
+    _fields_ = [
+        ("addr", c_uint16),
+        ("flags", c_uint16),
+        ("len", c_uint16),
+        ("buf", POINTER(c_uint8)),
+    ]
+
+
+class i2c_rdwr_ioctl_data(Structure):  # pylint: disable=invalid-name
+    """Linux i2c data struct."""
+
+    _fields_ = [("msgs", POINTER(i2c_msg)), ("nmsgs", c_uint32)]
+
+
+# pylint: enable=invalid-name,too-few-public-methods
+
+
+# pylint: disable=attribute-defined-outside-init
+def make_i2c_rdwr_data(messages):
+    """Utility function to create and return an i2c_rdwr_ioctl_data structure
+    populated with a list of specified I2C messages.  The messages parameter
+    should be a list of tuples which represent the individual I2C messages to
+    send in this transaction.  Tuples should contain 4 elements: address value,
+    flags value, buffer length, ctypes c_uint8 pointer to buffer.
+    """
+    # Create message array and populate with provided data.
+    msg_data_type = i2c_msg * len(messages)
+    msg_data = msg_data_type()
+    for i, message in enumerate(messages):
+        msg_data[i].addr = message[0] & 0x7F
+        msg_data[i].flags = message[1]
+        msg_data[i].len = message[2]
+        msg_data[i].buf = message[3]
+    # Now build the data structure.
+    data = i2c_rdwr_ioctl_data()
+    data.msgs = msg_data
+    data.nmsgs = len(messages)
+    return data
+
+
+# pylint: enable=attribute-defined-outside-init
+
+
+# Create an interface that mimics the Python SMBus API.
+class SMBus:
+    """I2C interface that mimics the Python SMBus API but is implemented with
+    pure Python calls to ioctl and direct /dev/i2c device access.
+    """
+
+    def __init__(self, bus=None):
+        """Create a new smbus instance.  Bus is an optional parameter that
+        specifies the I2C bus number to use, for example 1 would use device
+        /dev/i2c-1.  If bus is not specified then the open function should be
+        called to open the bus.
+        """
+        self._device = None
+        if bus is not None:
+            self.open(bus)
+
+    def __del__(self):
+        """Clean up any resources used by the SMBus instance."""
+        self.close()
+
+    def __enter__(self):
+        """Context manager enter function."""
+        # Just return this object so it can be used in a with statement, like
+        # with SMBus(1) as bus:
+        #     # do stuff!
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit function, ensures resources are cleaned up."""
+        self.close()
+        return False  # Don't suppress exceptions.
+
+    def open(self, bus):
+        """Open the smbus interface on the specified bus."""
+        # Close the device if it's already open.
+        if self._device is not None:
+            self.close()
+        # Try to open the file for the specified bus.  Must turn off buffering
+        # or else Python 3 fails (see: https://bugs.python.org/issue20074)
+        # pylint: disable=consider-using-with
+        self._device = open(f"/dev/i2c-{bus}", "r+b", buffering=0)
+        # pylint: enable=consider-using-with
+        # TODO: Catch IOError and throw a better error message that describes
+        # what's wrong (i.e. I2C may not be enabled or the bus doesn't exist).
+
+    def close(self):
+        """Close the smbus connection.  You cannot make any other function
+        calls on the bus unless open is called!"""
+        if self._device is not None:
+            self._device.close()
+            self._device = None
+
+    def _select_device(self, addr):
+        """Set the address of the device to communicate with on the I2C bus."""
+        ioctl(self._device.fileno(), I2C_SLAVE, addr & 0x7F)
+
+    def read_byte(self, addr):
+        """Read a single byte from the specified device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        self._select_device(addr)
+        return ord(self._device.read(1))
+
+    def read_bytes(self, addr, number):
+        """Read many bytes from the specified device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        self._select_device(addr)
+        return self._device.read(number)
+
+    def read_byte_data(self, addr, cmd):
+        """Read a single byte from the specified cmd register of the device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Build ctypes values to marshall between ioctl and Python.
+        reg = c_uint8(cmd)
+        result = c_uint8()
+        # Build ioctl request.
+        request = make_i2c_rdwr_data(
+            [
+                (addr, 0, 1, pointer(reg)),  # Write cmd register.
+                (addr, I2C_M_RD, 1, pointer(result)),  # Read 1 byte as result.
+            ]
+        )
+        # Make ioctl call and return result data.
+        ioctl(self._device.fileno(), I2C_RDWR, request)
+        return result.value
+
+    def read_word_data(self, addr, cmd):
+        """Read a word (2 bytes) from the specified cmd register of the device.
+        Note that this will interpret data using the endianness of the processor
+        running Python (typically little endian)!
+        """
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Build ctypes values to marshall between ioctl and Python.
+        reg = c_uint8(cmd)
+        result = c_uint16()
+        # Build ioctl request.
+        request = make_i2c_rdwr_data(
+            [
+                (addr, 0, 1, pointer(reg)),  # Write cmd register.
+                (
+                    addr,
+                    I2C_M_RD,
+                    2,
+                    cast(pointer(result), POINTER(c_uint8)),
+                ),  # Read word (2 bytes).
+            ]
+        )
+        # Make ioctl call and return result data.
+        ioctl(self._device.fileno(), I2C_RDWR, request)
+        return result.value
+
+    def read_block_data(self, addr, cmd):
+        """Perform a block read from the specified cmd register of the device.
+        The amount of data read is determined by the first byte send back by
+        the device.  Data is returned as a bytearray.
+        """
+        # TODO: Unfortunately this will require calling the low level I2C
+        # access ioctl to trigger a proper read_block_data.  The amount of data
+        # returned isn't known until the device starts responding so an I2C_RDWR
+        # ioctl won't work.
+        raise NotImplementedError()
+
+    def read_i2c_block_data(self, addr, cmd, length=32):
+        """Perform a read from the specified cmd register of device.  Length number
+        of bytes (default of 32) will be read and returned as a bytearray.
+        """
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Build ctypes values to marshall between ioctl and Python.
+
+        # convert register into bytearray
+        if not isinstance(cmd, (bytes, bytearray)):
+            reg = cmd  # backup
+            cmd = bytearray(1)
+            cmd[0] = reg
+
+        cmdstring = create_string_buffer(len(cmd))
+        for i, val in enumerate(cmd):
+            cmdstring[i] = val
+
+        result = create_string_buffer(length)
+
+        # Build ioctl request.
+        request = make_i2c_rdwr_data(
+            [
+                (
+                    addr,
+                    0,
+                    len(cmd),
+                    cast(cmdstring, POINTER(c_uint8)),
+                ),  # Write cmd register.
+                (addr, I2C_M_RD, length, cast(result, POINTER(c_uint8))),  # Read data.
+            ]
+        )
+
+        # Make ioctl call and return result data.
+        ioctl(self._device.fileno(), I2C_RDWR, request)
+        return bytearray(
+            result.raw
+        )  # Use .raw instead of .value which will stop at a null byte!
+
+    def write_quick(self, addr):
+        """Write a single byte to the specified device."""
+        # What a strange function, from the python-smbus source this appears to
+        # just write a single byte that initiates a write to the specified device
+        # address (but writes no data!).  The functionality is duplicated below
+        # but the actual use case for this is unknown.
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Build ioctl request.
+        request = make_i2c_rdwr_data(
+            [
+                (addr, 0, 0, None),
+            ]
+        )  # Write with no data.
+        # Make ioctl call and return result data.
+        ioctl(self._device.fileno(), I2C_RDWR, request)
+
+    def write_byte(self, addr, val):
+        """Write a single byte to the specified device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        self._select_device(addr)
+        data = bytearray(1)
+        data[0] = val & 0xFF
+        self._device.write(data)
+
+    def write_bytes(self, addr, buf):
+        """Write many bytes to the specified device. buf is a bytearray"""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        self._select_device(addr)
+        self._device.write(buf)
+
+    def write_byte_data(self, addr, cmd, val):
+        """Write a byte of data to the specified cmd register of the device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Construct a string of data to send with the command register and byte value.
+        data = bytearray(2)
+        data[0] = cmd & 0xFF
+        data[1] = val & 0xFF
+        # Send the data to the device.
+        self._select_device(addr)
+        self._device.write(data)
+
+    def write_word_data(self, addr, cmd, val):
+        """Write a word (2 bytes) of data to the specified cmd register of the
+        device.  Note that this will write the data in the endianness of the
+        processor running Python (typically little endian)!
+        """
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Construct a string of data to send with the command register and word value.
+        data = struct.pack("=BH", cmd & 0xFF, val & 0xFFFF)
+        # Send the data to the device.
+        self._select_device(addr)
+        self._device.write(data)
+
+    def write_block_data(self, addr, cmd, vals):
+        """Write a block of data to the specified cmd register of the device.
+        The amount of data to write should be the first byte inside the vals
+        string/bytearray and that count of bytes of data to write should follow
+        it.
+        """
+        # Just use the I2C block data write to write the provided values and
+        # their length as the first byte.
+        data = bytearray(len(vals) + 1)
+        data[0] = len(vals) & 0xFF
+        data[1:] = vals[0:]
+        self.write_i2c_block_data(addr, cmd, data)
+
+    def write_i2c_block_data(self, addr, cmd, vals):
+        """Write a buffer of data to the specified cmd register of the device."""
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Construct a string of data to send, including room for the command register.
+        data = bytearray(len(vals) + 1)
+        data[0] = cmd & 0xFF  # Command register at the start.
+        data[1:] = vals[0:]  # Copy in the block data (ugly but necessary to ensure
+        # the entire write happens in one transaction).
+        # Send the data to the device.
+        self._select_device(addr)
+        self._device.write(data)
+
+    def process_call(self, addr, cmd, val):
+        """Perform a smbus process call by writing a word (2 byte) value to
+        the specified register of the device, and then reading a word of response
+        data (which is returned).
+        """
+        assert (
+            self._device is not None
+        ), "Bus must be opened before operations are made against it!"
+        # Build ctypes values to marshall between ioctl and Python.
+        data = create_string_buffer(struct.pack("=BH", cmd, val))
+        result = c_uint16()
+        # Build ioctl request.
+        request = make_i2c_rdwr_data(
+            [
+                (addr, 0, 3, cast(pointer(data), POINTER(c_uint8))),  # Write data.
+                (
+                    addr,
+                    I2C_M_RD,
+                    2,
+                    cast(pointer(result), POINTER(c_uint8)),
+                ),  # Read word (2 bytes).
+            ]
+        )
+        # Make ioctl call and return result data.
+        ioctl(self._device.fileno(), I2C_RDWR, request)
+        # Note the python-smbus code appears to have a rather serious bug and
+        # does not return the result value!  This is fixed below by returning it.
+        return result.value

ros2_ws_arm/arm/env/lib/python3.12/site-packages/Adafruit_PureIO/spi.py

@@ -0,0 +1,404 @@
+# SPDX-FileCopyrightText: 2020 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`Adafruit_PureIO.spi`
+================================================================================
+
+Pure python (i.e. no native extensions) access to Linux IO SPI interface that is
+similar to the SpiDev API. Based heavily on https://github.com/tomstokes/python-spi/.
+
+* Author(s): Tom Stokes, Melissa LeBlanc-Williams
+
+Implementation Notes
+--------------------
+
+**Software and Dependencies:**
+
+* Linux and Python 3.5 or Higher
+
+"""
+
+# imports
+from ctypes import create_string_buffer, string_at, addressof
+from fcntl import ioctl
+import struct
+import platform
+import os.path
+from os import environ
+import array
+
+__version__ = "1.1.11"
+__repo__ = "https://github.com/adafruit/Adafruit_Python_PureIO.git"
+
+# SPI C API constants (from linux kernel headers)
+SPI_CPHA = 0x01
+SPI_CPOL = 0x02
+SPI_CS_HIGH = 0x04
+SPI_LSB_FIRST = 0x08
+SPI_THREE_WIRE = 0x10
+SPI_LOOP = 0x20
+SPI_NO_CS = 0x40
+SPI_READY = 0x80
+SPI_TX_DUAL = 0x100
+SPI_TX_QUAD = 0x200
+SPI_RX_DUAL = 0x400
+SPI_RX_QUAD = 0x800
+
+SPI_MODE_0 = 0
+SPI_MODE_1 = SPI_CPHA
+SPI_MODE_2 = SPI_CPOL
+SPI_MODE_3 = SPI_CPHA | SPI_CPOL
+
+SPI_DEFAULT_CHUNK_SIZE = 4096
+
+
+def _ioc_encode(direction, number, structure):
+    """
+    ioctl command encoding helper function
+    Calculates the appropriate spidev ioctl op argument given the direction,
+    command number, and argument structure in python's struct.pack format.
+    Returns a tuple of the calculated op and the struct.pack format
+    See Linux kernel source file /include/uapi/asm/ioctl.h
+    """
+    ioc_magic = ord("k")
+    ioc_nrbits = 8
+    ioc_typebits = 8
+    if platform.machine() == "mips":
+        ioc_sizebits = 13
+    else:
+        ioc_sizebits = 14
+
+    ioc_nrshift = 0
+    ioc_typeshift = ioc_nrshift + ioc_nrbits
+    ioc_sizeshift = ioc_typeshift + ioc_typebits
+    ioc_dirshift = ioc_sizeshift + ioc_sizebits
+
+    size = struct.calcsize(structure)
+
+    operation = (
+        (direction << ioc_dirshift)
+        | (ioc_magic << ioc_typeshift)
+        | (number << ioc_nrshift)
+        | (size << ioc_sizeshift)
+    )
+
+    return direction, operation, structure
+
+
+# pylint: disable=too-many-instance-attributes, too-many-branches
+class SPI:
+    """
+    This class is similar to SpiDev, but instead of opening and closing
+    for each call, it is set up on initialization making it fast.
+    """
+
+    _IOC_TRANSFER_FORMAT = "QQIIHBBBBH"
+
+    if platform.machine() == "mips":
+        # Direction is 3 bits
+        _IOC_READ = 2
+        _IOC_WRITE = 4
+    else:
+        # Direction is 2 bits
+        _IOC_WRITE = 1
+        _IOC_READ = 2
+
+    # _IOC_MESSAGE is a special case, so we ony need the ioctl operation
+    _IOC_MESSAGE = _ioc_encode(_IOC_WRITE, 0, _IOC_TRANSFER_FORMAT)[1]
+
+    _IOC_RD_MODE = _ioc_encode(_IOC_READ, 1, "B")
+    _IOC_WR_MODE = _ioc_encode(_IOC_WRITE, 1, "B")
+
+    _IOC_RD_LSB_FIRST = _ioc_encode(_IOC_READ, 2, "B")
+    _IOC_WR_LSB_FIRST = _ioc_encode(_IOC_WRITE, 2, "B")
+
+    _IOC_RD_BITS_PER_WORD = _ioc_encode(_IOC_READ, 3, "B")
+    _IOC_WR_BITS_PER_WORD = _ioc_encode(_IOC_WRITE, 3, "B")
+
+    _IOC_RD_MAX_SPEED_HZ = _ioc_encode(_IOC_READ, 4, "I")
+    _IOC_WR_MAX_SPEED_HZ = _ioc_encode(_IOC_WRITE, 4, "I")
+
+    _IOC_RD_MODE32 = _ioc_encode(_IOC_READ, 5, "I")
+    _IOC_WR_MODE32 = _ioc_encode(_IOC_WRITE, 5, "I")
+    # pylint: disable=too-many-arguments
+
+    def __init__(
+        self,
+        device,
+        max_speed_hz=None,
+        bits_per_word=None,
+        phase=None,
+        polarity=None,
+        cs_high=None,
+        lsb_first=None,
+        three_wire=None,
+        loop=None,
+        no_cs=None,
+        ready=None,
+    ):
+        """
+        Create spidev interface object.
+        """
+        if isinstance(device, tuple):
+            (bus, dev) = device
+            device = f"/dev/spidev{bus:d}.{dev:d}"
+
+        if not os.path.exists(device):
+            raise IOError(f"{device} does not exist")
+
+        self.handle = os.open(device, os.O_RDWR)
+
+        self.chunk_size = SPI_DEFAULT_CHUNK_SIZE
+        if environ.get("SPI_BUFSIZE") is not None:
+            try:
+                self.chunk_size = int(os.environ.get("SPI_BUFSIZE"))
+            except ValueError:
+                self.chunk_size = SPI_DEFAULT_CHUNK_SIZE
+
+        if max_speed_hz is not None:
+            self.max_speed_hz = max_speed_hz
+
+        if bits_per_word is not None:
+            self.bits_per_word = bits_per_word
+
+        if phase is not None:
+            self.phase = phase
+
+        if polarity is not None:
+            self.polarity = polarity
+
+        if cs_high is not None:
+            self.cs_high = cs_high
+
+        if lsb_first is not None:
+            self.lsb_first = lsb_first
+
+        if three_wire is not None:
+            self.three_wire = three_wire
+
+        if loop is not None:
+            self.loop = loop
+
+        if no_cs is not None:
+            self.no_cs = no_cs
+
+        if ready is not None:
+            self.ready = ready
+
+    # pylint: enable=too-many-arguments
+
+    def _ioctl(self, ioctl_data, data=None):
+        """
+        ioctl helper function.
+
+        Performs an ioctl on self.handle. If the ioctl is an SPI read type
+        ioctl, returns the result value.
+        """
+        (direction, ioctl_bytes, structure) = ioctl_data
+        if direction == SPI._IOC_READ:
+            arg = array.array(structure, [0])
+            ioctl(self.handle, ioctl_bytes, arg, True)
+            return arg[0]
+
+        arg = struct.pack("=" + structure, data)
+        ioctl(self.handle, ioctl_bytes, arg)
+        return None
+
+    def _get_mode_field(self, field):
+        """Helper function to get specific spidev mode bits"""
+        return bool(self._ioctl(SPI._IOC_RD_MODE) & field)
+
+    def _set_mode_field(self, field, value):
+        """Helper function to set a spidev mode bit"""
+        mode = self._ioctl(SPI._IOC_RD_MODE)
+        if value:
+            mode |= field
+        else:
+            mode &= ~field
+        self._ioctl(SPI._IOC_WR_MODE, mode)
+
+    @property
+    def phase(self):
+        """SPI clock phase bit"""
+        return self._get_mode_field(SPI_CPHA)
+
+    @phase.setter
+    def phase(self, phase):
+        self._set_mode_field(SPI_CPHA, phase)
+
+    @property
+    def polarity(self):
+        """SPI polarity bit"""
+        return self._get_mode_field(SPI_CPOL)
+
+    @polarity.setter
+    def polarity(self, polarity):
+        self._set_mode_field(SPI_CPOL, polarity)
+
+    @property
+    def cs_high(self):
+        """SPI chip select active level"""
+        return self._get_mode_field(SPI_CS_HIGH)
+
+    @cs_high.setter
+    def cs_high(self, cs_high):
+        self._set_mode_field(SPI_CS_HIGH, cs_high)
+
+    @property
+    def lsb_first(self):
+        """Bit order of SPI word transfers"""
+        return self._get_mode_field(SPI_LSB_FIRST)
+
+    @lsb_first.setter
+    def lsb_first(self, lsb_first):
+        self._set_mode_field(SPI_LSB_FIRST, lsb_first)
+
+    @property
+    def three_wire(self):
+        """SPI 3-wire mode"""
+        return self._get_mode_field(SPI_THREE_WIRE)
+
+    @three_wire.setter
+    def three_wire(self, three_wire):
+        self._set_mode_field(SPI_THREE_WIRE, three_wire)
+
+    @property
+    def loop(self):
+        """SPI loopback mode"""
+        return self._get_mode_field(SPI_LOOP)
+
+    @loop.setter
+    def loop(self, loop):
+        self._set_mode_field(SPI_LOOP, loop)
+
+    @property
+    def no_cs(self):
+        """No chipselect. Single device on bus."""
+        return self._get_mode_field(SPI_NO_CS)
+
+    @no_cs.setter
+    def no_cs(self, no_cs):
+        self._set_mode_field(SPI_NO_CS, no_cs)
+
+    @property
+    def ready(self):
+        """Slave pulls low to pause"""
+        return self._get_mode_field(SPI_READY)
+
+    @ready.setter
+    def ready(self, ready):
+        self._set_mode_field(SPI_READY, ready)
+
+    @property
+    def max_speed_hz(self):
+        """Maximum SPI transfer speed in Hz.
+
+        Note that the controller cannot necessarily assign the requested
+        speed.
+        """
+        return self._ioctl(SPI._IOC_RD_MAX_SPEED_HZ)
+
+    @max_speed_hz.setter
+    def max_speed_hz(self, max_speed_hz):
+        self._ioctl(SPI._IOC_WR_MAX_SPEED_HZ, max_speed_hz)
+
+    @property
+    def bits_per_word(self):
+        """Number of bits per word of SPI transfer.
+
+        A value of 0 is equivalent to 8 bits per word
+        """
+        return self._ioctl(SPI._IOC_RD_BITS_PER_WORD)
+
+    @bits_per_word.setter
+    def bits_per_word(self, bits_per_word):
+        self._ioctl(SPI._IOC_WR_BITS_PER_WORD, bits_per_word)
+
+    @property
+    def mode(self):
+        """Mode that SPI is currently running in"""
+        return self._ioctl(SPI._IOC_RD_MODE)
+
+    @mode.setter
+    def mode(self, mode):
+        self._ioctl(SPI._IOC_WR_MODE, mode)
+
+    def writebytes(self, data, max_speed_hz=0, bits_per_word=0, delay=0):
+        """Perform half-duplex SPI write."""
+        data = array.array("B", data).tobytes()
+        # length = len(data)
+        chunks = [
+            data[i : i + self.chunk_size] for i in range(0, len(data), self.chunk_size)
+        ]
+        for chunk in chunks:
+            length = len(chunk)
+            transmit_buffer = create_string_buffer(chunk)
+            spi_ioc_transfer = struct.pack(
+                SPI._IOC_TRANSFER_FORMAT,
+                addressof(transmit_buffer),
+                0,
+                length,
+                max_speed_hz,
+                delay,
+                bits_per_word,
+                0,
+                0,
+                0,
+                0,
+            )
+            try:
+                ioctl(self.handle, SPI._IOC_MESSAGE, spi_ioc_transfer)
+            except TimeoutError as err:
+                raise Exception(  # pylint: disable=broad-exception-raised
+                    "ioctl timeout. Please try a different SPI frequency or less data."
+                ) from err
+
+    def readbytes(self, length, max_speed_hz=0, bits_per_word=0, delay=0):
+        """Perform half-duplex SPI read as a binary string"""
+        receive_buffer = create_string_buffer(length)
+        spi_ioc_transfer = struct.pack(
+            SPI._IOC_TRANSFER_FORMAT,
+            0,
+            addressof(receive_buffer),
+            length,
+            max_speed_hz,
+            delay,
+            bits_per_word,
+            0,
+            0,
+            0,
+            0,
+        )
+        ioctl(self.handle, SPI._IOC_MESSAGE, spi_ioc_transfer)
+        return string_at(receive_buffer, length)
+
+    def transfer(self, data, max_speed_hz=0, bits_per_word=0, delay=0):
+        """Perform full-duplex SPI transfer"""
+        data = array.array("B", data).tobytes()
+        receive_data = []
+
+        chunks = [
+            data[i : i + self.chunk_size] for i in range(0, len(data), self.chunk_size)
+        ]
+        for chunk in chunks:
+            length = len(chunk)
+            receive_buffer = create_string_buffer(length)
+            transmit_buffer = create_string_buffer(chunk)
+            spi_ioc_transfer = struct.pack(
+                SPI._IOC_TRANSFER_FORMAT,
+                addressof(transmit_buffer),
+                addressof(receive_buffer),
+                length,
+                max_speed_hz,
+                delay,
+                bits_per_word,
+                0,
+                0,
+                0,
+                0,
+            )
+            ioctl(self.handle, SPI._IOC_MESSAGE, spi_ioc_transfer)
+            receive_data += string_at(receive_buffer, length)
+        return receive_data

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: Adafruit-Blinka
+Version: 8.58.1
+Summary: CircuitPython APIs for non-CircuitPython versions of Python such as CPython on Linux and MicroPython.
+Home-page: https://github.com/adafruit/Adafruit_Blinka
+Author: Adafruit Industries
+Author-email: circuitpython@adafruit.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: Implementation :: MicroPython
+Requires-Python: >=3.7.0
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: Adafruit-PlatformDetect>=3.70.1
+Requires-Dist: Adafruit-PureIO>=1.1.7
+Requires-Dist: binho-host-adapter>=0.1.6
+Requires-Dist: pyftdi>=0.40.0
+Requires-Dist: adafruit-circuitpython-typing
+Requires-Dist: sysv_ipc>=1.1.0; sys_platform == "linux" and platform_machine != "mips"
+Requires-Dist: toml>=0.10.2; python_version < "3.11"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+Introduction
+============
+
+.. image:: https://readthedocs.org/projects/adafruit-micropython-blinka/badge/?version=latest
+    :target: https://circuitpython.readthedocs.io/projects/blinka/en/latest/
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/discord/327254708534116352.svg
+    :target: https://adafru.it/discord
+    :alt: Discord
+
+.. image:: https://travis-ci.com/adafruit/Adafruit_Blinka.svg?branch=master
+    :target: https://travis-ci.com/adafruit/Adafruit_Blinka
+    :alt: Build Status
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+    :alt: Code Style: Black
+
+This repository contains a selection of packages emulating the CircuitPython API
+for devices or hosts running CPython or MicroPython. Working code exists to emulate these CircuitPython packages:
+
+* **analogio** - analog input/output pins, using pin identities from board+microcontroller packages
+* **bitbangio** - software-driven interfaces for I2C, SPI
+* **board** - breakout-specific pin identities
+* **busio** - hardware-driven interfaces for I2C, SPI, UART
+* **digitalio** - digital input/output pins, using pin identities from board+microcontroller packages
+* **keypad** - support for scanning keys and key matrices
+* **microcontroller** - chip-specific pin identities
+* **micropython** - MicroPython-specific module
+* **neopixel_write** - low-level interface to NeoPixels
+* **pulseio** - contains classes that provide access to basic pulse IO (PWM)
+* **pwmio** - contains classes that provide access to basic pulse IO (PWM)
+* **rainbowio** - provides the colorwheel() function
+* **usb_hid** - act as a hid-device using usb_gadget kernel driver
+
+For details, see the `Blinka API reference
+<https://circuitpython.readthedocs.io/projects/blinka/en/latest/index.html>`_.
+
+Dependencies
+=============
+
+The emulation described above is intended to provide a
+CircuitPython-like API for devices which are running CPython or
+Micropython. Since corresponding packages should be built-in to any
+standard CircuitPython image, they have no value on a device already
+running CircuitPython and would likely conflict in unhappy ways.
+
+The test suites in the test/src folder under **testing.universal** are by design
+intended to run on *either* CircuitPython *or* CPython/Micropython+compatibility layer to prove conformance.
+
+Installing from PyPI
+=====================
+
+On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locally `from
+PyPI <https://pypi.org/project/Adafruit-Blinka/>`_. To install for current user:
+
+.. code-block:: shell
+
+    pip3 install Adafruit-Blinka
+
+To install system-wide (this may be required in some cases):
+
+.. code-block:: shell
+
+    sudo pip3 install Adafruit-Blinka
+
+To install in a virtual environment in your current project:
+
+.. code-block:: shell
+
+    mkdir project-name && cd project-name
+    python3 -m venv .env
+    source .env/bin/activate
+    pip3 install Adafruit-Blinka
+
+Usage Example
+=============
+
+The pin names may vary by board, so you may need to change the pin names in the code. This
+example runs on the Raspberry Pi boards to blink an LED connected to GPIO 18 (Pin 12):
+
+.. code-block:: python
+
+    import time
+    import board
+    import digitalio
+
+    PIN = board.D18
+
+    print("hello blinky!")
+
+    led = digitalio.DigitalInOut(PIN)
+    led.direction = digitalio.Direction.OUTPUT
+
+    while True:
+        led.value = True
+        time.sleep(0.5)
+        led.value = False
+        time.sleep(0.5)
+
+Contributing
+============
+
+Contributions are welcome! Please read our `Code of Conduct
+<https://github.com/adafruit/Adafruit_Blinka/blob/master/CODE_OF_CONDUCT.md>`_
+before contributing to help this project stay welcoming.
+
+Building locally
+================
+
+Sphinx documentation
+-----------------------
+
+Sphinx is used to build the documentation based on rST files and comments in the code. First,
+install dependencies (feel free to reuse the virtual environment from above):
+
+.. code-block:: shell
+
+    python3 -m venv .env
+    source .env/bin/activate
+    pip install Sphinx sphinx-rtd-theme Adafruit-PlatformDetect
+
+Now, once you have the virtual environment activated:
+
+.. code-block:: shell
+
+    cd docs
+    sphinx-build -E -W -b html . _build/html
+
+This will output the documentation to ``docs/_build/html``. Open the index.html in your browser to
+view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to
+locally verify it will pass.

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/RECORD

@@ -0,0 +1,811 @@
+__pycache__/analogio.cpython-312.pyc,,
+__pycache__/bitbangio.cpython-312.pyc,,
+__pycache__/board.cpython-312.pyc,,
+__pycache__/busio.cpython-312.pyc,,
+__pycache__/digitalio.cpython-312.pyc,,
+__pycache__/keypad.cpython-312.pyc,,
+__pycache__/micropython.cpython-312.pyc,,
+__pycache__/neopixel_write.cpython-312.pyc,,
+__pycache__/onewireio.cpython-312.pyc,,
+__pycache__/pulseio.cpython-312.pyc,,
+__pycache__/pwmio.cpython-312.pyc,,
+__pycache__/rainbowio.cpython-312.pyc,,
+__pycache__/usb_hid.cpython-312.pyc,,
+adafruit_blinka-8.58.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+adafruit_blinka-8.58.1.dist-info/METADATA,sha256=gN2_wSKXWlRaO5_Yyw5wyedqOLnCCLvf2Ev88tU4Sxs,5748
+adafruit_blinka-8.58.1.dist-info/RECORD,,
+adafruit_blinka-8.58.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+adafruit_blinka-8.58.1.dist-info/licenses/LICENSE,sha256=UODDtbRIa-DtQgY5-KH28RXykQH-7mvNlUpLgdsE0PM,1086
+adafruit_blinka-8.58.1.dist-info/top_level.txt,sha256=ol8MVXQjyEEz8Hm-Z57kjjZYbi9TpphczXLTwQMQTBk,167
+adafruit_blinka/__init__.py,sha256=RtWWNeVQG31khZPFin73Li5obcKv9YoMs6cbdYY_GBc,3663
+adafruit_blinka/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/agnostic/__init__.py,sha256=2ZBsZstZ0j9N2jC3h16RlIegYM6pLnB5G3CJoQZh4OE,1164
+adafruit_blinka/agnostic/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/agnostic/__pycache__/time.cpython-312.pyc,,
+adafruit_blinka/agnostic/time.py,sha256=zbUmuMLoP9LbQY5VzqI53RkJkcMT8tmwqjifyVLzyeM,2011
+adafruit_blinka/board/OLIMEX_LIME2.py,sha256=1hwzEcfJghG02KxAow7cVyHxOKBEqzsVT9ATM7mgZRw,2237
+adafruit_blinka/board/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/board/__pycache__/OLIMEX_LIME2.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/binho_nova.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/clockworkcpi3.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/coral_dev_board.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/coral_dev_board_mini.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/dragonboard_410c.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/feather_can_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/feather_epd_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/feather_huzzah.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/feather_rfm_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/feather_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/ftdi_ft2232h.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/ftdi_ft232h.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/ftdi_ft4232h.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/generic_agnostic_board.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/generic_linux_pc.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/giantboard.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/greatfet_one.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/hifive_unleashed.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/itsybitsy_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/kb2040_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/lichee_rv.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/licheepi_4a.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/macropad_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/microchip_mcp2221.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/milkv_duo.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/nodemcu.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/pico_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/pineH64.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/pyboard.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/qt2040_trinkey_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/qtpy_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/rp2040_one_u2if.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/soPine.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/tritium-h3.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/udoo_x86ultra.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/vivid_unit.cpython-312.pyc,,
+adafruit_blinka/board/__pycache__/x86j41x5.cpython-312.pyc,,
+adafruit_blinka/board/ameridroid/__init__.py,sha256=aEO0gVJkfMCoUWs3_cC4TLXIihD28dlbvXhC_z_eQW8,115
+adafruit_blinka/board/ameridroid/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/ameridroid/__pycache__/indiedroid_nova.cpython-312.pyc,,
+adafruit_blinka/board/ameridroid/indiedroid_nova.py,sha256=FuPAg2adK75liqSbE-JHlB8srmk_62hKkPf1Rweyp6I,2247
+adafruit_blinka/board/bananapi/__init__.py,sha256=vV-I0ULkHsU8jvVuAiivQIG8TbruobbLZfS6qf5S6cU,152
+adafruit_blinka/board/bananapi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpiai2h.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpiai2n.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpif3.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpif5.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpim2plus.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpim2zero.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpim4berry.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpim4zero.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/__pycache__/bpim5.cpython-312.pyc,,
+adafruit_blinka/board/bananapi/bpiai2h.py,sha256=YfMpo4su_OeMQdLiIqNToH5YvOwL9JYJbhdtjI1OfsQ,1266
+adafruit_blinka/board/bananapi/bpiai2n.py,sha256=vosrK2VeuHPlucB5w_uglk52aMPpvSWVheLeXWoFJgI,1266
+adafruit_blinka/board/bananapi/bpif3.py,sha256=wWFXR4NRCqZeqQ_l_n_SGAKJyCWGJjSRc1PHXMJyQHY,1039
+adafruit_blinka/board/bananapi/bpif5.py,sha256=sw0bwfP7THUqQLGaVIAteyscpaMEb_uWsrMIv-hm6y0,1231
+adafruit_blinka/board/bananapi/bpim2plus.py,sha256=LgEX0AUGJzc_rAUFxWhhF-iY1772nhZClMkTZgzEEe8,1441
+adafruit_blinka/board/bananapi/bpim2zero.py,sha256=hF1uV721yCx-83-X0HYLYeBuae-h2-vvpDKalZoiBEA,1441
+adafruit_blinka/board/bananapi/bpim4berry.py,sha256=NSd4gsGQQUO-sTBy6gFyw3fjB7WerceDkzmpUPRmhj4,1240
+adafruit_blinka/board/bananapi/bpim4zero.py,sha256=CfsEViAkcbvsGnjgm2-ubNMMocAjgu4zTQGHXjVqFOY,1235
+adafruit_blinka/board/bananapi/bpim5.py,sha256=dvuj_C6eQgOxvvPlbuDZiDNl-JJJKUeYDEgJRiiDWMQ,1337
+adafruit_blinka/board/beagleboard/__init__.py,sha256=J8PAw_ifGdqZ-tKrZ-4AHJsbKLNsM63bZb4vEt9LxJc,154
+adafruit_blinka/board/beagleboard/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/__pycache__/beaglebone_ai.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/__pycache__/beaglebone_black.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/__pycache__/beaglebone_blue.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/__pycache__/beaglebone_pocketbeagle.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/__pycache__/beaglev_starlight.cpython-312.pyc,,
+adafruit_blinka/board/beagleboard/beaglebone_ai.py,sha256=-4ZWsFAqJXfkiWhUCNRkP7m03dovomsgdbceLdT-76w,4599
+adafruit_blinka/board/beagleboard/beaglebone_black.py,sha256=h90N2OCcE9nYqYwGL1t-DYT6krDybG2m-8WwB11JgV4,5598
+adafruit_blinka/board/beagleboard/beaglebone_blue.py,sha256=kiY3my53vRZbxf7nAYJ9xQ0gUwkoXURJyGuqH4wRv28,359
+adafruit_blinka/board/beagleboard/beaglebone_pocketbeagle.py,sha256=O8rUJd09xVXrMygiOG7AU3pjcwyQDgn-jSmL1ijJjFw,4582
+adafruit_blinka/board/beagleboard/beaglev_starlight.py,sha256=VA2u28-hR8ac1dpmjUk8HkPcCqvwQRKLN3GTzeZrfhc,835
+adafruit_blinka/board/binho_nova.py,sha256=dg2g7HTYMPnILgYLtvatEaZ1pvTZrnf1h69_KFJhe7M,417
+adafruit_blinka/board/clockworkcpi3.py,sha256=nh7DGjZL5qxhj_lMPnV3x8JJLhAdlLZ-uOVbJ6LKy18,1048
+adafruit_blinka/board/coral_dev_board.py,sha256=WevyZSohoNC9R0qZGybDuvpJBoBgv5bkLH6tDlef94A,833
+adafruit_blinka/board/coral_dev_board_mini.py,sha256=DaPwzx-nZgXbdiiQ0J8qLxE1JlNj06sJ1MS66uGeGEs,1395
+adafruit_blinka/board/dragonboard_410c.py,sha256=yp1JjBiDDM9JdhLKi5U23Ez_nlM9M4zWkQ7r5LlvivQ,972
+adafruit_blinka/board/feather_can_u2if.py,sha256=cXKUO4ypBpxd7cU8tE7krDZ-xdM7SOyZADqBe7HmYJM,1484
+adafruit_blinka/board/feather_epd_u2if.py,sha256=jqfUXoRTFBiAfF7MTv-wgp7EyUdEQuTjAXkj6FlEOGU,1431
+adafruit_blinka/board/feather_huzzah.py,sha256=_xRgtV7yPXdFtWevnLr5B0bc-yqcT5ejaS3GwCaZ22o,647
+adafruit_blinka/board/feather_rfm_u2if.py,sha256=ShHQawz8J2_Kk-Uuv_kSpHQsmQa5wsTDIQmrVuu9qac,1486
+adafruit_blinka/board/feather_u2if.py,sha256=p4vCZfBfDz67bXY7h-jW_ceAzwoel35RtEoLChlPyDI,1220
+adafruit_blinka/board/ftdi_ft2232h.py,sha256=whZg1Medz5_hwYoq1qQh8kkxU-FXOHLw7OTWwpHP-IQ,789
+adafruit_blinka/board/ftdi_ft232h.py,sha256=QzbLi43Q94b2CwJTnHEdNGmOODlsZAAqGc3_M2T6FPQ,458
+adafruit_blinka/board/ftdi_ft4232h.py,sha256=213nj1afh2SRBLVUsStSh8cVnJKnaEb39ba0DhZa9y8,565
+adafruit_blinka/board/generic_agnostic_board.py,sha256=fWyqxUUYjm06Ijr0f6XmPthQ8YDDzGFlN545Drj98nA,873
+adafruit_blinka/board/generic_linux_pc.py,sha256=HQ-A3YNp54IXlBXVVR34zBJBc2MDCtwRlCqPDhn9VPI,165
+adafruit_blinka/board/giantboard.py,sha256=_otsz78DH2LjyxuoWo5LTShK8_d2ufftbC7oOrb_Ebo,784
+adafruit_blinka/board/greatfet_one.py,sha256=W_bjRw7biUvUYGeUyFyrHb_8oIq1Dnm1InZxubTM6Eo,1847
+adafruit_blinka/board/hardkernel/__init__.py,sha256=-PYWUqlVU6GQEETfbPorR-iTQcxnHsx2pKK7hZKzNe0,153
+adafruit_blinka/board/hardkernel/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidc2.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidc4.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidm1.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidm1s.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidn2.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/__pycache__/odroidxu4.cpython-312.pyc,,
+adafruit_blinka/board/hardkernel/odroidc2.py,sha256=3x2TopbyW5FqINsmbQsZ_mw7nAMH3sr0cytpY_HBwt8,1639
+adafruit_blinka/board/hardkernel/odroidc4.py,sha256=kXq4A0DFZ3HtW4MiwZqA3H81aYtUqiIG8s0BX6WjQx4,1269
+adafruit_blinka/board/hardkernel/odroidm1.py,sha256=h5CLswDTwSC2nBNHeG-L7DupLSgWiZyhBfCrlsyffCw,1000
+adafruit_blinka/board/hardkernel/odroidm1s.py,sha256=HGla4et0Zr2SyinvSXSKnd5SwjHKMgv2rK7MqNgAoSw,1103
+adafruit_blinka/board/hardkernel/odroidn2.py,sha256=a70gXVhL6_aQMzZyb4vNgwA88diPlSzBBy23sjIidRk,2048
+adafruit_blinka/board/hardkernel/odroidxu4.py,sha256=4-SFuPWIFOZVK5oAXl5zvekxzNu9gUNYadiiLxm7dnE,903
+adafruit_blinka/board/hifive_unleashed.py,sha256=wPnltQDvNoKNICDmzsKbzfWYIgipPPrOy3dte_zm44U,851
+adafruit_blinka/board/horizon/__pycache__/rdkx3.cpython-312.pyc,,
+adafruit_blinka/board/horizon/rdkx3.py,sha256=q7xbr4LIxQNstA49BuhnbGQNKBBHBo3YzAj6Kh1fRqA,767
+adafruit_blinka/board/itsybitsy_u2if.py,sha256=GE_m7S1ZDEW0GmoEDquDjnwzHpLh2jYhcE1GRzJ5puM,1351
+adafruit_blinka/board/kb2040_u2if.py,sha256=Dbiw5h0KQrpEYqV4bE9I2SbgQEPk2O-yM2nHgXhGeSQ,1264
+adafruit_blinka/board/khadas/__init__.py,sha256=FPNBqsJPsHCkp4WfPK7MaDzTqhfr5NksgM5DswqLzSs,149
+adafruit_blinka/board/khadas/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/khadas/__pycache__/khadasvim3.cpython-312.pyc,,
+adafruit_blinka/board/khadas/khadasvim3.py,sha256=Cp2uUheqVC-goW5UFWHUlok77A1QrglYizCQ9uhUmEU,2985
+adafruit_blinka/board/lemaker/__init__.py,sha256=oJqscrLv3JGVY8-_g203aClXq6l72sKu0s6fwsRJbcY,150
+adafruit_blinka/board/lemaker/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/lemaker/__pycache__/bananapro.cpython-312.pyc,,
+adafruit_blinka/board/lemaker/bananapro.py,sha256=vKh2D-ehC2vlsOWFvAEYS4jU2DPTUUr32Cqm9AyfFww,3787
+adafruit_blinka/board/librecomputer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/board/librecomputer/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/librecomputer/__pycache__/aml_s905x_cc_v1.cpython-312.pyc,,
+adafruit_blinka/board/librecomputer/__pycache__/roc_rk3328_cc.cpython-312.pyc,,
+adafruit_blinka/board/librecomputer/aml_s905x_cc_v1.py,sha256=ep3mIc57FSDhEvRdLpV9fIntqR8gHutYeBg4xZP9S20,1307
+adafruit_blinka/board/librecomputer/roc_rk3328_cc.py,sha256=u_bmIpMEAVCjj1Y5fRXefCZUs-VO1mK_GpodJAmmLpM,1153
+adafruit_blinka/board/lichee_rv.py,sha256=gQio9fsip3deYP87H_TS3tf7hI5AKGv8MuP4YmxQ83k,764
+adafruit_blinka/board/licheepi_4a.py,sha256=ZWgiMLTJqeCPQVD93t3LKh1NVN4I_4IFv1pPZrit4GE,739
+adafruit_blinka/board/linksprite/__init__.py,sha256=vp_0eCnvrRMk88r1vW_OrUkNBMXdYUXraqSuT45X-0c,174
+adafruit_blinka/board/linksprite/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/linksprite/__pycache__/pcduino2.cpython-312.pyc,,
+adafruit_blinka/board/linksprite/__pycache__/pcduino3.cpython-312.pyc,,
+adafruit_blinka/board/linksprite/pcduino2.py,sha256=t7Y7hRZBo1mgcEcn-Mgy9RWhjwj_hqVrdwSsp33MeQ4,1253
+adafruit_blinka/board/linksprite/pcduino3.py,sha256=iLoxH07NVg3pqGRcut_2PTOQhHX2JlmabubgTB4YSmI,1107
+adafruit_blinka/board/lubancat/__init__.py,sha256=Zf2uJ08dlYPYxzfxQ5mMkXcTxseSMD8x89F5IfYF24U,151
+adafruit_blinka/board/lubancat/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat1.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat2.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat4.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat5.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat_imx6ull.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat_stm32mp157.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/__pycache__/lubancat_zero.cpython-312.pyc,,
+adafruit_blinka/board/lubancat/lubancat1.py,sha256=nbL7u0DAAgPgk9FZRg8Sju6scpMvXhTJQjYVltsA3FM,1482
+adafruit_blinka/board/lubancat/lubancat2.py,sha256=FjEhhmuoAje-1etsXsNmnS3CBUhj5S1jXdllfE3o6j8,1563
+adafruit_blinka/board/lubancat/lubancat4.py,sha256=HVTsaaVMn2Xv1ejIF1U1FhF6_3kgfpI1AIZDuFrjBiQ,1767
+adafruit_blinka/board/lubancat/lubancat5.py,sha256=gtpgxoN2vslf3lDF8jYH3Rbuv220hkrDeywhCotHzPQ,1591
+adafruit_blinka/board/lubancat/lubancat_imx6ull.py,sha256=IXK7Ur-QTq-VG9UFlj82VSEbNw2_HRiEQwohdtJdIto,1751
+adafruit_blinka/board/lubancat/lubancat_stm32mp157.py,sha256=SaU6nW_WSFPEIEgsiijTZigxSp1S17-Sidh5IcymDUI,1537
+adafruit_blinka/board/lubancat/lubancat_zero.py,sha256=TlHHoCYu6be-Cic3BQL40oJX_9tlz0CVwZ6BL2pWaec,1495
+adafruit_blinka/board/luckfox/__pycache__/luckfoxpico.cpython-312.pyc,,
+adafruit_blinka/board/luckfox/__pycache__/luckfoxpico_max.cpython-312.pyc,,
+adafruit_blinka/board/luckfox/__pycache__/luckfoxpico_mini.cpython-312.pyc,,
+adafruit_blinka/board/luckfox/__pycache__/luckfoxpico_plus.cpython-312.pyc,,
+adafruit_blinka/board/luckfox/luckfoxpico.py,sha256=tDDNbFJaoSPaqE_7sQYNug8esgDhtmVa2YJL7hiRRgg,1340
+adafruit_blinka/board/luckfox/luckfoxpico_max.py,sha256=Gy_Ji7zRi8pK0vR9NvN8Wf_Yg7JHXHoGW2AuWTkqIY4,1381
+adafruit_blinka/board/luckfox/luckfoxpico_mini.py,sha256=BzcANpBwdMs_PFv9G0P9HxLyME3h6bvZecjqrnKuAMg,1174
+adafruit_blinka/board/luckfox/luckfoxpico_plus.py,sha256=_OqT0lhrlU1pxgRlCFjHkCygPl4HU-JkqDxFNTU2zUo,1363
+adafruit_blinka/board/macropad_u2if.py,sha256=wTXpVKTDb4ov7n7GQYMPXKlTHejFz5_eWGxnBiP-g34,1454
+adafruit_blinka/board/microchip_mcp2221.py,sha256=-uPZQZfle5_4iB2ylcHN3gReSbZqWj5ykwe0yxQvqnA,295
+adafruit_blinka/board/milkv_duo.py,sha256=P_xLUzdgwnDIpi8W8B5Yrm0dxNcFPLc84unZObG1mQE,806
+adafruit_blinka/board/nanopi/__init__.py,sha256=3B1Z7hYACPToFK-bHMxmzvmGn2M1oQvf_XDfm0PFN0E,149
+adafruit_blinka/board/nanopi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/nanopi/__pycache__/duo2.cpython-312.pyc,,
+adafruit_blinka/board/nanopi/__pycache__/neo.cpython-312.pyc,,
+adafruit_blinka/board/nanopi/__pycache__/neoair.cpython-312.pyc,,
+adafruit_blinka/board/nanopi/duo2.py,sha256=Ed-CkB-hzN-9LIz9PBqOtBYhxeaFyMicfyPKhk9XtNg,573
+adafruit_blinka/board/nanopi/neo.py,sha256=6w_2EBFrP55bN1-XCPwtqtUo-yj6fBTMvFgw_M4QxtA,846
+adafruit_blinka/board/nanopi/neoair.py,sha256=6w_2EBFrP55bN1-XCPwtqtUo-yj6fBTMvFgw_M4QxtA,846
+adafruit_blinka/board/nodemcu.py,sha256=5BpaWQJ59FpSRHdEPGIMPFCTwEstr-f74AoPw5uyxOc,694
+adafruit_blinka/board/nvidia/__init__.py,sha256=oMuz9rKClk1dFbCOyEi1Qe1YkhLa4YTk0n-aRQwpagU,149
+adafruit_blinka/board/nvidia/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/clara_agx_xavier.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_nano.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_nx.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_orin.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_orin_nx.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_tx1.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_tx2.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_tx2_nx.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/__pycache__/jetson_xavier.cpython-312.pyc,,
+adafruit_blinka/board/nvidia/clara_agx_xavier.py,sha256=YfqchUj2Q2cAy-by2XazeQFEahLI8DllKvCPiiP13w4,652
+adafruit_blinka/board/nvidia/jetson_nano.py,sha256=GIMNnBHNaMt8csjSEJBsNyuWkpuOp6M3_kievldktq8,719
+adafruit_blinka/board/nvidia/jetson_nx.py,sha256=SfcnRby1N6CVM08NIyXY_WW46r1IxZDOrxR8oa17-bo,640
+adafruit_blinka/board/nvidia/jetson_orin.py,sha256=bIhAJj1qz3Bi2MHQPXCAb5OC0mKgTMJ7xEXdOp_yUNI,704
+adafruit_blinka/board/nvidia/jetson_orin_nx.py,sha256=HhtDtKkjDdKeJZsnKMsbhFhkUaBLNBS0vE-zRIolxAc,712
+adafruit_blinka/board/nvidia/jetson_tx1.py,sha256=eD1dMq4YV_jLro7kFjTXzuK6HkLuqElCiJjrFaKIGMY,642
+adafruit_blinka/board/nvidia/jetson_tx2.py,sha256=q3aQgtHXiuJN3nGm8UYkHk26Opkg0H_YYxcRCfcwb74,642
+adafruit_blinka/board/nvidia/jetson_tx2_nx.py,sha256=4uuR2TdG1xzRY__yXhlwdj3OFolECSxFwH9UOVD_slU,644
+adafruit_blinka/board/nvidia/jetson_xavier.py,sha256=0tJIccuAfbJZor2TDsXorDvm24a63KA8Ie9sAsvbIDA,649
+adafruit_blinka/board/onion/__init__.py,sha256=O8pRGz7qUm_r-Dv_8QM6h-s4Q-_floGDdoRisZ5WHUk,148
+adafruit_blinka/board/onion/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/onion/__pycache__/omega2.cpython-312.pyc,,
+adafruit_blinka/board/onion/omega2.py,sha256=Ecj4J_wXeawee6Nac1ScazyGQdpDkA-3_8nQftcDsR8,713
+adafruit_blinka/board/orangepi/__init__.py,sha256=AlwNbq_1J7jHRR9y3MRMB7oc6_QkRGWpjBbFTRRI5P8,160
+adafruit_blinka/board/orangepi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi3.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi3b.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi3lts.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi4.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi5.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepi5plus.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepipc.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepipc2.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepir1.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepizero.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepizero2.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepizeroplus.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/__pycache__/orangepizeroplus2h5.cpython-312.pyc,,
+adafruit_blinka/board/orangepi/orangepi3.py,sha256=rnJgsm_aZmKI1_CADcw-T_PZfWsGw-5ZIbpPYyq_9cw,630
+adafruit_blinka/board/orangepi/orangepi3b.py,sha256=lrWw1qNaed4bnMW-M6o6Lzxl3TuXd7V6FmvnKFg3hTY,1627
+adafruit_blinka/board/orangepi/orangepi3lts.py,sha256=y-2az63y-DlcbifrviMu6UNHgjA-VM9mml6GsTNm7PY,634
+adafruit_blinka/board/orangepi/orangepi4.py,sha256=znp3mcuiByc7ilworP7eVIkzjH2kp7DmQJfYR4T9OzY,3607
+adafruit_blinka/board/orangepi/orangepi5.py,sha256=TKQrIEoSzLY_FzByiXomQEXrkat811QhxnoQN2uE190,1311
+adafruit_blinka/board/orangepi/orangepi5plus.py,sha256=jDZnqFH5P8ti1il4S6n7LZ71LpXFE8SYIC597Nev7Pw,1851
+adafruit_blinka/board/orangepi/orangepipc.py,sha256=O6JxRxKooaFtYwUK5EfS3VPXH9-mnLC9co39ofYGLD4,793
+adafruit_blinka/board/orangepi/orangepipc2.py,sha256=3PDjD3Kx-3eJjSprx3M87Qgc2EpwfpdRUHZT6tbuKh0,777
+adafruit_blinka/board/orangepi/orangepir1.py,sha256=d9tTCnymzpsqy6ZFfYJ3eNcEzN8BFrr7y3NKIsfaefw,734
+adafruit_blinka/board/orangepi/orangepizero.py,sha256=pBhZ2uW3bEQPMP3zDkLIpJsqriNPhgdaX6HryGeHqXo,802
+adafruit_blinka/board/orangepi/orangepizero2.py,sha256=MPVsqzuK6na_UVhZ-MvotUaljb1SXF4At3d4oMqi0iw,659
+adafruit_blinka/board/orangepi/orangepizeroplus.py,sha256=x8nCWS-rAHlVOQvrhc7754KKH58L80fku3Sf3DpeEC8,772
+adafruit_blinka/board/orangepi/orangepizeroplus2h5.py,sha256=kBSVBCHR0-0Hhw2a0bhXaFlkwwVR6ooLU37bsRDbZQw,710
+adafruit_blinka/board/pico_u2if.py,sha256=My1sX_3siyopJnhizeSbD1PUsH_OlaoidBm1xtrLFXc,981
+adafruit_blinka/board/pine64/__init__.py,sha256=2g5wpsZUfAhsHZVRn07LH-AX4-wk2SlcGgo2fYbLrqU,112
+adafruit_blinka/board/pine64/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/pine64/__pycache__/pine64.cpython-312.pyc,,
+adafruit_blinka/board/pine64/__pycache__/quartz64_a.cpython-312.pyc,,
+adafruit_blinka/board/pine64/pine64.py,sha256=RbWGqFLBHqvAVfwFSa2O_B6FYOIWhjcj-qKw3dqlnNk,788
+adafruit_blinka/board/pine64/quartz64_a.py,sha256=EEqvhM7n9_Yvzn69JcpG_tFkyFBFEVqw9dc0Nr7qYSY,717
+adafruit_blinka/board/pineH64.py,sha256=Ro4_scT0-sun2JPcm5-2X4nfSk-esfAAH_HnjuZxcDM,675
+adafruit_blinka/board/pyboard.py,sha256=oBKkuJcpv73ftg6ySGnA-AO158uBqIQfGTPJi-2Gvps,896
+adafruit_blinka/board/qt2040_trinkey_u2if.py,sha256=Np8uZ8vUKqaYlRJSprKGBlG84nhemSK8bFI9f6XAL24,445
+adafruit_blinka/board/qtpy_u2if.py,sha256=xoi0sCIDzA7BhmrWxfustt0hMxdveDAsA0hfTpFSet4,1299
+adafruit_blinka/board/radxa/__init__.py,sha256=K2BxqGGcHui_nRk34EtRjbWfUFJoIzrruS7IOXkdhIY,156
+adafruit_blinka/board/radxa/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/radxacm3.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/radxazero.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/radxazero3.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rock3b.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rock5.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rock5c.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rockpi3a.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rockpi3c.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rockpi4.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rockpie.cpython-312.pyc,,
+adafruit_blinka/board/radxa/__pycache__/rockpis.cpython-312.pyc,,
+adafruit_blinka/board/radxa/radxacm3.py,sha256=-er4WibbewrPZ-0Y-wOiT3DVIist9scyPDLhLT2PBqk,2124
+adafruit_blinka/board/radxa/radxazero.py,sha256=m3ON3u7L7dNCb6xtxdBboesVKxSw07bDeUKn3WEdgLI,857
+adafruit_blinka/board/radxa/radxazero3.py,sha256=g5mx1qxcQZlxyERK5VgyPBxQ-PHvEzkUh4HVLPnLivE,1171
+adafruit_blinka/board/radxa/rock3b.py,sha256=LwgpoQUTgAY5iFGUIP_hCzaM32ozAcKMV2nu7nMNWXI,948
+adafruit_blinka/board/radxa/rock5.py,sha256=yNdMefkPHoI9c7-HOWQKTMPeBXXgmjXA7qOjRk3ANME,2465
+adafruit_blinka/board/radxa/rock5c.py,sha256=MOPzYT-vunAyoZ17wwI60BWwBPwdzcsRrxCSpdtMs64,2925
+adafruit_blinka/board/radxa/rockpi3a.py,sha256=CffA4XLyK_UH2b-H74nGMrTIm-JIpbzuqY34FZX24XU,1513
+adafruit_blinka/board/radxa/rockpi3c.py,sha256=r8GL9AJrGuK4Dxx1koZJWu8RTLNUu8YFMWHvoEoqj94,1129
+adafruit_blinka/board/radxa/rockpi4.py,sha256=6vTty9Q5LRhICn0rmLGT1O5ZrNymqXlNQRF2y6NvDEo,1096
+adafruit_blinka/board/radxa/rockpie.py,sha256=BeNilV6XQxa9urhlaFeZCUuQ4oYwlDnAetk-AZxMpSw,1500
+adafruit_blinka/board/radxa/rockpis.py,sha256=96ne9jWxzJmmV8P4-T-edBH_R9SN31yWpOWfssHAy_c,999
+adafruit_blinka/board/raspberrypi/__init__.py,sha256=apZ0b0uyIcb8QFCn5Wl8IGYRAxLnE-DxZelJh_QY_nA,155
+adafruit_blinka/board/raspberrypi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/pico.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_1b_rev1.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_1b_rev2.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_40pin.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_4b.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_5.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/__pycache__/raspi_cm.cpython-312.pyc,,
+adafruit_blinka/board/raspberrypi/pico.py,sha256=Sy8iobMIuSJjBRPsqQQD4VEKBPMgOrQ85O61x5RWIUg,765
+adafruit_blinka/board/raspberrypi/raspi_1b_rev1.py,sha256=_qrfxJVUWsHiGsKvlxiFTBxNsxgHeTUWsxQOlDpcpAI,667
+adafruit_blinka/board/raspberrypi/raspi_1b_rev2.py,sha256=VJcaSo9V71MsuEpPJ7GKj7K0QdcTjHqZgfn_DiaDrrk,667
+adafruit_blinka/board/raspberrypi/raspi_40pin.py,sha256=APNyA3mRi8aMt99lvatBlMGPoyxpAzxPwJpHnukbkDw,876
+adafruit_blinka/board/raspberrypi/raspi_4b.py,sha256=ohRDflMXMybpZN8Z5GLI4c9wt37-HTElGJnlgK1XP4I,889
+adafruit_blinka/board/raspberrypi/raspi_5.py,sha256=OqeLqBRCUrfV-B0BEahZqUgN6JudFTBArjc-9dsoXsc,889
+adafruit_blinka/board/raspberrypi/raspi_cm.py,sha256=1dqWpNri5uQt1E8QMBpFmwHWW6bdr9aTC4U-n8416mY,1172
+adafruit_blinka/board/repkapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/board/repkapi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/repkapi/__pycache__/repka_pi_3.cpython-312.pyc,,
+adafruit_blinka/board/repkapi/__pycache__/repka_pi_4.cpython-312.pyc,,
+adafruit_blinka/board/repkapi/repka_pi_3.py,sha256=EQwpiva5bqjcLKkv0W1EkdbtG9AsKRBOcxRLgaIzleY,1515
+adafruit_blinka/board/repkapi/repka_pi_4.py,sha256=StIajnEykxEmJSv61oJn4X7Zy-dE7HBBFZPhw8Ym-oY,1222
+adafruit_blinka/board/rp2040_one_u2if.py,sha256=yBSnnRTKRav_tJcVcPo_k0B9TVnKQ1mOzDle16wTAT0,1379
+adafruit_blinka/board/siemens/__init__.py,sha256=9wQJn9L_oGWjYMQnb1ypt3Qn-GN3O_gBeMP6adyqb8E,133
+adafruit_blinka/board/siemens/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/siemens/__pycache__/siemens_iot2050.cpython-312.pyc,,
+adafruit_blinka/board/siemens/siemens_iot2050.py,sha256=HGMUpDTXOsvhreJb6uOA4f5iECOr0Dc3zzGSfVysb9k,991
+adafruit_blinka/board/soPine.py,sha256=1Ilo95Fw2hJYdbk_7jSxrjLS57rFeLRTjV3s1WYN0hk,788
+adafruit_blinka/board/starfive/__init__.py,sha256=lzjWkQbeJrk-cmzhi0mnO8qeiZSd9l6WPlh6nQzgcig,134
+adafruit_blinka/board/starfive/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/starfive/__pycache__/visionfive2.cpython-312.pyc,,
+adafruit_blinka/board/starfive/visionfive2.py,sha256=BDR2p35IFDtZWoI3FHAKfOyUIrq1ecfw9DWse-MkRdc,671
+adafruit_blinka/board/stm32/__init__.py,sha256=c-0d6DvHBpcSKZxCR7mMeXZMwT-d99cGv9QWuuTt3-g,148
+adafruit_blinka/board/stm32/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/stm32/__pycache__/osd32mp1_brk.cpython-312.pyc,,
+adafruit_blinka/board/stm32/__pycache__/osd32mp1_red.cpython-312.pyc,,
+adafruit_blinka/board/stm32/__pycache__/stm32mp157c_dk2.cpython-312.pyc,,
+adafruit_blinka/board/stm32/osd32mp1_brk.py,sha256=u_RZPOGGBIffEfZhn8827a8vu091JZEjqxVM_v7RAKM,5364
+adafruit_blinka/board/stm32/osd32mp1_red.py,sha256=kgSgwkmOl9qpKAnoOkQn5b41kIFkS4viFR0gwLtvn7k,941
+adafruit_blinka/board/stm32/stm32mp157c_dk2.py,sha256=dkuHgQfc8wFsypxAr1n1ekSOibqjnVF8uCF8KxYSJw4,760
+adafruit_blinka/board/tritium-h3.py,sha256=XFQ4m35tkepZFEn0gS27kvL3aBomTimSfgdKaqbsMoM,756
+adafruit_blinka/board/udoo_x86ultra.py,sha256=birnNFZFnu9dRTQZKoG--LbhKtGw4o5JduDcFLiXZu4,1826
+adafruit_blinka/board/vicharak/__pycache__/axon.cpython-312.pyc,,
+adafruit_blinka/board/vicharak/__pycache__/vaaman.cpython-312.pyc,,
+adafruit_blinka/board/vicharak/axon.py,sha256=ev9v8Zq8qAz-ehv0UXqy5KUTpn1Dzx9_5M_WYtcp_x8,1339
+adafruit_blinka/board/vicharak/vaaman.py,sha256=n2mgV8gl5VpGc1aMkHIVag420wGE0Y_A6fWCE1QSjR4,906
+adafruit_blinka/board/vivid_unit.py,sha256=gWJhgb2Hq16J09DWxQ_aYFKfTdSUP9RIARgglAfhWWM,1152
+adafruit_blinka/board/walnutpi/__init__.py,sha256=HpQkQRA-2Cl7389IERUIgE5DCASYSUxuAKzOxcnDLLo,151
+adafruit_blinka/board/walnutpi/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/board/walnutpi/__pycache__/walnutpi1b.cpython-312.pyc,,
+adafruit_blinka/board/walnutpi/walnutpi1b.py,sha256=vyajN6CUA54nbc5IQrdY5nb6-Y8H7juYMEXtQsN9-40,861
+adafruit_blinka/board/x86j41x5.py,sha256=BiQC0DcXJ-hfHhHdSTseFykxs5nJ-tbO_hi0GwQ1De4,840
+adafruit_blinka/microcontroller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/__pycache__/alias.cpython-312.pyc,,
+adafruit_blinka/microcontroller/alias.py,sha256=AWGTzgWfU4wPWlWTM3An-ma5ybMmOttRy19qFJ-hbyo,1107
+adafruit_blinka/microcontroller/allwinner/D1/__init__.py,sha256=pQbuLoEazWS2sWJNDkJE55F4HVqEbRRN8bdvkw9jWMg,149
+adafruit_blinka/microcontroller/allwinner/D1/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/D1/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/D1/pin.py,sha256=0_1ubBtZgQn-wth_59ZkZ5GEP6JSSQsCY8_3itTRNS0,1880
+adafruit_blinka/microcontroller/allwinner/__init__.py,sha256=Y1J80-zqqh-_D-mGwASK31hBqAWepGpg9Ter4zV07pE,153
+adafruit_blinka/microcontroller/allwinner/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a20/__init__.py,sha256=ZoouDSdlo-I6MVa7c5cYV9zEONpAt2boVdAnyAMdDxI,157
+adafruit_blinka/microcontroller/allwinner/a20/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a20/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a20/pin.py,sha256=wpEyTv81B9HLbRUxpamUBueLFnxd7cbvltm1ldJl3Lc,2901
+adafruit_blinka/microcontroller/allwinner/a33/__init__.py,sha256=iMRDKlgRD4dkujNy4bC0oapqAwLAiqXvGRbBsIXfrpk,157
+adafruit_blinka/microcontroller/allwinner/a33/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a33/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a33/pin.py,sha256=-WNR-GiUItT1PUgS9I0HtEZm2tON1oVylaCl5eyWOwE,1118
+adafruit_blinka/microcontroller/allwinner/a64/__init__.py,sha256=24lqgbULhG68JmHe9kMwC3-srJrNqa_pcyCa4NK7btA,157
+adafruit_blinka/microcontroller/allwinner/a64/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a64/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/a64/pin.py,sha256=uhKew4XZHhnt0KgwuUeS_DJ-AN11rZfEBHcj5XJSwDg,1785
+adafruit_blinka/microcontroller/allwinner/h3/__init__.py,sha256=WPukV4agF7vSpLgZLWGIN4AKQXotgOJF_-xKlxzJAQc,156
+adafruit_blinka/microcontroller/allwinner/h3/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h3/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h3/pin.py,sha256=cHS4fdVnAV2n9GCm92_orgY3TYQzRGUAmwy0BFAhdog,1254
+adafruit_blinka/microcontroller/allwinner/h5/__init__.py,sha256=ln-NIylI35Ju9rXDBvIYeNNSx7XQ9vdz03StRMOW8vo,156
+adafruit_blinka/microcontroller/allwinner/h5/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h5/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h5/pin.py,sha256=6KFLZMlHgxQBRInFmEJjNVJerx-QrY-N6yl7Sh2Alak,1488
+adafruit_blinka/microcontroller/allwinner/h6/__init__.py,sha256=11_b_whLOkzEsfMy4U1bSlDX9pYyuf429nmb_bvqA7E,156
+adafruit_blinka/microcontroller/allwinner/h6/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h6/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h6/pin.py,sha256=o9Cof9gXpaZ0shTWyUHJbh0IgzqSMOl1ekBDU5TTtwk,1107
+adafruit_blinka/microcontroller/allwinner/h616/__init__.py,sha256=UtdnyzqeOG4Fb8oHbP6EADCKEhRwVoWaVXo2INhu54M,158
+adafruit_blinka/microcontroller/allwinner/h616/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h616/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h616/pin.py,sha256=JMW1ESsT6oPJA7Hp9kJwQVs9_hBdefeu5e3RsW3U60Y,3153
+adafruit_blinka/microcontroller/allwinner/h618/__init__.py,sha256=uv44e3GpPKx1-bJgJxzjdy0doUswNLF_OS7ayBa2CvA,158
+adafruit_blinka/microcontroller/allwinner/h618/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h618/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/h618/pin.py,sha256=GmvwraojmJbqxtTRzkqBqxnat9NP3TYTEoygcUAwYgQ,4011
+adafruit_blinka/microcontroller/allwinner/t527/__init__.py,sha256=EG1hItSusOKB_W1UOzeN9cO8tsdQMN0dqEtHHR36ljo,158
+adafruit_blinka/microcontroller/allwinner/t527/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/t527/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/allwinner/t527/pin.py,sha256=uYDz-yseOnRq7xXHkjTUg2V_u9DtA_nKXp37ftK8Hjw,7648
+adafruit_blinka/microcontroller/am335x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/am335x/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am335x/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am335x/__pycache__/sysfs_pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am335x/pin.py,sha256=qzcru8U0A-lVrtAfu-LYm06sgzUNf87iD6WU6AtPGWY,11328
+adafruit_blinka/microcontroller/am335x/sysfs_pwmout.py,sha256=Y5Un0pFxL-KzInvNDFlwN0rxv3KKWLXfex8DfuBJ0I8,10443
+adafruit_blinka/microcontroller/am65xx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/am65xx/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/__pycache__/analogio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/__pycache__/pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/am65xx/analogio.py,sha256=pvxhKRVhEE74xhYMaWU3m6pXs1eFV6youQ2zcR4kIXs,1470
+adafruit_blinka/microcontroller/am65xx/i2c.py,sha256=CoDIHGZbCNkUp54pKnkhY-YwFtLxzZDZmZojWhIIB_I,3006
+adafruit_blinka/microcontroller/am65xx/pin.py,sha256=mvI5Uz991yeiSm-qZ3iKf0DPWpVs8M5YDbsQn-5y3vo,5198
+adafruit_blinka/microcontroller/am65xx/pwmout.py,sha256=TOaY1Az7Ii2vk5Sb_IKNwOIEzuYWh0TlyIZtmOEXCnk,5250
+adafruit_blinka/microcontroller/am65xx/spi.py,sha256=m4oVAMVHC6633xc7adGjeQt_OFZqq6bijNEQwATbf3Q,4372
+adafruit_blinka/microcontroller/amlogic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/a311d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/a311d/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/a311d/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/a311d/pin.py,sha256=o6OcZf53ZIV-cMoKUDNejvxg-xy5ju5AjVRU3qHNOKg,6706
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/PulseIn.py,sha256=ZA-onxIMJGFHKD2XxwVjt3hrrojzbkfdlvHGPOFZii0,6171
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/__pycache__/PulseIn.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein,sha256=kRojwle4tzo0LpBoGW4pccqI7Y8oFk9ZtF627mwQg_w,20372
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein.license,sha256=lu6UbVXdYmAXgHbHvkjDb5WYAPKoZcdb1InK-GoVgtE,113
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein64,sha256=qPBI_Jg4NVgiqkf7WDXtdOZn6yXjQhaYyGumDRNCu5s,25832
+adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein64.license,sha256=lu6UbVXdYmAXgHbHvkjDb5WYAPKoZcdb1InK-GoVgtE,113
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pin.py,sha256=qWp7S_r8Zx5Ia2Oz4ezB6skyI7b41swJsTwRkSg5Rqc,7156
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/PulseIn.py,sha256=36Lu8PywzYAExSTILiJH1tzyBXBonFnkAtHMbzA0vxc,6211
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/__pycache__/PulseIn.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/libgpiod_pulsein,sha256=MaJiUVA-oXNR93fsGBpMs-zpYSSSB8h8sXr1WoeS4ps,25216
+adafruit_blinka/microcontroller/amlogic/meson_g12_common/pulseio/libgpiod_pulsein.license,sha256=UpaQW3I-925TXZF5zQ8olRBfev3bNy90FO17W0SpTXc,102
+adafruit_blinka/microcontroller/amlogic/s905/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/s905/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905/pin.py,sha256=oh7i-SvUO4BLG4KWdSSFnGu1_WOEH3-I5fJYZYg28iI,2036
+adafruit_blinka/microcontroller/amlogic/s905x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/s905x/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905x/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905x/pin.py,sha256=Sh9dzfaq-It8I4B-jhc_IrzDCQ6oIOZkGu__O2qROGs,1620
+adafruit_blinka/microcontroller/amlogic/s905x3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/s905x3/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905x3/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905x3/pin.py,sha256=Tuq5fAGl1fv4v1n2ZNL7dwCXiRmrnpzcL1RlaEHDALk,276
+adafruit_blinka/microcontroller/amlogic/s905y2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/s905y2/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905y2/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s905y2/pin.py,sha256=x2LOt3nzJ24xl775POGb1z5FGtdS5WXDa04EhtOwSe0,1778
+adafruit_blinka/microcontroller/amlogic/s922x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/amlogic/s922x/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s922x/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/amlogic/s922x/pin.py,sha256=S2tBpl0hJr6iCSIIVJARFhdXvdc_LQpkyiIwpeBin-U,275
+adafruit_blinka/microcontroller/atheros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/atheros/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/atheros/ar9331/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/atheros/ar9331/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/atheros/ar9331/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/atheros/ar9331/pin.py,sha256=wg-CWxypeoukHuOJYKdo7hw1BM3ggUMU7JpNP6g_70s,1224
+adafruit_blinka/microcontroller/bcm2711/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/bcm2711/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm2711/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm2711/pin.py,sha256=l6Hr1XGnzt8rHeYNhH5h-SWg5BM9IoLvpFGCKetmKNs,1804
+adafruit_blinka/microcontroller/bcm2712/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/bcm2712/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm2712/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm2712/pin.py,sha256=8hjqNaPvIgVww-_-kFvczW2goaoA0PJzyT6shWkRB-0,1798
+adafruit_blinka/microcontroller/bcm283x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/bcm283x/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/__pycache__/neopixel.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/__pycache__/rotaryio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/neopixel.py,sha256=a5F2obV639-TrDj8rbGTEZnEZed4JrULjnh4IRtwssg,5252
+adafruit_blinka/microcontroller/bcm283x/pin.py,sha256=DlSrw7vneNIZq0KEfav_C5pPDBY6nWudIr3eD3jPQTw,1690
+adafruit_blinka/microcontroller/bcm283x/pulseio/PulseIn.py,sha256=GuBB53Q8sZBKfz3FSOgPy-4qf31ZWtF6qlcFiGN6bAM,6317
+adafruit_blinka/microcontroller/bcm283x/pulseio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/bcm283x/pulseio/__pycache__/PulseIn.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/pulseio/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein,sha256=uqiXM-_mZV8oOV16noHJgdA78PS3RWVxeCWV_fuwanw,20448
+adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein.license,sha256=lu6UbVXdYmAXgHbHvkjDb5WYAPKoZcdb1InK-GoVgtE,113
+adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein64,sha256=rX5l-18nJWRpzJEe1aLS5Iz0qFmi_yacl9f2UJIsAjg,25832
+adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein64.license,sha256=lu6UbVXdYmAXgHbHvkjDb5WYAPKoZcdb1InK-GoVgtE,113
+adafruit_blinka/microcontroller/bcm283x/rotaryio.py,sha256=FbEqdztTRKiTY6mmiRW7Hxay8_UClRxBCenKUX3sMQc,6511
+adafruit_blinka/microcontroller/cv1800b/__init__.py,sha256=6BGssOqFeSmWCaV4bH2aXukuLQbCcUo1c2tocByZsOw,158
+adafruit_blinka/microcontroller/cv1800b/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/cv1800b/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/cv1800b/pin.py,sha256=lQfOQgxXwFT_7ZaK2XvCefekKZdCCJByHKtLzBSORL4,983
+adafruit_blinka/microcontroller/dra74x/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/dra74x/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/dra74x/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/dra74x/pin.py,sha256=LEW8oOGxikXkEkf_jy3kzYvA7oUNpv9JfiyEvz8U1CU,5715
+adafruit_blinka/microcontroller/esp8266/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/esp8266/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/esp8266/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/esp8266/pin.py,sha256=UtmCV_m_UCGMo6aVgG_g8CWuWSrMukpVvmIzoeOj2io,668
+adafruit_blinka/microcontroller/ftdi_mpsse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/ftdi_mpsse/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/pin.py,sha256=oSwlmnbkl0KjvcoyoQ7hLPM0hH7Chtc8oYKWn_Lr2KA,1467
+adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/pin.py,sha256=nwMFrcy5uzRDcGdchNw2656MjAZegDLZGYdlnto_CTM,536
+adafruit_blinka/microcontroller/ftdi_mpsse/ft4232h/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/ftdi_mpsse/ft4232h/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft4232h/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/ft4232h/pin.py,sha256=Zf-w8VPznKIbdIJ5v-ageSf6dIc9esh0mCEizG7AJSs,991
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__pycache__/url.cpython-312.pyc,,
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/i2c.py,sha256=TC6dbftYw1OcdFieFTq6bJTlfLqMwkE81Zwnmkj2B_Q,2666
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/pin.py,sha256=RXYy_uTmEjCZH-t3AdkayMhUVWX1PU9_X2yCYSLJMuQ,2587
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/spi.py,sha256=nwQXijgL2iDGF1luWny8bHjFfOqrWNNT_ZjaVYdWOGg,3447
+adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/url.py,sha256=9JCESi2IEabkfvupIUt1myHXGd8TdEFGo0Tiqxbqi0g,1003
+adafruit_blinka/microcontroller/generic_agnostic_board/PWMOut.py,sha256=3dwH0B-qGk_YgSGsPAPkeOAY-bi0y8QM8J3HUKs5ApE,3831
+adafruit_blinka/microcontroller/generic_agnostic_board/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/PWMOut.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/analogio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/generic_agnostic_board.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/neopixel.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_agnostic_board/analogio.py,sha256=766PnV5dPiXtAG8sxAWyhn9_yW8MBOXTT07jgzuFcx8,1357
+adafruit_blinka/microcontroller/generic_agnostic_board/generic_agnostic_board.py,sha256=Xrg-ww3XNK6KUIzb_j0_BUY32SxDLcY__Jg67Z6sxeQ,556
+adafruit_blinka/microcontroller/generic_agnostic_board/i2c.py,sha256=S1T3Tzb49y30R0T2J6XSpgKk-S-pXjq1cBf_1Vj__Rg,815
+adafruit_blinka/microcontroller/generic_agnostic_board/neopixel.py,sha256=GCJwhUwhY_QeQTF8kb1zr2vltxgunI6Ak1LtMAz_k0Y,501
+adafruit_blinka/microcontroller/generic_agnostic_board/pin.py,sha256=T5u-DKdOqOMRMDENkbo3pg-Unl7lMlEpMd4XZObUbN8,5567
+adafruit_blinka/microcontroller/generic_agnostic_board/spi.py,sha256=eeMsr2DCmNcBT-tFRuJoxWM7olD83hFHgunngOzURLo,1520
+adafruit_blinka/microcontroller/generic_linux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/generic_linux/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/lgpio_pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/lgpio_pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/libgpiod_chip.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/libgpiod_pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/periphery_pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/rotaryio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/rpi_gpio_pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/rpi_gpio_pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/sysfs_analogin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/sysfs_analogout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/sysfs_pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/__pycache__/sysfs_pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/i2c.py,sha256=ExnBKW6QR6llKlKLd6-6dgn_6ahD2J1JtbmcRY0LtnY,3181
+adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py,sha256=kK6jgmB_c_AweSmiSpa1TGGjMO1VCz5KNK5MK-OlTUI,3983
+adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py,sha256=kChMmGCCfuOc-esLVjmx5vKWRz2Z_RviItzLHWGKkiA,4673
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__pycache__/libgpiod_chip_1_x.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__pycache__/libgpiod_chip_2_x.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__pycache__/libgpiod_pin_1_x.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/libgpiod/__pycache__/libgpiod_pin_2_x.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_linux/libgpiod/libgpiod_chip_1_x.py,sha256=XgKtEA__6CFefqUGxnKCxk2OjOA4I7TY5GyrsEZDAJU,868
+adafruit_blinka/microcontroller/generic_linux/libgpiod/libgpiod_chip_2_x.py,sha256=G55Me7ufzNlwNH1ODFNtj9dTB7PvD7UDfG-cU18BpZc,732
+adafruit_blinka/microcontroller/generic_linux/libgpiod/libgpiod_pin_1_x.py,sha256=ggcDXPoNV0oY7mepLpbHUcFN4Mo7BfilajqNiTnmFvw,4912
+adafruit_blinka/microcontroller/generic_linux/libgpiod/libgpiod_pin_2_x.py,sha256=yyiyjh30chSqoItkNsdu092TLAkZ32RKdz7b4petPMo,3224
+adafruit_blinka/microcontroller/generic_linux/libgpiod_chip.py,sha256=Ha54h6thhpA8H9oDoR5AnVxgG9GF-URDpdkVmVK8TyY,767
+adafruit_blinka/microcontroller/generic_linux/libgpiod_pin.py,sha256=H6gHZ5ByMkaGcrMUojArswKtdglw6ZelA3CBs9oXxAw,762
+adafruit_blinka/microcontroller/generic_linux/periphery_pin.py,sha256=chCRjTNBeIK51wNfSrq4rxHxUd8GhR9HijgQjPT0Ym8,2781
+adafruit_blinka/microcontroller/generic_linux/rotaryio.py,sha256=IGTx1E9tA0EVugd2GmkN2OzKzdwOZ6vxHXN-8SvlEgk,5038
+adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py,sha256=MCbWJpYoy914p63VD9g9P2fPBdHDonyX6xcYOkoVsIw,2002
+adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pwmout.py,sha256=ho5lr5Yg_KchuqluKgddEzcOxB7yTdXTMe3wQAEtZiA,4494
+adafruit_blinka/microcontroller/generic_linux/spi.py,sha256=PRDh5kkrZUicXwgRUwm5PpTj3_xIP1cuOotfGL90XEk,4462
+adafruit_blinka/microcontroller/generic_linux/sysfs_analogin.py,sha256=i3JxF1QBAvSwsO5GD2-nr6u9XvwlxUXrLLsYRfBmixc,2780
+adafruit_blinka/microcontroller/generic_linux/sysfs_analogout.py,sha256=KxJUIlyzOhE7eQgvDV-GNMtbT2sECcHbUlk9gtuGMrI,2708
+adafruit_blinka/microcontroller/generic_linux/sysfs_pin.py,sha256=gWPS3ky0EiIxvuVhWqmb2D6iaVbojYZJ-rb0SICjgj4,10891
+adafruit_blinka/microcontroller/generic_linux/sysfs_pwmout.py,sha256=PerErKoEHb08Na61mXcxylQnG2uyH1TgSQPuNQ4yeNY,11023
+adafruit_blinka/microcontroller/generic_micropython/__init__.py,sha256=pTx54EcyfWW1Og6vxyLeBch2FFs2uTRt2kyE_pd_xXM,1091
+adafruit_blinka/microcontroller/generic_micropython/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_micropython/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_micropython/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/generic_micropython/i2c.py,sha256=I2Evb0RwlmZmT2D4U2NDyplu4GBvvwQjz6EcFeyuglk,1473
+adafruit_blinka/microcontroller/generic_micropython/spi.py,sha256=AMvjLP4BG7f8H60daUcDyIJVcesAn42cYEft-hqWPJE,1869
+adafruit_blinka/microcontroller/hfu540/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/hfu540/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/hfu540/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/hfu540/pin.py,sha256=Xu-TgsZ65bPJHZ48uRNMo9HIUPfQoc7oJ9XrAkp9Ysk,891
+adafruit_blinka/microcontroller/horizon/pwmio/PWMOut.py,sha256=E8Z5F3AwXtcZXO36Nyz73kCWuhXeYWDxBGuEn5zcCOU,4764
+adafruit_blinka/microcontroller/horizon/pwmio/__pycache__/PWMOut.cpython-312.pyc,,
+adafruit_blinka/microcontroller/horizon/sunrise_x3/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/horizon/sunrise_x3/pin.py,sha256=JAobb_knAFkMjhp8DdN-97vnVmhocRs1pfiuGAyszWc,963
+adafruit_blinka/microcontroller/mcp2221/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/mcp2221/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mcp2221/__pycache__/analogio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mcp2221/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mcp2221/__pycache__/mcp2221.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mcp2221/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mcp2221/analogio.py,sha256=C7E5HXbjp3-44jXsAygKngFCC-sDNtAbPRMaDyyzp-8,1437
+adafruit_blinka/microcontroller/mcp2221/i2c.py,sha256=oFLZTGWy2nHEnUUoq8SZ1N1nwtqnf9eGIaOHIN1QNzI,1544
+adafruit_blinka/microcontroller/mcp2221/mcp2221.py,sha256=p8MtF53PxW8nRrwzK7KodDretFEUHqKqWvwrITS86oI,13674
+adafruit_blinka/microcontroller/mcp2221/pin.py,sha256=ycyPIR6rwFkfJ1d5dDRwfU1pqmcec3IdAjoPEkW1qXY,2883
+adafruit_blinka/microcontroller/mips24kec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/mips24kec/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mips24kec/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mips24kec/pin.py,sha256=0iutvzeuEfl8Izg1Or3QeCah481ABtqo7ZA3TIuABoA,1302
+adafruit_blinka/microcontroller/mt8167/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/mt8167/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mt8167/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/mt8167/pin.py,sha256=QAwKHB0wDcbqsyWtuhp1VyJGWZdGWIgvMXwYgbO9ayA,2028
+adafruit_blinka/microcontroller/nova/__init__.py,sha256=FmgXWzhOXRA9Grann9isQUxF2h1BN8MVTlEMC2HY_nQ,1129
+adafruit_blinka/microcontroller/nova/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/__pycache__/pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/__pycache__/uart.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nova/i2c.py,sha256=bGBCZilT7YTm2dART3eEmeNDzi_U5n4RvwvKVNMjAj0,6260
+adafruit_blinka/microcontroller/nova/pin.py,sha256=Bg9rLnJKCubz0EwAwy6WD8iSLOv-9cNgJZofxwvI-d4,2065
+adafruit_blinka/microcontroller/nova/pwmout.py,sha256=oQjCAxr2RmJpDZNwrJrK30Ze0e0Bn4Ws5SD3z5ct1eg,7201
+adafruit_blinka/microcontroller/nova/spi.py,sha256=sMPVlwPGIl-VJDIQEYSJwPp34_O7Lkua7P_B-S2z_x0,8491
+adafruit_blinka/microcontroller/nova/uart.py,sha256=lfdgSC3vJL7F8DglvZkDm4knmDU4N9TZTSVmevAlacE,2556
+adafruit_blinka/microcontroller/nxp_imx6ull/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/nxp_imx6ull/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_imx6ull/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_imx6ull/pin.py,sha256=zvRZLEoCgz6VkIFZWKFFX4V5YAPcPmm8AdvUEovVX7A,2149
+adafruit_blinka/microcontroller/nxp_imx8m/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/nxp_imx8m/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_imx8m/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_imx8m/pin.py,sha256=PZKoFxqrBf7vwzTBK5Y_Hm75KrflMT3LzMnpeQSoAfY,1214
+adafruit_blinka/microcontroller/nxp_lpc4330/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/analogio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/pwmout.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/__pycache__/uart.cpython-312.pyc,,
+adafruit_blinka/microcontroller/nxp_lpc4330/analogio.py,sha256=P7e0OM20r6wkMwrdp6V8ZCngA0Q3tOTRyKDDHNLaqrY,1441
+adafruit_blinka/microcontroller/nxp_lpc4330/i2c.py,sha256=dvZw_-XBBj613MFrRq0X_Ln5gT18nxdg5KfXhCeHxMU,1614
+adafruit_blinka/microcontroller/nxp_lpc4330/pin.py,sha256=wX5IjrSor8JfFe7yvC5ZB7UfD2BMLelathCOQ-gr5Gw,5450
+adafruit_blinka/microcontroller/nxp_lpc4330/pwmout.py,sha256=WPeavaU7Lxe3BJaPfhYnbgOtVF6npCvO73aWgLVpWJo,6735
+adafruit_blinka/microcontroller/nxp_lpc4330/spi.py,sha256=SvpwPCYCf9PR_YpOBAGBQbhno4rMwPItAMWi3F8JQEw,4678
+adafruit_blinka/microcontroller/nxp_lpc4330/uart.py,sha256=h2qK0cUOKdHGQrcplbvekLVyHSfp_101aOLuBk3Z3tM,2000
+adafruit_blinka/microcontroller/pentium/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/pentium/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/pentium/j4105/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/pentium/j4105/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/pentium/j4105/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/pentium/j4105/pin.py,sha256=0jTP0QaNbqRxuThr4odWvqm-IpgcddXGEZ6hy9jwW5k,1314
+adafruit_blinka/microcontroller/pentium/n3710/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/pentium/n3710/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/pentium/n3710/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/pentium/n3710/pin.py,sha256=UgGvw8jai9lSiv0-jzb-3AYDRQrMY39RK2EpSCPgW_c,2249
+adafruit_blinka/microcontroller/renesas/__init__.py,sha256=rsZNYzFNHcR7zDrjhxmns8kehx6uPW3YOtMK6exs_i8,151
+adafruit_blinka/microcontroller/renesas/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/renesas/rzv2h/__init__.py,sha256=cZO46p8OvIqZnl0F4sPYqF9DkH4WPh4BsSOWjs-uYWw,157
+adafruit_blinka/microcontroller/renesas/rzv2h/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/renesas/rzv2h/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/renesas/rzv2h/pin.py,sha256=eBvPYrAs5lYBFkp2W-E7sxKtIjP18vLinUzx8xOnQYQ,3875
+adafruit_blinka/microcontroller/renesas/rzv2n/__init__.py,sha256=ndeaxmdVYhGmgC_NIkQCjNBbE0OnFx4TkH-RuFPflxo,157
+adafruit_blinka/microcontroller/renesas/rzv2n/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/renesas/rzv2n/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/renesas/rzv2n/pin.py,sha256=4eXLMVhQcqa1T0xEMxCTuyfDW-qbqXE6d6yXSqnw-Kk,3875
+adafruit_blinka/microcontroller/rockchip/PWMOut.py,sha256=llueFwmndWl52aXL348_hGjaxTHXgUKHKCvjIpgFmro,12729
+adafruit_blinka/microcontroller/rockchip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/__pycache__/PWMOut.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3308/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3308/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3308/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3308/pin.py,sha256=EPiNI-cXvt3bfOeWWvVriuRWOkOue_k2n3OcRwJgNNg,4936
+adafruit_blinka/microcontroller/rockchip/rk3328/__init__.py,sha256=pb23QZkdWqUNZQrotHSfQwIJ_6yxAXJ8jPFkitXSIy8,159
+adafruit_blinka/microcontroller/rockchip/rk3328/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3328/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3328/pin.py,sha256=U5NacEY7W890aiEr9I432H2cIQL293zmNtUykneJQ1U,3767
+adafruit_blinka/microcontroller/rockchip/rk3399/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3399/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3399/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3399/pin.py,sha256=DXajUEbR3hVrOtQYcrW1w2uJwQtV_JHojLw2H8659DE,5378
+adafruit_blinka/microcontroller/rockchip/rk3566/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3566/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3566/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3566/pin.py,sha256=xzW6o8JC7H0uMlSiIJbtivDlCH4YRk48R6GnEQNyqd8,6704
+adafruit_blinka/microcontroller/rockchip/rk3568/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3568/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3568/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3568/pin.py,sha256=dM4J7OIzPenIKFqugYGLeoqf-LsJZ75Azm420_kvb54,5510
+adafruit_blinka/microcontroller/rockchip/rk3568b2/__init__.py,sha256=oFMcYY3KXVnLQLCDC9muCvXz0A6cb-IhQvutmtNpfqw,96
+adafruit_blinka/microcontroller/rockchip/rk3568b2/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3568b2/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3568b2/pin.py,sha256=NXUgiaklXAkFJCiEOkqDU7_SaO3p4-VbhiaUTd0ZP7c,3217
+adafruit_blinka/microcontroller/rockchip/rk3588/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3588/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3588/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3588/pin.py,sha256=nx7LQWWI_lS6QbId4qLU3tJElXd2GBEralGPR8JF3zo,16310
+adafruit_blinka/microcontroller/rockchip/rk3588s/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rockchip/rk3588s/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3588s/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rk3588s/pin.py,sha256=GmVFnJqRK63SQMRwsYEtsXfSiiS6QD2w01vj59uF6vk,6989
+adafruit_blinka/microcontroller/rockchip/rv1103/__init__.py,sha256=xQfoJkhdXFJWFrvW3xstRGYI2jdZwwaZasV4fJx1myA,159
+adafruit_blinka/microcontroller/rockchip/rv1103/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rv1103/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rv1103/pin.py,sha256=Nes3dLq2NZcxIE7IijDqFyFec4jnacLhv2s3mNUBrts,5091
+adafruit_blinka/microcontroller/rockchip/rv1106/__init__.py,sha256=B4mjQg-cbLwmfb900_XQSOacnkAP9xB8jqsMzMv2LqA,159
+adafruit_blinka/microcontroller/rockchip/rv1106/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rv1106/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rockchip/rv1106/pin.py,sha256=Tefp2r52H-I9as0bJ6S36rPj7tWUrngbioxFwA_a1ZE,5849
+adafruit_blinka/microcontroller/rp2040/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rp2040/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040/__pycache__/uart.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040/i2c.py,sha256=Nok-jLZ4COCXqTNRiOE90KFGo7o7b4xbfzVgZz35POA,2032
+adafruit_blinka/microcontroller/rp2040/pin.py,sha256=XDAKGmwX8T8aqyuruiPxbEsop8MQrMtuxTM09nEYn58,4819
+adafruit_blinka/microcontroller/rp2040/spi.py,sha256=AnpOm2620qrdGWP-R0YRNyN466Mj-3JRrntJoD5Ve8I,2787
+adafruit_blinka/microcontroller/rp2040/uart.py,sha256=TmdfOdSXjFzowlDX0e6rUGHHq75lrbUgywD5PzujRUE,1643
+adafruit_blinka/microcontroller/rp2040_u2if/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/analogio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/i2c.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/neopixel.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/pwmio.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/rp2040_u2if.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/__pycache__/spi.cpython-312.pyc,,
+adafruit_blinka/microcontroller/rp2040_u2if/analogio.py,sha256=GSZN_kSq_rUYUAX4v7TC7FAhqeg45n_4cdwX7DzukUA,1984
+adafruit_blinka/microcontroller/rp2040_u2if/i2c.py,sha256=mNLjEuqh4bZYxuMlOf-kO5IBBF9sFyffiJdfc39yuiQ,5712
+adafruit_blinka/microcontroller/rp2040_u2if/neopixel.py,sha256=MV4CYEgKNscCmUA0CqI9tgMa5u7YW6DPOsvh5RZUE34,522
+adafruit_blinka/microcontroller/rp2040_u2if/pin.py,sha256=Pba8KW8h7aT7UtKDP1FzOXAyDTZ4zt7_Bj0SneATRGM,2257
+adafruit_blinka/microcontroller/rp2040_u2if/pwmio.py,sha256=0shXaflbOPtkgbDytx8q-r_-VkrFbkJB3D8YpdiZR-0,1342
+adafruit_blinka/microcontroller/rp2040_u2if/rp2040_u2if.py,sha256=iliM4lVhCWbkyAHinejMe7ys1OJv9vlTeKFEMkblFhQ,16641
+adafruit_blinka/microcontroller/rp2040_u2if/spi.py,sha256=fjSL5eDHeEMZXqhNPpM9dE975XdcpuHvGQ87SNahC4M,5008
+adafruit_blinka/microcontroller/sama5/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/sama5/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/sama5/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/sama5/pin.py,sha256=Han_erLLWKOYV4v73wdSFQjZVylNX2r3bcXoahvttFI,1074
+adafruit_blinka/microcontroller/samsung/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/samsung/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/samsung/exynos5422/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/samsung/exynos5422/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/samsung/exynos5422/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/samsung/exynos5422/pin.py,sha256=bnluZii5quhUL_2onQM0FgVIuNR5Y0uAGHjCRh0U1Rc,2326
+adafruit_blinka/microcontroller/snapdragon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/snapdragon/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/snapdragon/apq8016/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/snapdragon/apq8016/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/snapdragon/apq8016/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/snapdragon/apq8016/pin.py,sha256=7tuhDvXKoZIr3UI4h9hanKJvW-jpsfPD1f8cUWdSOgg,3581
+adafruit_blinka/microcontroller/spacemit/__init__.py,sha256=lHpQyWhJmyyhXHofXht5ZIaPagptKYh0UVLFhL3t5sY,152
+adafruit_blinka/microcontroller/spacemit/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/spacemit/k1/__init__.py,sha256=oTHSlhfgJxkZXCW588ez4mIvxXYfWeDUgpjZcFam9iw,155
+adafruit_blinka/microcontroller/spacemit/k1/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/spacemit/k1/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/spacemit/k1/pin.py,sha256=LXb4fNAIwAyA7yeg8B5DPiNUuiPnglA--ylI7DF8QOs,5319
+adafruit_blinka/microcontroller/starfive/JH7110/__init__.py,sha256=uCUdxtsMvlFBZ0JfcZd7UqeXd5UCHOlA1U85lIfheD8,147
+adafruit_blinka/microcontroller/starfive/JH7110/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH7110/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH7110/pin.py,sha256=s7cZlT0X5C_Ei16Op4akijH4bTNQ2pYAEvt4ddBmzIw,2665
+adafruit_blinka/microcontroller/starfive/JH7110/pwmio/PWMOut.py,sha256=8S-jnqsaPUkO9VfgZc0P7zxuZHohXA71gse292SQvFk,4438
+adafruit_blinka/microcontroller/starfive/JH7110/pwmio/__init__.py,sha256=wYVnbWF6RR-pPgDvS0QK_fJ9Z4EFxK_Qfopg2m8Z454,159
+adafruit_blinka/microcontroller/starfive/JH7110/pwmio/__pycache__/PWMOut.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH7110/pwmio/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH71x0/__init__.py,sha256=uQzBqDw63SlmAu-cj0uDsqjJnBQAB1Wzvfw6k_XE4nY,159
+adafruit_blinka/microcontroller/starfive/JH71x0/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH71x0/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/starfive/JH71x0/pin.py,sha256=1kld4eClhKBRfcPap1BA19W5FN8cMNW6YP2cCx_Q8e0,1015
+adafruit_blinka/microcontroller/starfive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/starfive/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/stm32/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/stm32f405/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/stm32/stm32f405/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/stm32f405/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/stm32f405/pin.py,sha256=STQxwOcTWfjNzhvXBMbn_SXsxitOup0yj3aIMRjP4zM,1192
+adafruit_blinka/microcontroller/stm32/stm32mp157/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/stm32/stm32mp157/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/stm32mp157/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/stm32/stm32mp157/pin.py,sha256=NK_yfV4mgo_N0fs0oloyQJuJdU1unZnH8WgyEN-zNb8,3418
+adafruit_blinka/microcontroller/tegra/PWMOut.py,sha256=UZ1xkO8loMHFVE5QWP0PtUeJ4RYpOXiFQVDjzr3PbHo,4440
+adafruit_blinka/microcontroller/tegra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/tegra/__pycache__/PWMOut.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t186/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/tegra/t186/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t186/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t186/pin.py,sha256=sJ29lBiCvmS6QL_UzVDTYmIV8BarQe2l-PhVwAWinvs,3414
+adafruit_blinka/microcontroller/tegra/t194/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/tegra/t194/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t194/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t194/pin.py,sha256=TSg_B9H-uEZUDSz4-6dLmcMI0CbyRBLxlEAHgrkw1pA,3387
+adafruit_blinka/microcontroller/tegra/t210/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/tegra/t210/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t210/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t210/pin.py,sha256=z9VTpmQKMMzWJBPM8o_2X24rr-ZkfxMLmn3cbdGfGHc,3564
+adafruit_blinka/microcontroller/tegra/t234/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/tegra/t234/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t234/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/tegra/t234/pin.py,sha256=6ETpnxJ_ni_1Pz4nBFpg2CjQN-mRzKYS1eyfpW4Q-TE,3321
+adafruit_blinka/microcontroller/thead/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adafruit_blinka/microcontroller/thead/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/thead/th1520/__init__.py,sha256=sefd-Bqm5dSrUbt2zwe0tvrU987N44XWXBVrKErd6Rc,120
+adafruit_blinka/microcontroller/thead/th1520/__pycache__/__init__.cpython-312.pyc,,
+adafruit_blinka/microcontroller/thead/th1520/__pycache__/pin.cpython-312.pyc,,
+adafruit_blinka/microcontroller/thead/th1520/pin.py,sha256=Tx5T_0CLFqiPiGYifL07Ul7VPMCzFf5Htcwc1S_ueVo,3456
+analogio.py,sha256=UonLPxGpPco5YXo_q82jfxgQmJneAUnJESz9hOPW5Ok,3370
+bitbangio.py,sha256=KNt_Lmg_dOGVu2gKUb63e9YJg-8flYaq2F-AqnSVn0o,4535
+board.py,sha256=HZiOGh3oWtB4eq2ufgDAGEcF-T3KYA6DeZgWfoyZq4k,16757
+busio.py,sha256=5Rt3T4SZG_48WQfRZH54OamdJLD_tZ__CbDoIgYgFPg,22898
+digitalio.py,sha256=j7euYGcffNgS4j8Y8cQuQ51k7bUDsWn33Kp-diOl3_8,10610
+keypad.py,sha256=ragQirpuLOqTI_7XNmaUTCOL9qMeDkFX6SVA4fafFG8,18820
+microcontroller/__init__.py,sha256=qwCaNk5-DdXTYL65Mva1sWJzhUQlmrlW-oDeKphes6k,7952
+microcontroller/__pycache__/__init__.cpython-312.pyc,,
+microcontroller/__pycache__/pin.cpython-312.pyc,,
+microcontroller/pin.py,sha256=2i8ZJe3j0SvGZLXCySf6UT_Nq9LL8qH1oqRkQBdko-0,8451
+micropython-stubs/micropython.pyi,sha256=gIE7gt93t1Ur8Iv_FxHVZfGD1BqR5FH8zgDuj2isr0E,645
+micropython.py,sha256=6D4KCjMpp48_onWPME_Gf7v83CKiKz2_9vBoF2-gVhI,626
+neopixel_write.py,sha256=1n-EcDjJZU3xFKxmbX0jMCO1Z8kUV4VCXykNe2GaJwM,1656
+onewireio.py,sha256=kCgKFtBjs-2PmpkTOC0ny4M-ap136V5_5Z8c3P3bYCo,1326
+pulseio.py,sha256=MZ5fUNP86wNjXDuk-BNbkzy-VsmJ9SUpnxZZ0JfsoRY,918
+pwmio.py,sha256=0Q6VxVZ6VdS1i2BsiPS6HJt4pBOTQUj2Wua6OMm-tE8,3349
+rainbowio.py,sha256=c38T9U1xuXgh0JeD_xs_RUfzrHhiQKRpcVJCC8BakwE,1181
+usb_hid.py,sha256=pNaGDmg-JQABuEN4qIwkfwxeeSLSoohTnQOI1w8cLfA,24778

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/WHEEL

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

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Adafruit Industries
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka-8.58.1.dist-info/top_level.txt

@@ -0,0 +1,16 @@
+adafruit_blinka
+analogio
+bitbangio
+board
+busio
+digitalio
+keypad
+microcontroller
+micropython
+micropython-stubs
+neopixel_write
+onewireio
+pulseio
+pwmio
+rainbowio
+usb_hid

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka/__init__.py

@@ -0,0 +1,125 @@
+# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""
+`adafruit_blinka` - Runtime utility objects for re-implementation of CircuitPython API
+======================================================================================
+
+* Author(s): cefn
+"""
+
+import os
+
+try:
+    import tomllib
+except ImportError:
+    import toml as tomllib
+
+
+class Enum:
+    """
+    Object supporting CircuitPython-style of static symbols
+    as seen with Direction.OUTPUT, Pull.UP
+    """
+
+    def __repr__(self):
+        """
+        Assumes instance will be found as attribute of own class.
+        Returns dot-subscripted path to instance
+        (assuming absolute import of containing package)
+        """
+        cls = type(self)
+        for key in dir(cls):
+            if getattr(cls, key) is self:
+                return "{}.{}.{}".format(cls.__module__, cls.__qualname__, key)
+        return repr(self)
+
+    @classmethod
+    def iteritems(cls):
+        """
+        Inspects attributes of the class for instances of the class
+        and returns as key,value pairs mirroring dict#iteritems
+        """
+        for key in dir(cls):
+            val = getattr(cls, key)
+            if isinstance(cls, val):
+                yield (key, val)
+
+
+class ContextManaged:
+    """An object that automatically deinitializes hardware with a context manager."""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.deinit()
+
+    # pylint: disable=no-self-use
+    def deinit(self):
+        """Free any hardware used by the object."""
+        return
+
+    # pylint: enable=no-self-use
+
+
+class Lockable(ContextManaged):
+    """An object that must be locked to prevent collisions on a microcontroller resource."""
+
+    _locked = False
+
+    def try_lock(self):
+        """Attempt to grab the lock. Return True on success, False if the lock is already taken."""
+        if self._locked:
+            return False
+        self._locked = True
+        return True
+
+    def unlock(self):
+        """Release the lock so others may use the resource."""
+        if self._locked:
+            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
+    import sys
+    from adafruit_blinka.agnostic import time
+
+    # pylint: enable=import-outside-toplevel
+
+    sys.modules["time"] = time

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka/agnostic/__init__.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""Allows useful indirection to test Pin naming logic by switching platform in testing
+    or provide bootstrapping logic for board identification where auto-detection is not
+    feasible (e.g. multiple ESP8266 boards architecturally identical). Once runtime
+    environment is established, can choose various routes to make available and re-export
+    common modules and operations, depending on platform support
+"""
+import sys
+import adafruit_platformdetect
+
+# We intentionally are patching into this namespace as module names so skip the name check.
+# pylint: disable=invalid-name
+
+# We'll define board and chip id values in agnostic rather than accessing
+# detector directly elsewhere, just in case additional indirection is necessary
+# at some later point:
+
+detector = adafruit_platformdetect.Detector()
+chip_id = detector.chip.id
+board_id = detector.board.id
+
+implementation = sys.implementation.name
+if implementation == "micropython":
+    from utime import sleep
+elif implementation in ("circuitpython", "cpython"):
+    from time import sleep

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka/agnostic/time.py

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""Platform agnostic time implementation"""
+
+from adafruit_blinka import agnostic
+
+# We intentionally are patching into this namespace so skip the wildcard check.
+# pylint: disable=unused-wildcard-import,wildcard-import
+
+if agnostic.implementation == "circuitpython":
+    from time import *
+elif agnostic.implementation == "micropython":
+    import utime
+    from utime import sleep
+
+    from ucollections import namedtuple
+
+    _struct_time = namedtuple(
+        "struct_time",
+        (
+            "tm_year",
+            "tm_mon",
+            "tm_mday",
+            "tm_hour",
+            "tm_min",
+            "tm_sec",
+            "tm_wday",
+            "tm_yday",
+            "tm_isdst",
+        ),
+    )
+
+    # pylint: disable=too-many-arguments
+    def _marshal_time(
+        tm_year,
+        tm_mon,
+        tm_mday,
+        tm_hour=0,
+        tm_min=0,
+        tm_sec=0,
+        tm_wday=-1,
+        tm_yday=-1,
+        tm_isdst=-1,
+    ):
+        """Construct struct_time with default values."""
+        _struct_time(
+            tm_year,
+            tm_mon,
+            tm_mday,
+            tm_hour,
+            tm_min,
+            tm_sec,
+            tm_wday,
+            tm_yday,
+            tm_isdst,
+        )
+
+    def struct_time(time_tuple):
+        """Create a struct_time"""
+        return _marshal_time(*time_tuple)
+
+    # pylint: disable=invalid-name
+    _total_ms = 0
+    _prev_ticks_ms = utime.ticks_ms()
+
+    def monotonic():
+        """A monotonically increasing time in seconds. No defined start time."""
+        # Assumes that monotonic is called more frequently than the wraparound of micropython's
+        # utime.ticks_ms()
+        global _prev_ticks_ms, _total_ms  # pylint: disable=global-statement
+        ticks_ms = utime.ticks_ms()
+        _total_ms += utime.ticks_diff(ticks_ms, _prev_ticks_ms)
+        _prev_ticks_ms = ticks_ms
+        return _total_ms * 0.001

ros2_ws_arm/arm/env/lib/python3.12/site-packages/adafruit_blinka/board/OLIMEX_LIME2.py

@@ -0,0 +1,145 @@
+# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""Pin definitions for the A20_OLINUXINO_LIME2."""
+
+from adafruit_blinka.microcontroller.allwinner.a20 import pin
+
+PA0 = pin.PA0
+PA1 = pin.PA1
+PA2 = pin.PA2
+UART2_TX = PA2
+PA3 = pin.PA3
+UART2_RX = PA3
+PA6 = pin.PA6
+PA7 = pin.PA7
+PA8 = pin.PA8
+PA9 = pin.PA9
+PA10 = pin.PA10
+UART1_TX = PA10
+PA11 = pin.PA11
+UART1_RX = PA11
+PA12 = pin.PA12
+PA13 = pin.PA13
+PA14 = pin.PA14
+PA15 = pin.PA15
+PA16 = pin.PA16
+PA17 = pin.PA17
+
+PB0 = pin.PB0
+TWI0_SCK = PB0
+SCL0 = PB0
+TWI0_SCL = PB0
+I2C0_SCL = PB0
+PB1 = pin.PB1
+TWI0_SDA = PB1
+SDA0 = PB1
+TWI0_SDA = PB1
+SDA0 = PB1
+PB2 = pin.PB2
+PWM0 = PB2
+PB3 = pin.PB3
+IR0_TX = PB3
+PB4 = pin.PB4
+IR0_RX = PB4
+PB5 = pin.PB5
+PB6 = pin.PB6
+PB7 = pin.PB7
+PB8 = pin.PB8
+PB12 = pin.PB12
+PB13 = pin.PB13
+PB18 = pin.PB18
+TWI1_SCK = PB18
+SCL1 = PB18
+TWI_SCL1 = PB18
+S2C_SCL1 = PB18
+PB19 = pin.PB19
+TWI1_SDA = PB19
+SDA1 = PB19
+TWI_SDA1 = PB19
+I2C_SDA1 = PB19
+PB20 = pin.PB20
+TWI2_SCK = PB20
+SCL = PB20
+TWI_SCL2 = PB20
+I2C_SCL2 = PB20
+PB21 = pin.PB21
+TWI2_SDA = PB21
+SDA = PB21
+TWI_SDA2 = PB21
+I2C_SDA2 = PB21
+PB22 = pin.PB22
+UART0_TX = PB22
+PB23 = pin.PB23
+UART0_RX = PB23
+
+PC19 = pin.PC19
+SPI2_CS0 = PC19
+PC20 = pin.PC20
+SPI2_SCLK = PC20
+PC21 = pin.PC21
+SPI2_MOSI = PC21
+PC22 = pin.PC22
+SPI2_MISO = PC22
+
+PG2 = pin.PG2
+
+PH2 = pin.PH2
+PH4 = pin.PH4
+UART4_TX = PH4
+PH5 = pin.PH5
+UART4_RX = PH5
+PH6 = pin.PH6
+UART5_TX = PH6
+PH7 = pin.PH7
+UART5_RX = PH7
+PH8 = pin.PH8
+PH9 = pin.PH9
+PH10 = pin.PH10
+PH11 = pin.PH11
+PH12 = pin.PH12
+PH13 = pin.PH13
+PH14 = pin.PH14
+PH15 = pin.PH15
+PH16 = pin.PH16
+PH17 = pin.PH17
+PH18 = pin.PH18
+PH19 = pin.PH19
+PH20 = pin.PH20
+CAN_TX = PH20
+PH21 = pin.PH21
+CAN_RX = PH21
+PH24 = pin.PH24
+
+PI0 = pin.PI0
+TWI3_SCK = PI0
+SCL3 = PI0
+PI1 = pin.PI1
+TWI3_SDA = PI1
+SDA3 = PI1
+PI3 = pin.PI3
+PWM1 = PI3
+PI10 = pin.PI10
+SPI0_CS0 = PI10
+PI11 = pin.PI11
+SPI0_SCLK = PI11
+PI12 = pin.PI12
+SPI0_MOSI = PI12
+UART6_TX = PI12
+PI13 = pin.PI13
+SPI0_MISO = PI13
+UART6_RX = PI13
+PI14 = pin.PI14
+SPI0_CS1 = PI14
+PI16 = pin.PI16
+UART2_RTS = PI16
+PI17 = pin.PI17
+UART2_CTS = PI17
+PI18 = pin.PI18
+UART2_TX = PI18
+PI19 = pin.PI19
+UART2_RX = PI19
+PI20 = pin.PI20
+UART7_TX = PI20
+PI21 = pin.PI21
+UART7_RX = PI21