├── .gitignore ├── CHANGES.md ├── LICENSE.txt ├── MANIFEST.in ├── README.md ├── bbio ├── __init__.py ├── bbio.py ├── common.py ├── libraries │ ├── ADS786x │ │ ├── README │ │ ├── __init__.py │ │ └── ads786x.py │ ├── ADT7310 │ │ ├── README.md │ │ ├── __init__.py │ │ └── adt7310.py │ ├── ADXL345 │ │ ├── ADXL345.py │ │ └── __init__.py │ ├── BBIOServer │ │ ├── .gitignore │ │ ├── README │ │ ├── __init__.py │ │ ├── bbio_server.py │ │ └── src │ │ │ ├── footer.html │ │ │ ├── functions.js │ │ │ ├── header.html │ │ │ ├── index.html.template │ │ │ ├── jquery-1.11.1.min.js │ │ │ ├── mobile.css │ │ │ ├── sidebar.html │ │ │ └── style.css │ ├── BMP183 │ │ ├── BMP183.py │ │ └── __init__.py │ ├── DACx311 │ │ ├── README │ │ ├── __init__.py │ │ └── dacx311.py │ ├── EventIO │ │ ├── README │ │ ├── __init__.py │ │ └── eventio.py │ ├── GridEYE │ │ ├── GridEYE.py │ │ └── __init__.py │ ├── HTU21D │ │ ├── HTU21D.py │ │ └── __init__.py │ ├── IoT │ │ ├── __init__.py │ │ ├── phant.py │ │ └── thingspeak.py │ ├── LiquidCrystal │ │ ├── LiquidCrystal.py │ │ └── __init__.py │ ├── MAX31855 │ │ ├── __init__.py │ │ └── max31855.py │ ├── MMA7660 │ │ ├── README.md │ │ ├── __init__.py │ │ └── mma7660.py │ ├── RotaryEncoder │ │ ├── README.md │ │ ├── __init__.py │ │ └── rotary_encoder.py │ ├── SafeProcess │ │ ├── README │ │ ├── __init__.py │ │ └── safe_process.py │ ├── Servo │ │ ├── README │ │ ├── Servo.py │ │ └── __init__.py │ ├── WebCam │ │ ├── README.md │ │ ├── __init__.py │ │ └── webcam.py │ ├── __init__.py │ └── example.py └── platform │ ├── __init__.py │ ├── beaglebone │ ├── __init__.py │ ├── adc.py │ ├── api.py │ ├── cape_manager.py │ ├── config.py │ ├── gpio.c │ ├── gpio.h │ ├── i2c.py │ ├── interrupt.py │ ├── pinmux.py │ ├── pwm.py │ ├── serial_port.py │ └── spi.py │ ├── platform.py │ └── util │ ├── __init__.py │ ├── mmap_util.c │ ├── mmap_util.h │ ├── sysfs.c │ └── sysfs.h ├── code_of_conduct.md ├── doinstall.sh ├── examples ├── ADS786x_test.py ├── ADXL345_test.py ├── BBIOServer_mobile_test.py ├── BBIOServer_test.py ├── BMP183_test.py ├── DACx311_test.py ├── EventIO_test.py ├── GridEYE_save_image.py ├── GridEYE_test.py ├── HTU21D_test.py ├── LiquidCrystal_clock.py ├── LiquidCrystal_fps.py ├── LiquidCrystal_glyphs.py ├── MAX31855_test.py ├── SafeProcess_test.py ├── Servo_sweep.py ├── adt7310_test.py ├── analog_test.py ├── available_pins.py ├── blink.py ├── digitalRead.py ├── encoder_test.py ├── fade.py ├── interrupt.py ├── knock.py ├── mma7660_test.py ├── phant_test.py ├── remote_temp_control.py ├── security_cam.py ├── serial_echo.py ├── serial_server.py ├── switch.py ├── webcam_bbioserver_test.py └── webcam_test.py ├── setup.cfg ├── setup.py ├── tests ├── io_test.py ├── library_test.py ├── sleep_test.py ├── sleep_test_results.txt └── speed_test.py └── tools ├── generate_overlays.py └── overlays ├── PyBBIO-ADC-00A0.dts ├── PyBBIO-AIN0-00A0.dts ├── PyBBIO-AIN1-00A0.dts ├── PyBBIO-AIN2-00A0.dts ├── PyBBIO-AIN3-00A0.dts ├── PyBBIO-AIN4-00A0.dts ├── PyBBIO-AIN5-00A0.dts ├── PyBBIO-AIN6-00A0.dts ├── PyBBIO-AIN7-00A0.dts ├── PyBBIO-ecap0-00A0.dts ├── PyBBIO-ecap1-00A0.dts ├── PyBBIO-ehrpwm1-00A0.dts ├── PyBBIO-ehrpwm2-00A0.dts ├── PyBBIO-epwmss0-00A0.dts ├── PyBBIO-epwmss1-00A0.dts ├── PyBBIO-epwmss2-00A0.dts ├── PyBBIO-eqep0-00A0.dts ├── PyBBIO-eqep1-00A0.dts ├── PyBBIO-eqep2-00A0.dts ├── PyBBIO-eqep2b-00A0.dts ├── PyBBIO-gpio0_10-00A0.dts ├── PyBBIO-gpio0_11-00A0.dts ├── PyBBIO-gpio0_12-00A0.dts ├── PyBBIO-gpio0_13-00A0.dts ├── PyBBIO-gpio0_14-00A0.dts ├── PyBBIO-gpio0_15-00A0.dts ├── PyBBIO-gpio0_2-00A0.dts ├── PyBBIO-gpio0_20-00A0.dts ├── PyBBIO-gpio0_22-00A0.dts ├── PyBBIO-gpio0_23-00A0.dts ├── PyBBIO-gpio0_26-00A0.dts ├── PyBBIO-gpio0_27-00A0.dts ├── PyBBIO-gpio0_3-00A0.dts ├── PyBBIO-gpio0_30-00A0.dts ├── PyBBIO-gpio0_31-00A0.dts ├── PyBBIO-gpio0_4-00A0.dts ├── PyBBIO-gpio0_5-00A0.dts ├── PyBBIO-gpio0_7-00A0.dts ├── PyBBIO-gpio0_8-00A0.dts ├── PyBBIO-gpio0_9-00A0.dts ├── PyBBIO-gpio1_0-00A0.dts ├── PyBBIO-gpio1_1-00A0.dts ├── PyBBIO-gpio1_12-00A0.dts ├── PyBBIO-gpio1_13-00A0.dts ├── PyBBIO-gpio1_14-00A0.dts ├── PyBBIO-gpio1_15-00A0.dts ├── PyBBIO-gpio1_16-00A0.dts ├── PyBBIO-gpio1_17-00A0.dts ├── PyBBIO-gpio1_18-00A0.dts ├── PyBBIO-gpio1_19-00A0.dts ├── PyBBIO-gpio1_2-00A0.dts ├── PyBBIO-gpio1_28-00A0.dts ├── PyBBIO-gpio1_29-00A0.dts ├── PyBBIO-gpio1_3-00A0.dts ├── PyBBIO-gpio1_30-00A0.dts ├── PyBBIO-gpio1_31-00A0.dts ├── PyBBIO-gpio1_4-00A0.dts ├── PyBBIO-gpio1_5-00A0.dts ├── PyBBIO-gpio1_6-00A0.dts ├── PyBBIO-gpio1_7-00A0.dts ├── PyBBIO-gpio2_1-00A0.dts ├── PyBBIO-gpio2_10-00A0.dts ├── PyBBIO-gpio2_11-00A0.dts ├── PyBBIO-gpio2_12-00A0.dts ├── PyBBIO-gpio2_13-00A0.dts ├── PyBBIO-gpio2_14-00A0.dts ├── PyBBIO-gpio2_15-00A0.dts ├── PyBBIO-gpio2_16-00A0.dts ├── PyBBIO-gpio2_17-00A0.dts ├── PyBBIO-gpio2_2-00A0.dts ├── PyBBIO-gpio2_22-00A0.dts ├── PyBBIO-gpio2_23-00A0.dts ├── PyBBIO-gpio2_24-00A0.dts ├── PyBBIO-gpio2_25-00A0.dts ├── PyBBIO-gpio2_3-00A0.dts ├── PyBBIO-gpio2_4-00A0.dts ├── PyBBIO-gpio2_5-00A0.dts ├── PyBBIO-gpio2_6-00A0.dts ├── PyBBIO-gpio2_7-00A0.dts ├── PyBBIO-gpio2_8-00A0.dts ├── PyBBIO-gpio2_9-00A0.dts ├── PyBBIO-gpio3_14-00A0.dts ├── PyBBIO-gpio3_15-00A0.dts ├── PyBBIO-gpio3_16-00A0.dts ├── PyBBIO-gpio3_17-00A0.dts ├── PyBBIO-gpio3_19-00A0.dts ├── PyBBIO-gpio3_21-00A0.dts ├── PyBBIO-usr0-00A0.dts ├── PyBBIO-usr1-00A0.dts ├── PyBBIO-usr2-00A0.dts ├── PyBBIO-usr3-00A0.dts ├── adc-template.txt ├── compiled ├── PyBBIO-ADC-00A0.dtbo ├── PyBBIO-AIN0-00A0.dtbo ├── PyBBIO-AIN1-00A0.dtbo ├── PyBBIO-AIN2-00A0.dtbo ├── PyBBIO-AIN3-00A0.dtbo ├── PyBBIO-AIN4-00A0.dtbo ├── PyBBIO-AIN5-00A0.dtbo ├── PyBBIO-AIN6-00A0.dtbo ├── PyBBIO-AIN7-00A0.dtbo ├── PyBBIO-ecap0-00A0.dtbo ├── PyBBIO-ecap1-00A0.dtbo ├── PyBBIO-ehrpwm1-00A0.dtbo ├── PyBBIO-ehrpwm2-00A0.dtbo ├── PyBBIO-epwmss0-00A0.dtbo ├── PyBBIO-epwmss1-00A0.dtbo ├── PyBBIO-epwmss2-00A0.dtbo ├── PyBBIO-eqep0-00A0.dtbo ├── PyBBIO-eqep1-00A0.dtbo ├── PyBBIO-eqep2-00A0.dtbo ├── PyBBIO-eqep2b-00A0.dtbo ├── PyBBIO-gpio0_10-00A0.dtbo ├── PyBBIO-gpio0_11-00A0.dtbo ├── PyBBIO-gpio0_12-00A0.dtbo ├── PyBBIO-gpio0_13-00A0.dtbo ├── PyBBIO-gpio0_14-00A0.dtbo ├── PyBBIO-gpio0_15-00A0.dtbo ├── PyBBIO-gpio0_2-00A0.dtbo ├── PyBBIO-gpio0_20-00A0.dtbo ├── PyBBIO-gpio0_22-00A0.dtbo ├── PyBBIO-gpio0_23-00A0.dtbo ├── PyBBIO-gpio0_26-00A0.dtbo ├── PyBBIO-gpio0_27-00A0.dtbo ├── PyBBIO-gpio0_3-00A0.dtbo ├── PyBBIO-gpio0_30-00A0.dtbo ├── PyBBIO-gpio0_31-00A0.dtbo ├── PyBBIO-gpio0_4-00A0.dtbo ├── PyBBIO-gpio0_5-00A0.dtbo ├── PyBBIO-gpio0_7-00A0.dtbo ├── PyBBIO-gpio0_8-00A0.dtbo ├── PyBBIO-gpio0_9-00A0.dtbo ├── PyBBIO-gpio1_0-00A0.dtbo ├── PyBBIO-gpio1_1-00A0.dtbo ├── PyBBIO-gpio1_12-00A0.dtbo ├── PyBBIO-gpio1_13-00A0.dtbo ├── PyBBIO-gpio1_14-00A0.dtbo ├── PyBBIO-gpio1_15-00A0.dtbo ├── PyBBIO-gpio1_16-00A0.dtbo ├── PyBBIO-gpio1_17-00A0.dtbo ├── PyBBIO-gpio1_18-00A0.dtbo ├── PyBBIO-gpio1_19-00A0.dtbo ├── PyBBIO-gpio1_2-00A0.dtbo ├── PyBBIO-gpio1_28-00A0.dtbo ├── PyBBIO-gpio1_29-00A0.dtbo ├── PyBBIO-gpio1_3-00A0.dtbo ├── PyBBIO-gpio1_30-00A0.dtbo ├── PyBBIO-gpio1_31-00A0.dtbo ├── PyBBIO-gpio1_4-00A0.dtbo ├── PyBBIO-gpio1_5-00A0.dtbo ├── PyBBIO-gpio1_6-00A0.dtbo ├── PyBBIO-gpio1_7-00A0.dtbo ├── PyBBIO-gpio2_1-00A0.dtbo ├── PyBBIO-gpio2_10-00A0.dtbo ├── PyBBIO-gpio2_11-00A0.dtbo ├── PyBBIO-gpio2_12-00A0.dtbo ├── PyBBIO-gpio2_13-00A0.dtbo ├── PyBBIO-gpio2_14-00A0.dtbo ├── PyBBIO-gpio2_15-00A0.dtbo ├── PyBBIO-gpio2_16-00A0.dtbo ├── PyBBIO-gpio2_17-00A0.dtbo ├── PyBBIO-gpio2_2-00A0.dtbo ├── PyBBIO-gpio2_22-00A0.dtbo ├── PyBBIO-gpio2_23-00A0.dtbo ├── PyBBIO-gpio2_24-00A0.dtbo ├── PyBBIO-gpio2_25-00A0.dtbo ├── PyBBIO-gpio2_3-00A0.dtbo ├── PyBBIO-gpio2_4-00A0.dtbo ├── PyBBIO-gpio2_5-00A0.dtbo ├── PyBBIO-gpio2_6-00A0.dtbo ├── PyBBIO-gpio2_7-00A0.dtbo ├── PyBBIO-gpio2_8-00A0.dtbo ├── PyBBIO-gpio2_9-00A0.dtbo ├── PyBBIO-gpio3_14-00A0.dtbo ├── PyBBIO-gpio3_15-00A0.dtbo ├── PyBBIO-gpio3_16-00A0.dtbo ├── PyBBIO-gpio3_17-00A0.dtbo ├── PyBBIO-gpio3_19-00A0.dtbo ├── PyBBIO-gpio3_21-00A0.dtbo ├── PyBBIO-usr0-00A0.dtbo ├── PyBBIO-usr1-00A0.dtbo ├── PyBBIO-usr2-00A0.dtbo └── PyBBIO-usr3-00A0.dtbo └── gpio-template.txt /.gitignore: -------------------------------------------------------------------------------- 1 | *.pyo 2 | *.pyc 3 | build/ 4 | dist/ -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2012-2014 - Alexander Hiam 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include LICENSE.txt 2 | include README.md 3 | recursive-include bbio *.py *.c *.h 4 | recursive-include bbio/libraries *.md 5 | recursive-include bbio/libraries/BBIOServer/src *.* 6 | recursive-include examples *.* 7 | recursive-include tools *.py *.txt *.dts *.dtbo -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | PyBBIO 2 | ====== 3 | 4 | **Note**: I haven't had any time to maintain this library in recent years - if anyone's interested in taking it over hit me up: 5 | 6 | http://github.com/graycatlabs/PyBBIO 7 | 8 | Copyright (c) 2012-2015 - Alexander Hiam 9 | 10 | Released under the MIT license 11 | 12 | PyBBIO is a Python library for Arduino-style hardware IO support on the 13 | BeagleBone and BeagleBone Black. It supports the GPIO, ADC, PWM, UART, 14 | SPI, I2C and eQEP modules, and also includes a number of additional libraries 15 | for added functionality. 16 | 17 | Documentation can be found at http://github.com/graycatlabs/PyBBIO/wiki 18 | 19 | Follow me on Twitter [@alexanderhiam](https://twitter.com/alexanderhiam) for PyBBIO development updates 20 | 21 | License 22 | ======= 23 | 24 | Permission is hereby granted, free of charge, to any person obtaining a copy 25 | of this software and associated documentation files (the "Software"), to deal 26 | in the Software without restriction, including without limitation the rights 27 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 28 | copies of the Software, and to permit persons to whom the Software is 29 | furnished to do so, subject to the following conditions: 30 | 31 | The above copyright notice and this permission notice shall be included in 32 | all copies or substantial portions of the Software. 33 | 34 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 35 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 36 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 37 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 38 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 39 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 40 | THE SOFTWARE. 41 | -------------------------------------------------------------------------------- /bbio/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py script for PyBBIO 2 | # 3 | 4 | try: 5 | from .bbio import run, stop 6 | except ImportError, e: 7 | if e.args[0] == 'cannot import name run': 8 | # run() and stop() not defined in interactive mode 9 | pass 10 | else: raise 11 | 12 | from .common import addToCleanup, millis, micros, delay, delayMicroseconds 13 | 14 | from .platform import * 15 | 16 | import libraries -------------------------------------------------------------------------------- /bbio/bbio.py: -------------------------------------------------------------------------------- 1 | """ 2 | PyBBIO - bbio.py 3 | Copyright (c) 2012-2015 - Alexander Hiam 4 | Released under the MIT license 5 | https://github.com/graycatlabs/PyBBIO 6 | """ 7 | 8 | import sys, atexit 9 | 10 | from .platform import platform_init, platform_cleanup 11 | from .common import ADDITIONAL_CLEANUP, util_init 12 | 13 | def bbio_init(): 14 | """ Pre-run initialization, i.e. starting module clocks, etc. """ 15 | util_init() 16 | platform_init() 17 | 18 | def bbio_cleanup(): 19 | """ Post-run cleanup, i.e. stopping module clocks, etc. """ 20 | # Run user cleanup routines: 21 | for cleanup in ADDITIONAL_CLEANUP: 22 | try: 23 | cleanup() 24 | except Exception as e: 25 | # Something went wrong with one of the cleanup routines, but we 26 | # want to keep going; just print the error and continue 27 | print "*Exception raised trying to call cleanup routine '%s':\n %s" %\ 28 | (cleanup, e) 29 | platform_cleanup() 30 | 31 | # The following code detects if Python is running interactively, 32 | # and if so initializes PyBBIO on import and registers PyBBIO's 33 | # cleanup to be called at exit, otherwise it defines the run() and 34 | # stop() methods for the file based control flow: 35 | import __main__ 36 | if not hasattr(__main__, '__file__'): 37 | # We're in the interpreter, see: 38 | # http://stackoverflow.com/questions/2356399/tell-if-python-is-in-interactive-mode 39 | bbio_init() 40 | print "PyBBIO initialized" 41 | def interactive_cleanup(): 42 | bbio_cleanup() 43 | print "Finished PyBBIO cleanup" 44 | atexit.register(interactive_cleanup) 45 | 46 | else: 47 | bbio_init() 48 | atexit.register(bbio_cleanup) 49 | 50 | # Imported in a Python file, define run() and stop(): 51 | def run(setup, loop): 52 | """ The main loop; must be passed a setup and a loop function. 53 | First the setup function will be called once, then the loop 54 | function wil be called continuously until a stop signal is 55 | raised, e.g. CTRL-C or a call to the stop() function from 56 | within the loop. """ 57 | try: 58 | setup() 59 | while (True): 60 | loop() 61 | except KeyboardInterrupt: 62 | # Manual exit signal, clean up and exit happy 63 | exit(0) 64 | 65 | def stop(): 66 | """ Preferred way for a program to stop itself. """ 67 | raise KeyboardInterrupt # Expected happy stop condition in run() 68 | -------------------------------------------------------------------------------- /bbio/common.py: -------------------------------------------------------------------------------- 1 | # common.py 2 | # Part of PyBBIO 3 | # github.com/alexanderhiam/PyBBIO 4 | # MIT License 5 | # 6 | # This file contains routines and variables that may need to be 7 | # accessed by internal drivers, which cannot import the bbio.py 8 | # file because it imports them. 9 | 10 | import time 11 | 12 | ADDITIONAL_CLEANUP = [] # See add_cleanup() below. 13 | START_TIME_MS = 0 # Set in run() - used by millis() and micros(). 14 | 15 | START_TIME_MS = 0 16 | def util_init(): 17 | global START_TIME_MS 18 | START_TIME_MS = time.time()*1000 19 | 20 | def addToCleanup(routine): 21 | """ Takes a callable object to be called during the cleanup once a 22 | program has stopped, e.g. a function to close a log file, kill 23 | a thread, etc. """ 24 | ADDITIONAL_CLEANUP.append(routine) 25 | 26 | def millis(): 27 | """ Returns roughly the number of millisoconds since program start. """ 28 | return time.time()*1000 - START_TIME_MS 29 | 30 | def micros(): 31 | """ Returns roughly the number of microsoconds since program start. """ 32 | return time.time()*1000000 - START_TIME_MS*1000 33 | 34 | def delay(ms): 35 | """ Sleeps for given number of milliseconds. """ 36 | time.sleep(ms/1000.0) 37 | 38 | def delayMicroseconds(us): 39 | """ Sleeps for given number of microseconds > ~30; still working 40 | on a more accurate method. """ 41 | t = time.time() 42 | while (((time.time()-t)*1000000) < us): pass 43 | -------------------------------------------------------------------------------- /bbio/libraries/ADS786x/README: -------------------------------------------------------------------------------- 1 | ADS786x - v0.1 2 | 3 | Copyright 2012 Alexander Hiam 4 | 5 | ADS786x is a library for PyBBIO to interface with TI's ADS786x1 series 6 | analog-to-digital converters (ADS7866-12bit, ADS7867-10bit, ADS7868-8bit). 7 | 8 | See documentation here: 9 | https://github.com/alexanderhiam/PyBBIO/wiki/ADS786x 10 | As well as the included example program: 11 | PyBBIO/examples/ADS786x_test.py 12 | 13 | ADS786x is released as part of PyBBIO under its MIT license. 14 | See PyBBIO/LICENSE.txt 15 | -------------------------------------------------------------------------------- /bbio/libraries/ADS786x/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's ADS786x library 2 | 3 | from ads786x import ADS7866, ADS7867, ADS7868 4 | -------------------------------------------------------------------------------- /bbio/libraries/ADS786x/ads786x.py: -------------------------------------------------------------------------------- 1 | """ 2 | ADS786x - v0.1 3 | Copyright 2012 Alexander Hiam 4 | A library for interfacing with TI's ADS786x series 5 | analog-to-digital converters 6 | """ 7 | 8 | from bbio import * 9 | 10 | class ADS786x(object): 11 | """ Base class for all each of ADS786x series classes. """ 12 | def __init__(self, data_pin, clk_pin, cs_pin, vref=3.3): 13 | self._data = data_pin 14 | self._clk = clk_pin 15 | self._cs = cs_pin 16 | pinMode(self._data, INPUT) 17 | for i in (self._cs, self._clk): pinMode(i, OUTPUT) 18 | 19 | # Idle state for clock and cs (data doesn't matter): 20 | for i in (self._cs, self._clk): digitalWrite(i, HIGH) 21 | 22 | # Calculate volts per bit: 23 | self.dv = float(vref)/2**self.n_bits 24 | 25 | def read(self): 26 | """ Read and return the ADC value. """ 27 | digitalWrite(self._cs, LOW) 28 | value = shiftIn(self._data, self._clk, MSBFIRST, n_bits=self.n_bits+3) 29 | digitalWrite(self._cs, HIGH) 30 | return value 31 | 32 | def readVolts(self): 33 | """ Sets the DAC output to the given voltage. """ 34 | return self.read() * self.dv 35 | 36 | 37 | class ADS7866(ADS786x): 38 | # Tested, working 39 | n_bits = 12 40 | 41 | class ADS7867(ADS786x): 42 | # Untested 43 | n_bits = 10 44 | 45 | class ADS7868(ADS786x): 46 | # Untested 47 | n_bits = 8 48 | -------------------------------------------------------------------------------- /bbio/libraries/ADT7310/README.md: -------------------------------------------------------------------------------- 1 | ADT7310 - v0.1 2 | 3 | Copyright 2014 Rekha Seethamraju 4 | rekha.kmit@gmail.com 5 | 6 | Library for controlling temperature sensor ADT7310 with the 7 | Beaglebone Black's SPI pins. 8 | 9 | See documentation here: 10 | https://github.com/alexanderhiam/PyBBIO/wiki/ADT7310 11 | As well as the included example programs: 12 | PyBBIO/examples/adt7310_test.py 13 | 14 | ADT7310 is released as part of PyBBIO under its MIT license. 15 | See PyBBIO/LICENSE.txt 16 | -------------------------------------------------------------------------------- /bbio/libraries/ADT7310/__init__.py: -------------------------------------------------------------------------------- 1 | from adt7310 import ADT7310 -------------------------------------------------------------------------------- /bbio/libraries/ADXL345/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's ADXL345 library 2 | from ADXL345 import ADXL345 3 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/.gitignore: -------------------------------------------------------------------------------- 1 | *.html -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/README: -------------------------------------------------------------------------------- 1 | BBIOServer - v1.3 2 | 3 | Copyright 2012, 2014 Alexander Hiam 4 | 5 | BBIOServer is a dynamic web interface library for PyBBIO. 6 | 7 | See documentation here: 8 | https://github.com/alexanderhiam/PyBBIO/wiki/BBIOServer 9 | As well as the included example programs: 10 | PyBBIO/examples/BBIOServer_test.py 11 | and 12 | PyBBIO/examples/BBIOServer_mobile_test.py 13 | 14 | BBIOServer is released as part of PyBBIO under its MIT license. 15 | See PyBBIO/LICENSE.txt 16 | 17 | --------------------------------------------------- 18 | 19 | BBIOServer uses and includes a copy of the minified JQuery library v1.11.1, 20 | released under the MIT license. 21 | 22 | JQuery v1.11.1 license details: 23 | 24 | jQuery JavaScript Library v1.11.1 25 | http://jquery.com/ 26 | 27 | Includes Sizzle.js 28 | http://sizzlejs.com/ 29 | 30 | Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors 31 | Released under the MIT license 32 | http://jquery.org/license 33 | 34 | Date: 2014-05-01T17:42Z 35 | 36 | --------------------------------------------------- 37 | 38 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py for BBIOServer 2 | # Nothing to do here but import everything from bbio_server.py. 3 | from bbio_server import * 4 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/footer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/functions.js: -------------------------------------------------------------------------------- 1 | /* 2 | functions.js 3 | Javascript functions for PyBBIO BBIOServer library. 4 | */ 5 | 6 | function call_function(function_id, type) { 7 | /* Interfaces with the BBIOServer request handler to execute 8 | PyBBIO functions. */ 9 | var params = { "function_id" : function_id }; 10 | if (type == "entry") { 11 | // Extract the text and add it to the params hash table: 12 | var text = $('#' + function_id).val() 13 | if (!text) { 14 | text += " "; 15 | } 16 | params["entry_text"] = text; 17 | } 18 | $.get("/cgi-bin/index", params, 19 | function(return_value){ 20 | if (type == "monitor") { 21 | // Set the monitor div with the same id as the function 22 | // to the return value: 23 | $('#'+function_id).text(return_value); 24 | } 25 | }); 26 | }; 27 | 28 | 29 | function start_monitor() { 30 | /* Called once on page load. Continuously updates monitors. */ 31 | $('.monitor-field').each(function() { 32 | // The div id is the same as its function's id: 33 | var function_id = $(this).attr('id'); 34 | call_function(function_id, 'monitor'); 35 | }); 36 | setTimeout(function() { 37 | start_monitor(); 38 | }, 200); 39 | } 40 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/header.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | PyBBIO Server - %s 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 19 | %s 20 |
21 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/index.html.template: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Redirecting to PyBBIO web interface... 5 | 8 | 9 | 10 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/mobile.css: -------------------------------------------------------------------------------- 1 | /* 2 | CSS mobile stylesheet for BBIOServer. 3 | */ 4 | 5 | 6 | body { 7 | background: #eeeeff; 8 | font-family: monospace; 9 | font-size: 12px; 10 | margin: 5px; 11 | } 12 | 13 | a { 14 | text-decoration: none; 15 | color: #444499; 16 | outline: 0; 17 | } 18 | a:hover { 19 | text-decoration: underline; 20 | } 21 | 22 | #page-wrapper{ 23 | display: inline-block; 24 | width: 99%; 25 | max-width: 720px; 26 | padding-bottom: 5px; 27 | border: 1px solid #888888; 28 | background: #ffffff; 29 | } 30 | 31 | #header { 32 | background: #ffffff; 33 | padding: 2px; 34 | margin: 0px; 35 | border-bottom: 1px solid #888888; 36 | } 37 | #header h2 { margin: 5px; } 38 | 39 | #sidebar { 40 | padding: 2px 0px 2px 0px; 41 | border-bottom: 1px solid #888888; 42 | } 43 | 44 | #sidebar li { 45 | font-size: 15px; 46 | list-style-type: none; 47 | display: inline; 48 | padding-left: 10px; 49 | border-left: 1px solid #888888; 50 | } 51 | 52 | #sidebar li a:hover { 53 | background: #efefef; 54 | } 55 | 56 | #sidebar li:first-child { 57 | border: 0px; 58 | } 59 | 60 | #content { 61 | padding: 2px; 62 | margin: 2px; 63 | } 64 | 65 | div .heading { 66 | float: left; 67 | width: 100%; 68 | margin: 2px 0px 10px 0px; 69 | padding: 5px 0px 6px 2px; 70 | border-bottom: 1px dashed #888888; 71 | font-size: 16px; 72 | font-weight: bold; 73 | } 74 | 75 | div .text { 76 | float: left; 77 | margin: 2px; 78 | } 79 | 80 | div .object-wrapper { 81 | float: left; 82 | margin: 0px 0px 7px 10px; 83 | } 84 | div .object-wrapper .entry { 85 | float: left; 86 | display: inline-block; 87 | margin-top: 2px; 88 | font-family: monospace; 89 | font-size: 12px; 90 | height: 28px; 91 | } 92 | 93 | div .button { 94 | float: left; 95 | display: inline-block; 96 | padding: 5px; 97 | margin-top: 3px; 98 | background: #fafafa; 99 | border: 1px solid #999999; 100 | -moz-user-select: none; 101 | -khtml-user-select: none; 102 | -webkit-user-select: none; 103 | -o-user-select: none; 104 | } 105 | div .button:hover { 106 | background: #efefef; 107 | cursor: pointer; 108 | } 109 | 110 | div .value-field { 111 | float: left; 112 | display: inline-block; 113 | margin: 5px; 114 | padding: 5px 0px; 115 | } 116 | 117 | div .monitor-field { 118 | float: left; 119 | display: inline-block; 120 | margin: 5px 0px 5px 2px; 121 | padding: 5px 0px 5px 2px; 122 | } 123 | 124 | #copyright { 125 | float: left; 126 | width: 98%; 127 | margin-left: 5px; 128 | margin-right: 1000px; 129 | font-size: 10px; 130 | } 131 | -------------------------------------------------------------------------------- /bbio/libraries/BBIOServer/src/sidebar.html: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | -------------------------------------------------------------------------------- /bbio/libraries/BMP183/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's BMP183 library 2 | from BMP183 import BMP183 -------------------------------------------------------------------------------- /bbio/libraries/DACx311/README: -------------------------------------------------------------------------------- 1 | DACx311 - v0.1 2 | 3 | Copyright 2012 Alexander Hiam 4 | 5 | DACx311 is a library for PyBBIO to interface with TI's DACx311 series 6 | digital-to-analog converters (DAC5311-8bit, DAC6311-10bit, DAC7311-12bit, 7 | DAC8311-14bit). 8 | 9 | See documentation here: 10 | https://github.com/alexanderhiam/PyBBIO/wiki/DACx311 11 | As well as the included example program: 12 | PyBBIO/examples/DACx311_test.py 13 | 14 | DACx311 is released as part of PyBBIO under its MIT license. 15 | See PyBBIO/LICENSE.txt 16 | -------------------------------------------------------------------------------- /bbio/libraries/DACx311/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's DACx311 library 2 | 3 | from dacx311 import DAC5311, DAC6311, DAC7311, DAC8311 4 | -------------------------------------------------------------------------------- /bbio/libraries/DACx311/dacx311.py: -------------------------------------------------------------------------------- 1 | """ 2 | DACx311 - v0.1 3 | Copyright 2012 Alexander Hiam 4 | A library for interfacing with TI's DACx311 series 5 | digital-to-analog converters 6 | """ 7 | 8 | from bbio import * 9 | 10 | class DACx311(object): 11 | """ Base class for all each of DACx311 series classes. """ 12 | def __init__(self, data_pin, clk_pin, sync_pin, vref=3.3): 13 | self._data = data_pin 14 | self._clk = clk_pin 15 | self._sync = sync_pin 16 | for i in (self._data, self._sync, self._clk): pinMode(i, OUTPUT) 17 | 18 | # Idle state for clock and sync (data doesn't matter): 19 | for i in (self._sync, self._clk): digitalWrite(i, HIGH) 20 | 21 | self.max_value = 2**self.n_bits - 1 22 | # Calculate volts per bit: 23 | self.dv = float(vref)/2**self.n_bits 24 | 25 | def set(self, value): 26 | """ Set the DAC control register to the given value. """ 27 | if (value > self.max_value): value = self.max_value 28 | if (value < 0): value = 0 29 | value <<= self.bit_shift 30 | digitalWrite(self._sync, LOW) 31 | 32 | shiftOut(self._data, self._clk, MSBFIRST, (value>>8), FALLING) 33 | shiftOut(self._data, self._clk, MSBFIRST, value & 0xff, FALLING) 34 | 35 | digitalWrite(self._sync, HIGH) 36 | 37 | def setVolts(self, volts): 38 | """ Sets the DAC output to the given voltage. """ 39 | value = int(volts/self.dv) 40 | self.set(value) 41 | 42 | 43 | class DAC5311(DACx311): 44 | # Untested 45 | n_bits = 8 46 | bit_shift = 6 47 | 48 | class DAC6311(DACx311): 49 | # Untested 50 | n_bits = 10 51 | bit_shift = 4 52 | 53 | class DAC7311(DACx311): 54 | # Tested working 55 | n_bits = 12 56 | bit_shift = 2 57 | 58 | class DAC8311(DACx311): 59 | # Untested 60 | n_bits = 14 61 | bit_shift = 0 62 | -------------------------------------------------------------------------------- /bbio/libraries/EventIO/README: -------------------------------------------------------------------------------- 1 | EventIO - v0.2 2 | 3 | Copyright 2012 Alexander Hiam 4 | 5 | EventIO provides basic multi-process event-driven programming 6 | for PyBBIO (https://github.com/alexanderhiam/PyBBIO). 7 | 8 | Documentation: 9 | https://github.com/alexanderhiam/PyBBIO/wiki/EventIO 10 | 11 | Example program: 12 | PyBBIO/examples/EventIO_test.py 13 | 14 | EventIO is released as part of PyBBIO under its MIT license. 15 | See PyBBIO/LICENSE.txt 16 | -------------------------------------------------------------------------------- /bbio/libraries/EventIO/__init__.py: -------------------------------------------------------------------------------- 1 | # EventIO - __init__.py 2 | # 3 | 4 | from eventio import * 5 | 6 | -------------------------------------------------------------------------------- /bbio/libraries/GridEYE/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's GridEYE library 2 | from GridEYE import GridEYE -------------------------------------------------------------------------------- /bbio/libraries/HTU21D/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's HTU21D library 2 | from HTU21D import HTU21D -------------------------------------------------------------------------------- /bbio/libraries/IoT/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for IoT PyBBIO library 2 | import thingspeak, phant 3 | 4 | __all__ = [ 5 | 'thingspeak', 'phant' 6 | ] -------------------------------------------------------------------------------- /bbio/libraries/LiquidCrystal/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's LiquidCrystal library 2 | from LiquidCrystal import LiquidCrystal -------------------------------------------------------------------------------- /bbio/libraries/MAX31855/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py file for PyBBIO's MAX31855 library 2 | 3 | from max31855 import MAX31855 4 | -------------------------------------------------------------------------------- /bbio/libraries/MAX31855/max31855.py: -------------------------------------------------------------------------------- 1 | """ 2 | MAX31855 3 | Copyright 2015 - Alexander Hiam 4 | 5 | A library for PyBBIO to interface with Maxim's MAX31855 thermocouple amplifier. 6 | 7 | MAX31855 is released as part of PyBBIO under its MIT license. 8 | See PyBBIO/LICENSE.txt 9 | """ 10 | 11 | class MAX31855(object): 12 | SPI_CLOCK_MODE = 1 13 | SPI_FREQUENCY = 4000000 14 | SPI_N_BITS = 32 15 | 16 | OPEN_CIRCUIT = 1 17 | SHORT_TO_GND = 2 18 | SHORT_TO_VCC = 4 19 | 20 | 21 | def __init__(self, spi_bus, spi_cs=0, offset=0): 22 | self.spi_bus = spi_bus 23 | self.spi_cs = spi_cs 24 | self.offset = offset 25 | self.error = None 26 | 27 | def readTempF(self): 28 | """ Reads temperature, converts to Fahrenheit and returns, or 29 | returns None if error detected. """ 30 | temp = self.readTempC() 31 | return temp if not temp else temp * 9.0/5.0 + 32 32 | 33 | def readTempC(self): 34 | """ Reads and returns the temperature in Celsius, or returns None 35 | if error detected. """ 36 | value = self.read() 37 | if value == None: return None 38 | # Extract 14-bit signed temperature value: 39 | temp = (value >> 18) & 0x3fff 40 | # Convert 2's complement: 41 | if temp >= 2**13: temp -= 2**14 42 | return temp*0.25 + self.offset 43 | 44 | def readTempInternal(self): 45 | """ Reads and returns the MAX31855 reference junction temperature 46 | in Celsius, or returns None if error detected. """ 47 | value = self.read() 48 | if value == None: return None 49 | temp = (value >> 4) & 0xfff 50 | # Convert 2's complement: 51 | if temp >= 2**11: temp -= 2**12 52 | return temp*0.0625 53 | 54 | def read(self): 55 | """ Receives and returns full 32-bit map from MAX31855, or sets 56 | self.error and returns None if fault detected. """ 57 | self.error = None 58 | 59 | # Configure SPI bus as required by the MAX31855: 60 | self.spi_bus.setClockMode(self.spi_cs, self.SPI_CLOCK_MODE) 61 | self.spi_bus.setMaxFrequency(self.spi_cs, self.SPI_FREQUENCY) 62 | self.spi_bus.setBitsPerWord(self.spi_cs, self.SPI_N_BITS) 63 | self.spi_bus.setMSBFirst(self.spi_cs) 64 | self.spi_bus.setCSActiveLow(self.spi_cs) 65 | 66 | value = self.spi_bus.read(self.spi_cs, 1)[0] 67 | 68 | if (value & (1<<16)): 69 | # Fault bit set, save error code and return None: 70 | self.error = value & 0b111 71 | return None 72 | 73 | return value 74 | -------------------------------------------------------------------------------- /bbio/libraries/MMA7660/README.md: -------------------------------------------------------------------------------- 1 | MMA7660 - v0.1 2 | 3 | Copyright 2014 Rekha Seethamraju rekha.kmit@gmail.com 4 | 5 | Library for controlling accelerometer MMA7660 with the Beaglebone Black's I2C's 6 | pins. 7 | 8 | See documentation here: 9 | https://github.com/alexanderhiam/PyBBIO/wiki/MMA7660 10 | As well as the included example programs: 11 | PyBBIO/examples/mma7660_test.py 12 | 13 | MMA7660 is released as part of PyBBIO under its MIT license. See PyBBIO/LICENSE.txt -------------------------------------------------------------------------------- /bbio/libraries/MMA7660/__init__.py: -------------------------------------------------------------------------------- 1 | from mma7660 import MMA7660 -------------------------------------------------------------------------------- /bbio/libraries/RotaryEncoder/README.md: -------------------------------------------------------------------------------- 1 | eQEP - v0.1 2 | 3 | Copyright 2014 Rekha Seethamraju 4 | rekha.kmit@gmail.com 5 | 6 | Library for controlling rotary encoder with the Beaglebone Black's eQEP pins. 7 | 8 | See documentation here: 9 | https://github.com/alexanderhiam/PyBBIO/wiki/eQEP 10 | As well as the included example programs: 11 | https://github.com/alexanderhiam/PyBBIO/examples/encoder_test.py 12 | 13 | eQEP is released as part of PyBBIO under its MIT license. 14 | See PyBBIO/LICENSE.txt 15 | -------------------------------------------------------------------------------- /bbio/libraries/RotaryEncoder/__init__.py: -------------------------------------------------------------------------------- 1 | #__init__.py for Rotary Encoder 2 | 3 | from rotary_encoder import RotaryEncoder 4 | -------------------------------------------------------------------------------- /bbio/libraries/SafeProcess/README: -------------------------------------------------------------------------------- 1 | SafeProcess - v0.1 2 | 3 | Copyright 2012 Alexander Hiam 4 | 5 | For PyBBIO - https://github.com/alexanderhiam/PyBBIO 6 | 7 | Provides a wrapper for Python's mutliprocessing.Process class 8 | which will be terminated during PyBBIO's cleanup. 9 | 10 | Documentation: 11 | https://github.com/alexanderhiam/PyBBIO/wiki/SafeProcess 12 | 13 | Example program: 14 | PyBBIO/examples/SafeProcess_test.py 15 | 16 | See the Python docs for multiprocessing.Process: 17 | http://docs.python.org/library/multiprocessing.html#multiprocessing.Process 18 | 19 | SafeProcess is released as part of PyBBIO under its MIT License 20 | license. See PyBBIO/LICENSE.txt 21 | 22 | -------------------------------------------------------------------------------- /bbio/libraries/SafeProcess/__init__.py: -------------------------------------------------------------------------------- 1 | # SafeProcess - __init__.py 2 | # 3 | 4 | from safe_process import * 5 | 6 | -------------------------------------------------------------------------------- /bbio/libraries/SafeProcess/safe_process.py: -------------------------------------------------------------------------------- 1 | """ 2 | SafeProcess - v0.1 3 | Copyright 2012 - Alexander Hiam 4 | MIT license 5 | 6 | Provides a wrapper for Python's mutliprocessing.Process class 7 | which will be terminated during PyBBIO's cleanup. 8 | """ 9 | 10 | from multiprocessing import Process 11 | from bbio import * 12 | 13 | 14 | class SafeProcess(Process): 15 | def __init__(self, group=None, target=None, name=None, args=(), kwargs={}): 16 | 17 | # This is the magic line: 18 | addToCleanup(lambda: self.terminate()) 19 | # This way the process will be terminated as part of PyBBIO's 20 | # cleanup routine. 21 | 22 | self.config() 23 | Process.__init__(self, group=group, target=target, name=name, 24 | args=args, kwargs=kwargs) 25 | 26 | def config(self): 27 | """ This function may be overriden by an inheriting class to handle any 28 | initialization that does not require any arguments be passed in. """ 29 | pass 30 | -------------------------------------------------------------------------------- /bbio/libraries/Servo/README: -------------------------------------------------------------------------------- 1 | Servo - v0.1 2 | 3 | Copyright 2012 Alexander Hiam 4 | 5 | Library for controlling servo motors with the BeagleBone's PWM pins. 6 | 7 | See documentation here: 8 | https://github.com/alexanderhiam/PyBBIO/wiki/Servo 9 | As well as the included example programs: 10 | PyBBIO/examples/Servo_sweep.py 11 | 12 | Based on the Arduino Servo library: 13 | http://www.arduino.cc/en/Reference/Servo 14 | 15 | Servo is released as part of PyBBIO under its MIT license. 16 | See PyBBIO/LICENSE.txt 17 | 18 | -------------------------------------------------------------------------------- /bbio/libraries/Servo/Servo.py: -------------------------------------------------------------------------------- 1 | """ 2 | Servo - v0.1 3 | Copyright 2012 Alexander Hiam 4 | 5 | Library for controlling servo motors with the BeagleBone's PWM pins. 6 | """ 7 | 8 | from bbio import * 9 | 10 | class Servo(object): 11 | def __init__(self, pwm_pin=None, pwm_freq=50, min_ms=0.5, max_ms=2.4): 12 | assert (pwm_freq > 0), "pwm_freq must be positive, given: %s" %\ 13 | str(pwm_freq) 14 | assert (min_ms > 0), "0 min_ms must be positive, given: %s" %\ 15 | str(min_ms) 16 | assert (max_ms > 0), "max_ms must be positive, given: %s" %\ 17 | str(max_ms) 18 | self.pwm_freq = pwm_freq 19 | self.min_ms = min_ms 20 | self.max_ms = max_ms 21 | self.pwm_pin = None 22 | if (pwm_pin): self.attach(pwm_pin) 23 | self.angle = None 24 | 25 | def attach(self, pwm_pin): 26 | """ Attach servo to PWM pin; alternative to passing PWM pin to 27 | __init__(). Can also be used to change pins. """ 28 | if (self.pwm_pin): 29 | # Already attached to a pin, detach first 30 | self.detach() 31 | self.pwm_pin = pwm_pin 32 | 33 | pwmFrequency(self.pwm_pin, self.pwm_freq) 34 | self.period_ms = 1000.0/self.pwm_freq 35 | 36 | def write(self, angle): 37 | """ Set the angle ofthe servo in degrees. """ 38 | if (angle < 0): angle = 0 39 | if(angle > 180): angle = 180 40 | value = (self.max_ms-self.min_ms)/180.0 * angle + self.min_ms 41 | analogWrite(self.pwm_pin, value, self.period_ms) 42 | self.angle= angle 43 | 44 | def read(self): 45 | """ return the current angle of the servo, or None if it has not 46 | yet been set. """ 47 | return self.angle 48 | 49 | def detach(self): 50 | """ Detaches the servo so so pin can be used for normal PWM 51 | operation. """ 52 | if (not self.pwm_pin): return 53 | pwmDisable(self.pwm_pin) 54 | self.pwm_pin = None 55 | self.angle = None 56 | -------------------------------------------------------------------------------- /bbio/libraries/Servo/__init__.py: -------------------------------------------------------------------------------- 1 | # __init__.py for Servo 2 | 3 | from Servo import * 4 | -------------------------------------------------------------------------------- /bbio/libraries/WebCam/README.md: -------------------------------------------------------------------------------- 1 | WebCam - v0.1 2 | Copyright 2014 Rekha Seethamraju 3 | rekha.kmit@gmail.com 4 | 5 | WebCam is a library for streaming video and taking a picture from a webcam 6 | connected to the beaglebone black. 7 | 8 | See documentation here: 9 | https://github.com/alexanderhiam/PyBBIO/wiki/WebCam 10 | As well as the included example programs: 11 | PyBBIO/examples/webcam_test.py 12 | PyBBIO/examples/webcam_bbioserver_test.py 13 | 14 | WebCam is released as part of PyBBIO under its MIT license. See PyBBIO/LICENSE.txt 15 | -------------------------------------------------------------------------------- /bbio/libraries/WebCam/__init__.py: -------------------------------------------------------------------------------- 1 | from webcam import WebCam -------------------------------------------------------------------------------- /bbio/libraries/__init__.py: -------------------------------------------------------------------------------- 1 | # bbio/libraries/__init__.py 2 | 3 | -------------------------------------------------------------------------------- /bbio/libraries/example.py: -------------------------------------------------------------------------------- 1 | # This is just an example to demonstrate libraries directory 2 | # scheme for PyBBIO. 3 | # To test: 4 | # run PyBBIO/tests/library_test.py 5 | 6 | 7 | def foo(): 8 | print "Hello, world!" 9 | 10 | 11 | -------------------------------------------------------------------------------- /bbio/platform/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | from platform import detect_platform 3 | _platform = detect_platform() 4 | 5 | if "BeagleBone" in _platform: 6 | from beaglebone import * 7 | import beaglebone 8 | 9 | #elif "SomeOtherPlatform" in _platform: 10 | # ... 11 | 12 | else: 13 | # Unsupported platform 14 | raise ImportError("Cannot import PyBBIO, platform not supported") 15 | 16 | # No need to keep this in the namespace: 17 | del _platform 18 | -------------------------------------------------------------------------------- /bbio/platform/beaglebone/adc.py: -------------------------------------------------------------------------------- 1 | # adc.py 2 | # Part of PyBBIO 3 | # github.com/graycatlabs/PyBBIO 4 | # MIT License 5 | # 6 | # Beaglebone ADC driver for kernels >= 3.8. 7 | # 8 | # Just a wrapper for the sysfs ADC driver for the time being. 9 | 10 | import os, glob, bbio 11 | import cape_manager 12 | from config import ADC, ADC_ENABLE_DTS_OVERLAY 13 | 14 | _ADC_INITIALIZED = False 15 | 16 | def analog_init(): 17 | """ Initializes the on-board 8ch 12bit ADC. """ 18 | pass 19 | 20 | def analog_cleanup(): 21 | pass 22 | 23 | def analogRead(adc_pin): 24 | """ Returns voltage read on given analog input pin. If passed one of 25 | PyBBIO's AIN0-AIN5 keywords the voltage will be returned in millivolts. 26 | May also be passed the path to an AIN file as created by a cape overlay, 27 | in which case the value will be returned as found in the file. """ 28 | global _ADC_INITIALIZED 29 | if not _ADC_INITIALIZED: 30 | cape_manager.load(ADC_ENABLE_DTS_OVERLAY, auto_unload=False) 31 | # Don't unload the overlay on exit for now because it can 32 | # cause kernel panic. 33 | bbio.delay(100) 34 | _ADC_INITIALIZED = True 35 | if adc_pin in ADC: 36 | adc_pin = ADC[adc_pin] 37 | adc_file = glob.glob(adc_pin[0]) 38 | if len(adc_file) == 0: 39 | overlay = adc_pin[1] 40 | # Overlay not loaded yet 41 | cape_manager.load(overlay, auto_unload=False) 42 | adc_file = glob.glob(adc_pin[0]) 43 | else: 44 | adc_file = glob.glob(adc_pin) 45 | if len(adc_file) == 0: 46 | raise Exception('*Could not load overlay for adc_pin: %s' % adc_pin) 47 | adc_file = adc_file[0] 48 | # Occasionally the kernel will be writing to the file when you try 49 | # to read it, to avoid IOError try up to 5 times: 50 | for i in range(5): 51 | try: 52 | with open(adc_file, 'rb') as f: 53 | val = f.read() 54 | return int(val) 55 | except IOError: 56 | continue 57 | raise Exception('*Could not open AIN file: %s' % adc_file) 58 | 59 | 60 | def inVolts(mv): 61 | """ Converts millivolts to volts... you know, to keep the API 62 | consistent. """ 63 | return mv/1000.0 64 | 65 | -------------------------------------------------------------------------------- /bbio/platform/beaglebone/api.py: -------------------------------------------------------------------------------- 1 | # api.py 2 | # Part of PyBBIO 3 | # github.com/graycatlabs/PyBBIO 4 | # MIT License 5 | # 6 | # Beaglebone platform API file. 7 | 8 | from adc import analog_init, analog_cleanup 9 | from pwm import pwm_init, pwm_cleanup 10 | from serial_port import serial_cleanup 11 | from gpio import gpioCleanup 12 | 13 | def platform_init(): 14 | analog_init() 15 | pwm_init() 16 | 17 | def platform_cleanup(): 18 | analog_cleanup() 19 | pwm_cleanup() 20 | serial_cleanup() 21 | gpioCleanup() 22 | 23 | -------------------------------------------------------------------------------- /bbio/platform/beaglebone/cape_manager.py: -------------------------------------------------------------------------------- 1 | # cape_manager.py 2 | # Part of PyBBIO 3 | # github.com/graycatlabs/PyBBIO 4 | # MIT License 5 | # 6 | # Beaglebone Cape Manager driver 7 | # For Beaglebone's with 3.8 kernel or greater 8 | 9 | from bbio.platform.beaglebone.config import SLOTS_FILE 10 | from bbio.common import addToCleanup 11 | 12 | def isLoaded(overlay): 13 | """ Returns True if the given overlay is loaded, False if not. """ 14 | with open(SLOTS_FILE, 'rb') as f: 15 | capes = f.read() 16 | if (',%s\n' % overlay) in capes: 17 | # already loaded 18 | return True 19 | return False 20 | 21 | def load(overlay, auto_unload=True): 22 | """ Attempt to load an overlay with the given name. If auto_unload=True it 23 | will be auto-unloaded at program exit (the current cape manager crashes 24 | when trying to unload certain overlay fragments). """ 25 | if isLoaded(overlay): return 26 | with open(SLOTS_FILE, 'wb') as f: 27 | f.write(overlay) 28 | if auto_unload: 29 | addToCleanup(lambda: unload(overlay)) 30 | 31 | def unload(overlay): 32 | """ Unload the first overlay matching the given name if present. Returns 33 | True if successful, False if no mathcing overlay loaded. """ 34 | with open(SLOTS_FILE, 'rb') as f: 35 | slots = f.readlines() 36 | for slot in slots: 37 | if overlay in slot: 38 | load('-%i' % int(slot.split(':')[0]), auto_unload=False) 39 | return True 40 | return False 41 | -------------------------------------------------------------------------------- /bbio/platform/beaglebone/i2c.py: -------------------------------------------------------------------------------- 1 | # i2c.py 2 | # Part of PyBBIO 3 | # github.com/graycatlabs/PyBBIO 4 | # MIT License 5 | # 6 | # Beaglebone i2c driver 7 | 8 | import bbio, cape_manager, os, glob, serbus 9 | from config import I2C_BASE_ADDRESSES 10 | 11 | class I2CBus(serbus.I2CDev): 12 | def __init__(self, bus): 13 | assert 1<= bus <= 2, 'Only I2C buses 1 and 2 are available' 14 | # Run serbus.I2CDev initializtion: 15 | super(I2CBus, self).__init__(bus) 16 | self._is_open = False 17 | 18 | def open(self, use_10bit_address=False): 19 | """ I2CDev.open(use_10bit_address=False) -> None 20 | 21 | Initialize the I2C bus interface. 22 | If use_10bit_address=True the bus will use 10-bit slave addresses 23 | instead of 7-bit addresses. 24 | """ 25 | if self._is_open: return 26 | if self.bus_num == 1 and not cape_manager.isLoaded("BB-I2C1"): 27 | # I2C2 is already enabled for reading cape EEPROMs, 28 | # so only need to load overlay for I2C1 29 | cape_manager.load("BB-I2C1", auto_unload=False) 30 | bbio.common.delay(10) 31 | # Make sure it initialized correctly: 32 | if not cape_manager.isLoaded("BB-I2C1"): 33 | raise IOError("could not enable I2C1") 34 | 35 | # Detect bus number: 36 | # (since I2C2 is always enabled at boot, it's kernel assigned 37 | # bus number will always be the same, and I2C1 will always be 38 | # the next consecutive bus number, so this isn't actually 39 | # required) 40 | for i in glob.glob("/sys/bus/i2c/devices/i2c-*"): 41 | path = os.path.realpath(i) 42 | module_addr = int(path.split("/")[4].split(".")[0], 16) 43 | if module_addr == I2C_BASE_ADDRESSES[self.bus_num]: 44 | self.bus_num = int(path.split("/")[5][-1]) 45 | break 46 | 47 | super(I2CBus, self).open(use_10bit_address=use_10bit_address) 48 | self._is_open = True 49 | 50 | def begin(self, use_10bit_address=False): 51 | """ Same as I2CBus.open() """ 52 | self.open(use_10bit_address=use_10bit_address) 53 | 54 | def end(self): 55 | """ Same as I2CBus.close() """ 56 | self.close() 57 | 58 | def i2c_cleanup(): 59 | """ Closes all open i2c buses. """ 60 | Wire1.close() 61 | Wire2.close() 62 | 63 | Wire1 = I2C1 = I2CBus(1) 64 | Wire2 = I2C2 = I2CBus(2) 65 | -------------------------------------------------------------------------------- /bbio/platform/beaglebone/spi.py: -------------------------------------------------------------------------------- 1 | # spi.py 2 | # Part of PyBBIO 3 | # github.com/graycatlabs/PyBBIO 4 | # MIT License 5 | 6 | import cape_manager, bbio, os, glob, serbus 7 | from config import SPI_BASE_ADDRESSES 8 | 9 | class SPIBus(serbus.SPIDev): 10 | def __init__(self, bus): 11 | super(SPIBus, self).__init__(bus) 12 | self._is_open = False 13 | 14 | def open(self): 15 | if self._is_open: return 16 | 17 | overlay = "BB-SPIDEV%i" % (self.bus) 18 | cape_manager.load(overlay, auto_unload=False) 19 | bbio.common.delay(250) # Give driver time to load 20 | assert cape_manager.isLoaded(overlay), "Could not load SPI overlay" 21 | 22 | for i in glob.glob("/sys/bus/spi/devices/*.0"): 23 | path = os.path.realpath(i) 24 | module_addr = int(path.split("/")[4].split(".")[0], 16) 25 | if module_addr == SPI_BASE_ADDRESSES[self.bus]: 26 | self.bus = int(path.split("/")[6][-1]) 27 | break 28 | super(SPIBus, self).open() 29 | # Initialize to default parameters: 30 | self.setCSActiveLow(0) 31 | self.setBitsPerWord(0, 8) 32 | self.setMaxFrequency(0, 8000000) 33 | self.setClockMode(0, 0) 34 | 35 | self._is_open = True 36 | 37 | def begin(self): 38 | self.open() 39 | 40 | def end(self): 41 | self.close() 42 | 43 | # Initialize the global SPI instances: 44 | SPI0 = SPIBus(0) 45 | SPI1 = SPIBus(1) 46 | -------------------------------------------------------------------------------- /bbio/platform/platform.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def detect_platform(): 4 | """ Attempt to detect the current platform. Returns one of: 'BeagleBone 3.2', 5 | 'BeagleBone >=3.8'. """ 6 | platform = '' 7 | with open('/proc/cpuinfo', 'rb') as f: 8 | cpuinfo = f.read().lower() 9 | if ('armv7' in cpuinfo and 10 | ('am335x' in cpuinfo or 'am33xx' in cpuinfo)): 11 | platform = 'BeagleBone' 12 | 13 | import commands 14 | uname_status, uname = commands.getstatusoutput('uname -a') 15 | if uname_status > 0: 16 | exit('uname failed, cannot detect kernel version! uname output:\n %s' % uname) 17 | if ('3.2' in uname): 18 | platform += ' 3.2' 19 | else: 20 | platform += ' >=3.8' 21 | 22 | return platform 23 | -------------------------------------------------------------------------------- /bbio/platform/util/__init__.py: -------------------------------------------------------------------------------- 1 | # bbio.platform.util -------------------------------------------------------------------------------- /bbio/platform/util/mmap_util.c: -------------------------------------------------------------------------------- 1 | /* mmap_uitl.c 2 | * Part of PyBBIO 3 | * MIT License 4 | * 5 | * A C utility for memory access through mmap. 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include "mmap_util.h" 16 | 17 | struct memory { 18 | int fd; 19 | int size; 20 | uint8_t *map; 21 | }; 22 | 23 | static int mmap_exists = 0; 24 | static struct memory *_mmap; 25 | 26 | int mmapInit(char *fn, memaddr offset, memaddr size) { 27 | int fd; 28 | uint8_t *map; 29 | if (mmap_exists) return 0; 30 | fd = open(fn, O_RDWR); 31 | if (fd < 0) return 0; 32 | map = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset); 33 | if (map == MAP_FAILED) return 0; 34 | _mmap = malloc(sizeof(struct memory*)); 35 | _mmap->fd = fd; 36 | _mmap->map = map; 37 | mmap_exists = 1; 38 | return 1; 39 | } 40 | 41 | void mmapClose(void) { 42 | // Todo: handle and report unmapping/freeing errors 43 | if (mmap_exists) { 44 | munmap(_mmap->map, _mmap->size); 45 | close(_mmap->fd); 46 | free(_mmap); 47 | mmap_exists = 0; 48 | } 49 | } 50 | 51 | uint _getReg(memaddr address, int order, int bytes) { 52 | int i, bits; 53 | uint value; 54 | if(!mmap_exists) return 0; 55 | bits = bytes*8; 56 | value = 0; 57 | for (i=0; imap[address+i] << (bits-(i<<3))); 60 | } 61 | else value |= (uint) (_mmap->map[address+i] << (i<<3)); 62 | } 63 | return value; 64 | } 65 | 66 | void _setReg(memaddr address, uint value, int order, int bytes) { 67 | int i, bits; 68 | if(!mmap_exists) return; 69 | bits = bytes*8; 70 | for (i=0; imap[address+i] = (uint8_t) ((value >> (bits-(i<<3))) & 0xff); 73 | } 74 | else _mmap->map[address+i] = ((uint8_t) (value >> (i<<3)) & 0xff); 75 | } 76 | } 77 | 78 | -------------------------------------------------------------------------------- /bbio/platform/util/mmap_util.h: -------------------------------------------------------------------------------- 1 | /* mmap_uitl.h 2 | * Part of PyBBIO 3 | * MIT License 4 | * 5 | * A C utility for memory access through mmap. 6 | */ 7 | 8 | #ifndef _MMAP_UTIL_H 9 | #define _MMAP_UTIL_H 10 | 11 | #define LITTLEENDIAN 0 12 | #define BIGENDIAN 1 13 | 14 | typedef unsigned long memaddr; 15 | typedef unsigned int uint; 16 | 17 | int mmapInit(char *fn, memaddr offset, memaddr size); 18 | /* Attempts to initialize mmap with given parameters. Returns 1 if 19 | * successful, 0 otherwise. 20 | */ 21 | 22 | void mmapClose(void); 23 | /* Closes mmap. Should be called before program exit. 24 | */ 25 | 26 | uint _getReg(memaddr address, int order, int bytes); 27 | /* Returns given number of bytes starting at given address with given 28 | * endianness. 29 | */ 30 | 31 | void _setReg(memaddr address, uint value, int order, int bytes); 32 | /* Sets memory from address to address+bytes to the given value using 33 | * the given byte ordering. 34 | */ 35 | 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /bbio/platform/util/sysfs.h: -------------------------------------------------------------------------------- 1 | /* sysfs.h 2 | * 3 | * Provides C and Python functions to read and write kernel driver sysfs 4 | * interface files. 5 | * 6 | * Part of PyBBIO - https://github.com/graycatlabs/PyBBIO 7 | * Copyright (c) 2014 - Alexander Hiam 8 | * 9 | * Permission is hereby granted, free of charge, to any person obtaining a copy 10 | * of this software and associated documentation files (the "Software"), to deal 11 | * in the Software without restriction, including without limitation the rights 12 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 13 | * copies of the Software, and to permit persons to whom the Software is 14 | * furnished to do so, subject to the following conditions: 15 | * 16 | * The above copyright notice and this permission notice shall be included in 17 | * all copies or substantial portions of the Software. 18 | * 19 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 22 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 25 | * THE SOFTWARE. 26 | */ 27 | 28 | #ifndef _SYSFS_H_ 29 | #define _SYSFS_H_ 30 | 31 | #include "Python.h" 32 | 33 | // Maximum number of bytes to read from file in kernelFileIO(): 34 | #define READ_BUFFER_LENGTH 128 35 | 36 | // Returns first real path found given path with '*' wildcards, or empty string 37 | // if no path found. The path string is created with calloc(), and therefore 38 | // the returned char* must be passed to free() eventually. 39 | char *getFirstGlobMatch(char *path); 40 | 41 | // Writes the given value to the file at the given path. The path may contain 42 | // '*' wildcards. Returns 0 if successful, errno error code otherwise. 43 | int kernelFileWrite(char *filename, char *value); 44 | 45 | // Copies up to result_len-1 of the the contents of the file at the given path 46 | // followed by a null-character to the given result buffer. The path may 47 | // contain '*' wildcards. Returns 0 if successful, errno error code otherwise. 48 | int kernelFileRead(char *filename, char *result, int result_len); 49 | 50 | #endif -------------------------------------------------------------------------------- /code_of_conduct.md: -------------------------------------------------------------------------------- 1 | # Contributor Code of Conduct 2 | 3 | As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities. 4 | 5 | We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality. 6 | 7 | Examples of unacceptable behavior by participants include: 8 | 9 | * The use of sexualized language or imagery 10 | * Personal attacks 11 | * Trolling or insulting/derogatory comments 12 | * Public or private harassment 13 | * Publishing other's private information, such as physical or electronic addresses, without explicit permission 14 | * Other unethical or unprofessional conduct 15 | 16 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. 17 | 18 | By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team. 19 | 20 | This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. 21 | 22 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a project maintainer at . All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. Maintainers are obligated to maintain confidentiality with regard to the reporter of an incident. 23 | 24 | This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.3.0, available at [http://contributor-covenant.org/version/1/3/0/](http://contributor-covenant.org/version/1/3/0/) 25 | -------------------------------------------------------------------------------- /doinstall.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | /usr/bin/yes | pip uninstall PyBBIO 4 | rm -r build/ dist/ 5 | python setup.py install 6 | -------------------------------------------------------------------------------- /examples/ADS786x_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | ADS786x_test.py 3 | Alexander Hiam - 12/2012 4 | 5 | Example program for PyBBIO's ADS786x library. 6 | 7 | This example program is in the public domain. 8 | """ 9 | 10 | from bbio import * 11 | from bbio.libraries.ADS786x import * 12 | 13 | # Set variables for the pins connected to the ADC: 14 | data_pin = GPIO1_15 # P8.15 15 | clk_pin = GPIO1_14 # P8.16 16 | cs_pin = GPIO0_27 # P8.17 17 | 18 | # Create an instance of the ADC class: 19 | adc = ADS7866(data_pin, clk_pin, cs_pin) 20 | 21 | def setup(): 22 | # Nothing to do here, the ADS786x class sets pin modes 23 | pass 24 | 25 | def loop(): 26 | # Read the voltage and print it to the terminal: 27 | voltage = adc.readVolts() 28 | print "%0.3f V" % voltage 29 | delay(1000) 30 | 31 | 32 | run(setup, loop) 33 | -------------------------------------------------------------------------------- /examples/ADXL345_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | ADXL345_test.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the ADXL345 library included 6 | with PyBBIO. Interfaces with the ADXL345 3-axis I2C or SPI accelerometer. 7 | 8 | This example program is in the public domain. 9 | """ 10 | 11 | from bbio import * 12 | # Import the ADXL345 class from the ADXL345 library: 13 | from bbio.libraries.ADXL345 import ADXL345 14 | 15 | # To use the ADXL345 in I2C mode the SPI CS pin needs to be held high. 16 | # To ensure CS is high, it can either be wired to 3.3V, or it can be 17 | # wired to a GPIO pin and the pin set high: 18 | CS_GPIO = GPIO3_17 19 | pinMode(CS_GPIO, OUTPUT) 20 | digitalWrite(CS_GPIO, HIGH) 21 | # After setting CS high, wait a bit to give the ADXL345 time to boot: 22 | delay(100) 23 | 24 | # Initialize the I2C port the ADXL345 is attached to: 25 | I2C2.open() 26 | # Initialize the ADXL345: 27 | accel = ADXL345(I2C2) 28 | 29 | def setup(): 30 | # The default range is +/-2 G, set to +/-8 G: 31 | accel.setRange(accel.RANGE_8G) 32 | 33 | def loop(): 34 | x, y, z = accel.getXYZ() 35 | print "{:+0.2f}G {:+0.2f}G {:+0.2f}G".format(x, y, z) 36 | delay(100) 37 | 38 | run(setup, loop) -------------------------------------------------------------------------------- /examples/BMP183_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | BMP183_test.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the BMP183 library included 6 | with PyBBIO. Interfaces with the BMP183 SPI pressure sensor to 7 | measure the atmospheric pressure and ambient temperature. 8 | 9 | This example program is in the public domain. 10 | """ 11 | 12 | from bbio import * 13 | # Import the BMP183 class from the BMP183 library: 14 | from bbio.libraries.BMP183 import BMP183 15 | 16 | # Create a new instance of the BMP183 class using SPI0 with the 17 | # default CS0 chip select pin: 18 | bmp = BMP183(SPI0) 19 | 20 | def setup(): 21 | # The BMP183 is initialized when the BMP183 class is instantiated, 22 | # so there's nothing to do here 23 | pass 24 | 25 | def loop(): 26 | # Get the current temperature in Celsius: 27 | temp = bmp.getTemp() 28 | # Get the current pressure in Pascals: 29 | pressure = bmp.getPressure() 30 | 31 | print "\ntemperature : %0.2f C" % temp 32 | print "pressure : %i Pa" % pressure 33 | 34 | delay(5000) 35 | 36 | run(setup, loop) -------------------------------------------------------------------------------- /examples/DACx311_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | DACx311.py 3 | Alexander Hiam - 11/2012 4 | 5 | Example program for PyBBIO's DACx311 library to 6 | output a triangle wave. 7 | 8 | This example program is in the public domain. 9 | """ 10 | 11 | from bbio import * 12 | from bbio.libraries.DACx311 import * 13 | 14 | # Set variables for the pins connected to the DAC: 15 | data_pin = GPIO1_6 # P8.3 16 | clk_pin = GPIO1_7 # P8.4 17 | sync_pin = GPIO1_2 # P8.5 18 | 19 | # Create an instance of the DAC class: 20 | dac = DAC7311(data_pin, clk_pin, sync_pin) 21 | 22 | # Set a few global variables: 23 | volts = 0.0 # Initial voltage 24 | increment = 0.1 # Ammount to increment volts by each time 25 | pause = 75 # ms to wait between each increment 26 | 27 | def setup(): 28 | # Nothing to do here, the DACx311 class sets pin modes 29 | pass 30 | 31 | def loop(): 32 | global volts, increment 33 | # Set voltage in volts and increment: 34 | dac.setVolts(volts) 35 | volts += increment 36 | 37 | # If at upper or lower limit, negate the incrememnt value: 38 | if((volts >= 3.3) or (volts <= 0)): 39 | # Notice here that it's still possible that volts is either 40 | # above 3.3 or below 0, and it won't be incremented again until 41 | # after the DAC is next set. That's OK though, because values 42 | # passed to the DACx311 class are checked and constrained to 43 | # within this range. 44 | increment = -increment 45 | 46 | # Wait a bit: 47 | delay(10) 48 | 49 | # Run the program: 50 | run(setup, loop) 51 | -------------------------------------------------------------------------------- /examples/EventIO_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | """ 3 | EventIO_test.py 4 | Alexander Hiam 5 | 6 | An example to demonstrate the use of the EventIO library 7 | for PyBBIO. 8 | 9 | Example circuit: 10 | -A switch from 3.3v (P9.3) to GPIO1_7 (P8.4) with a 10k pull-down 11 | resistor to GND (P9.2) 12 | 13 | -A switch from 3.3v to GPIO1_3 (P8.6) with a 10k pull-down resistor. 14 | 15 | -A voltage divider with two equal resistors around 10k between 3.3v 16 | and GND to make about 1.6v 17 | 18 | -A potentiometer with the two outer pins connected to the 1.6v output 19 | of the voltage divider and GND, and the center wiper pin connected to 20 | AIN0 (P9.39). 21 | 22 | This example program is in the public domain. 23 | """ 24 | 25 | # First we import PyBBIO: 26 | from bbio import * 27 | # Then we can import EventIO: 28 | from bbio.libraries.EventIO import * 29 | 30 | sw1 = GPIO1_7 31 | sw2 = GPIO1_3 32 | pot = AIN0 33 | 34 | # Create an event loop: 35 | event_loop = EventLoop() 36 | 37 | #--- The events to be triggered: --- 38 | def event1(): 39 | toggle(USR1) 40 | return EVENT_CONTINUE 41 | 42 | def event2(): 43 | toggle(USR2) 44 | return EVENT_CONTINUE 45 | 46 | def event3(): 47 | digitalWrite(USR3, HIGH) 48 | return EVENT_CONTINUE 49 | 50 | def event4(): 51 | digitalWrite(USR3, LOW) 52 | return EVENT_CONTINUE 53 | #----------------------------------- 54 | 55 | def setup(): 56 | # This sets sw1 to trigger event1 when pressed with a debounce 57 | # time of 50ms: 58 | event_loop.add_event(DigitalTrigger(sw1, HIGH, event1, 50)) 59 | 60 | # This sets sw2 to trigger event2 when pressed with a debounce 61 | # time of 270ms: 62 | event_loop.add_event(DigitalTrigger(sw2, HIGH, event2, 270)) 63 | 64 | # This sets event3 to be called when the value on pot is above 65 | # 1820: 66 | event_loop.add_event(AnalogLevel(pot, 1820, event3)) 67 | 68 | # This sets event3 to be called when the value on pot is below 69 | # 1820: 70 | event_loop.add_event(AnalogLevel(pot, 1820, event4, direction=-1)) 71 | 72 | # Then start the event loop: 73 | event_loop.start() 74 | 75 | def loop(): 76 | # Because the event loop is run as a seperate process, this will 77 | # be executed normally. 78 | print "Time running: %ims" % int(millis()) 79 | delay(3000) 80 | 81 | run(setup, loop) 82 | # As soon as ctrl-c is pressed the event loop process will be 83 | # automatically termintated and the program wil exit happily. 84 | -------------------------------------------------------------------------------- /examples/GridEYE_save_image.py: -------------------------------------------------------------------------------- 1 | """ 2 | GridEYE_test.py 3 | Alexander Hiam 4 | 5 | Example program for PyBBIO's GridEYE library. Reads the current 6 | thermal sensor data and saves to thermal-image.png in the current 7 | directory. 8 | 9 | Requires the Python Imaging Library: 10 | # pip install PIL 11 | 12 | This example program is in the public domain. 13 | """ 14 | 15 | from bbio import * 16 | from bbio.libraries.GridEYE import GridEYE 17 | from PIL import Image 18 | import colorsys 19 | 20 | # Width and height of final image, 8x8 thermal image scaled to this size: 21 | WIDTH = 600 22 | HEIGHT = 600 23 | 24 | I2C1.open() 25 | grideye = GridEYE(I2C1) 26 | # Enable the GridEYE's built-in moving average: 27 | grideye.enableAveraging() 28 | 29 | 30 | def generateImage(frame): 31 | min_temp = min(frame) 32 | max_temp = max(frame) 33 | 34 | for i in range(64): 35 | # Map temperature value to ratio of min and max temp: 36 | frame[i] -= min_temp 37 | frame[i] /= (max_temp - min_temp) 38 | 39 | # Convert ratio to (R, G, B): 40 | frame[i] = colorsys.hsv_to_rgb(1-frame[i], 1, 1) 41 | frame[i] = tuple(map(lambda x: int(255*x), frame[i])) 42 | 43 | image = Image.new("RGB", (8, 8)) 44 | image.putdata(frame) 45 | image = image.resize((WIDTH,HEIGHT), Image.BILINEAR) 46 | image.save("thermal-image.png") 47 | 48 | def setup(): 49 | pass 50 | 51 | def loop(): 52 | frame = grideye.getFrame() 53 | generateImage(frame) 54 | stop() 55 | 56 | 57 | run(setup, loop) 58 | -------------------------------------------------------------------------------- /examples/GridEYE_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | GridEYE_test.py 3 | Alexander Hiam 4 | 5 | Example program for PyBBIO's GridEYE library. 6 | 7 | This example program is in the public domain. 8 | """ 9 | 10 | from bbio import * 11 | from bbio.libraries.GridEYE import GridEYE 12 | 13 | # Initialize the I2C bus: 14 | I2C1.open() 15 | # Create a GridEYE object: 16 | grideye = GridEYE(I2C1) 17 | 18 | ambient = grideye.getAmbientTemp() 19 | frame = grideye.getFrame() 20 | 21 | print "ambient temp: {:0.1f}C".format(ambient) 22 | print "sensor temp:" 23 | for y in range(8): 24 | string = "" 25 | for x in range(8): 26 | string += " {:5.1f}".format(frame[y*8+x]) 27 | print string -------------------------------------------------------------------------------- /examples/HTU21D_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | HTU21D_test.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the HTU21D library included 6 | with PyBBIO. Interfaces with the HTU21D I2C relative humidity sensor. 7 | 8 | This example program is in the public domain. 9 | """ 10 | 11 | from bbio import * 12 | # Import the HTU21D class from the HTU21D library: 13 | from bbio.libraries.HTU21D import HTU21D 14 | 15 | # Initialize I2C bus: 16 | I2C2.open() 17 | # Create a new instance of the HTU21D class using the I2C2 I2C bus 18 | htu = HTU21D(I2C2) 19 | 20 | def setup(): 21 | # The HTU21D is initialized when the HTU21D class is instantiated, 22 | # so there's nothing to do here 23 | pass 24 | 25 | def loop(): 26 | # Read the current relative humidity: 27 | rh = htu.getHumidity() 28 | # Read the current ambient temperature: 29 | temp = htu.getTemp() 30 | # Calculate the current dew point: 31 | dew_point = htu.calculateDewPoint(rh, temp) 32 | 33 | print "\nrelative humidity : %0.2f %%" % rh 34 | print "temperature : %0.2f C" % temp 35 | print "dew point : %0.2f C" % dew_point 36 | 37 | delay(2000) 38 | 39 | run(setup, loop) -------------------------------------------------------------------------------- /examples/LiquidCrystal_clock.py: -------------------------------------------------------------------------------- 1 | """ 2 | LiquidCrystal_clock.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the LiquidCrystal library 6 | included with PyBBIO. Displays the date and time on a 16x2 character 7 | LCD. 8 | 9 | This example program is in the public domain. 10 | """ 11 | from bbio import * 12 | # Import the LiquidCrystal class from the LiquidCrystal library: 13 | from bbio.libraries.LiquidCrystal import LiquidCrystal 14 | from time import strftime 15 | 16 | RS_PIN = GPIO0_30 17 | RW_PIN = GPIO0_31 18 | EN_PIN = GPIO1_16 19 | D4_PIN = GPIO0_5 20 | D5_PIN = GPIO0_13 21 | D6_PIN = GPIO0_3 22 | D7_PIN = GPIO1_17 23 | 24 | lcd = LiquidCrystal(RS_PIN, RW_PIN, EN_PIN, D4_PIN, D5_PIN, D6_PIN, D7_PIN) 25 | 26 | last_date = '' 27 | last_time = '' 28 | 29 | def setup(): 30 | lcd.begin(16, 2) # (columns, rows) 31 | 32 | def loop(): 33 | global last_date, last_time 34 | date = strftime("%x") # date in locale's standard format 35 | time = strftime("%X") # time in locale's standard format 36 | 37 | if date != last_date or time != last_time: 38 | # Only update the display if the date or time has changed. This 39 | # reduces the flicker you see when repeatedly writing the same 40 | # string. 41 | lcd.clear() # clear the screen 42 | lcd.home() # return to column 0, row 0 43 | lcd.prints(date) 44 | lcd.goto(0, 1) # go to column 0, row 1 45 | lcd.prints(time) 46 | last_date = date 47 | last_time = time 48 | delay(10) 49 | 50 | run(setup, loop) -------------------------------------------------------------------------------- /examples/LiquidCrystal_fps.py: -------------------------------------------------------------------------------- 1 | """ 2 | LiquidCrystal_fps.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the LiquidCrystal library 6 | included with PyBBIO. Calculated and displays the approximate maximum 7 | refresh rate when writing all characters on a 16x2 LCD. 8 | 9 | This example program is in the public domain. 10 | """ 11 | from bbio import * 12 | from bbio.libraries.LiquidCrystal import LiquidCrystal 13 | import string, time 14 | 15 | RS_PIN = GPIO0_30 16 | RW_PIN = GPIO0_31 17 | EN_PIN = GPIO1_16 18 | D4_PIN = GPIO0_5 19 | D5_PIN = GPIO0_13 20 | D6_PIN = GPIO0_3 21 | D7_PIN = GPIO1_17 22 | 23 | lcd = LiquidCrystal(RS_PIN, RW_PIN, EN_PIN, D4_PIN, D5_PIN, D6_PIN, D7_PIN) 24 | 25 | def setup(): 26 | lcd.begin(16, 2) # (columns, rows) 27 | 28 | def loop(): 29 | alphabet = string.lowercase 30 | line1 = alphabet[:16] 31 | line2 = alphabet[16:]+"012345" 32 | n_frames = 100 # number of frames to write 33 | start_time = time.time() 34 | for i in range(n_frames): 35 | lcd.clear() 36 | lcd.home() 37 | lcd.prints(line1) 38 | lcd.goto(0, 1) 39 | lcd.prints(line2) 40 | duration = time.time() - start_time 41 | fps = n_frames / duration 42 | lcd.clear() 43 | lcd.home() 44 | lcd.prints("refresh rate:") 45 | lcd.goto(0, 1) 46 | lcd.prints("%0.1f fps" % fps) 47 | exit() 48 | 49 | run(setup, loop) -------------------------------------------------------------------------------- /examples/LiquidCrystal_glyphs.py: -------------------------------------------------------------------------------- 1 | """ 2 | LiquidCrystal_glyph.py 3 | Alexander Hiam 4 | 5 | An example to demonstrate the use of the LiquidCrystal library 6 | included with PyBBIO. Demonstrates creating and displaying custom 7 | characters. 8 | 9 | This example program is in the public domain. 10 | """ 11 | from bbio import * 12 | # Import the LiquidCrystal class from the LiquidCrystal library: 13 | from bbio.libraries.LiquidCrystal import LiquidCrystal 14 | 15 | RS_PIN = GPIO0_30 16 | RW_PIN = GPIO0_31 17 | EN_PIN = GPIO1_16 18 | D4_PIN = GPIO0_5 19 | D5_PIN = GPIO0_13 20 | D6_PIN = GPIO0_3 21 | D7_PIN = GPIO1_17 22 | 23 | lcd = LiquidCrystal(RS_PIN, RW_PIN, EN_PIN, D4_PIN, D5_PIN, D6_PIN, D7_PIN) 24 | 25 | # This is how the custom 5x8 characters are defined: 26 | glyph0 = [ 27 | 0b00000, 28 | 0b00000, 29 | 0b01110, 30 | 0b10001, 31 | 0b10010, 32 | 0b10001, 33 | 0b01110, 34 | 0b00000, 35 | ] 36 | 37 | glyph1 = [ 38 | 0b00000, 39 | 0b00000, 40 | 0b01110, 41 | 0b10001, 42 | 0b01001, 43 | 0b10001, 44 | 0b01110, 45 | 0b00000, 46 | ] 47 | 48 | glyph2 = [ 49 | 0b00000, 50 | 0b01110, 51 | 0b10001, 52 | 0b11011, 53 | 0b10001, 54 | 0b11011, 55 | 0b10101, 56 | 0b00000, 57 | ] 58 | 59 | def setup(): 60 | lcd.begin(16, 2) # (columns, rows) 61 | # Load the custom glyphs into the display's RAM: 62 | lcd.createGlyph(0, glyph0) 63 | lcd.createGlyph(1, glyph1) 64 | lcd.createGlyph(2, glyph2) 65 | 66 | def loop(): 67 | lcd.clear() 68 | lcd.home() 69 | lcd.scrollDisplay(-5) 70 | for i in range(3): 71 | # Tell the display to put the given glyph at the current location: 72 | lcd.displayGlyph(2) 73 | lcd.scrollCursor(1) 74 | lcd.displayGlyph(0) 75 | 76 | for i in range(21): 77 | lcd.scrollDisplay(1) 78 | delay(400) 79 | delay(200) 80 | 81 | lcd.clear() 82 | lcd.goto(16,1) 83 | for i in range(3): 84 | lcd.displayGlyph(2) 85 | lcd.scrollCursor(1) 86 | lcd.displayGlyph(1) 87 | 88 | for i in range(21): 89 | lcd.scrollDisplay(-1) 90 | delay(400) 91 | delay(200) 92 | 93 | run(setup, loop) -------------------------------------------------------------------------------- /examples/MAX31855_test.py: -------------------------------------------------------------------------------- 1 | """ 2 | MAX31855_test.py 3 | Alexander Hiam - 12/2012 4 | Updated Oct. 2015 5 | 6 | Example program for PyBBIO's MAX31855 library. 7 | Reads the temperature from a MAX31855 thermocouple amplifier connected 8 | over SPI. 9 | 10 | This example program is in the public domain. 11 | """ 12 | 13 | from bbio import * 14 | from bbio.libraries.MAX31855 import MAX31855 15 | 16 | # Open SPI bus 1: 17 | SPI1.open() 18 | 19 | # Using SPI1 CS0 (P9_28): 20 | cs_pin = 0 21 | 22 | # Create an instance of the MAX31855 class: 23 | thermocouple = MAX31855(SPI1, cs_pin) 24 | 25 | def setup(): 26 | # Nothing to do here... 27 | pass 28 | 29 | def loop(): 30 | temp = thermocouple.readTempC() 31 | if (temp == None): 32 | # The MAX31855 reported an error, print it: 33 | if thermocouple.error == thermocouple.OPEN_CIRCUIT: 34 | print "Thermocouple not connected" 35 | 36 | elif thermocouple.error == thermocouple.SHORT_TO_GND: 37 | print "Thermocouple shorted to GND" 38 | 39 | elif thermocouple.error == thermocouple.SHORT_TO_VCC: 40 | print "Thermocouple shorted to VCC" 41 | 42 | else: 43 | print "Temp: {:0.2f} C".format(temp) 44 | delay(1000) 45 | 46 | run(setup, loop) 47 | -------------------------------------------------------------------------------- /examples/SafeProcess_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | """ 3 | SafeProcess_test.py 4 | Alexander Hiam 5 | 6 | An example to demonstrate the use of the SafeProcess library 7 | for PyBBIO. 8 | 9 | This example program is in the public domain. 10 | """ 11 | 12 | from bbio import * 13 | from bbio.libraries.SafeProcess import * 14 | 15 | def foo(): 16 | while(True): 17 | print "foo" 18 | delay(1000) 19 | 20 | def setup(): 21 | p = SafeProcess(target=foo) 22 | p.start() 23 | 24 | def loop(): 25 | print "loop" 26 | delay(500) 27 | 28 | run(setup, loop) 29 | -------------------------------------------------------------------------------- /examples/Servo_sweep.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | """ 3 | Servo_sweep.py 4 | Alexander Hiam - 11/7/12 5 | 6 | An example use of PyBBIO's Servo library to sweep the angle 7 | of a servo motor back and forth between 0 and 180 degrees. 8 | 9 | Based on Arduino's Servo library example: 10 | http://arduino.cc/en/Tutorial/Sweep 11 | 12 | Connect the servo's power wires to 5V (P9.8) and ground (P9.2), 13 | and the signal wire to PWM1A (P9.14). 14 | 15 | 16 | This example is in the public domain. 17 | """ 18 | 19 | # First we must import PyBBIO: 20 | from bbio import * 21 | # Then we can import Servo: 22 | from bbio.libraries.Servo import * 23 | 24 | # Create an instance of the Servo object: 25 | servo1 = Servo(PWM1A) 26 | # We could have left out the PWM pin here and used 27 | # Servo.attach(PWM1A) in setup() instead. 28 | 29 | def setup(): 30 | # Nothing to do here 31 | pass 32 | 33 | def loop(): 34 | for angle in range(180): # 0-180 degrees 35 | servo1.write(angle) 36 | delay(15) 37 | 38 | for angle in range(180, 0, -1): # 180-0 degrees 39 | servo1.write(angle) 40 | delay(15) 41 | 42 | run(setup, loop) 43 | -------------------------------------------------------------------------------- /examples/adt7310_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | ''' 3 | adt7310_test.py 4 | Rekha Seethamraju 5 | 6 | An example to demonstrate the use of the ADT7310 library 7 | for PyBBIO. 8 | 9 | This example program is in the public domain. 10 | ''' 11 | from bbio import * 12 | from bbio.libraries.ADT7310 import * 13 | 14 | adt = ADT7310(0,0) 15 | #interrput pin 16 | pin = GPIO1_28 17 | #critical pin 18 | pinc = GPIO1_18 19 | 20 | def alarm(): 21 | '''executed when temp crosses threshold temperatures - high and low ''' 22 | print("Too Hot or Cold!") 23 | 24 | def criticalalarm(): 25 | '''executed when temp crossed critical temperature ''' 26 | print("Over Critical Temperature") 27 | 28 | def setup(): 29 | #sets low temperature threshold 30 | adt.setLowTemp(5) 31 | #sets high temperature threshold 32 | adt.setHighTemp(50) 33 | #sets high temperature threshold 34 | adt.setCriticalTemp(60) 35 | #sets the function to call when interrupt pin in active. 36 | adt.setAlarm(pin,alarm) 37 | #sets the function to call when interrupt pin in active. 38 | adt.setCriticalAlarm(pinc,criticalalarm) 39 | 40 | def loop(): 41 | temp = adt.getTemp() 42 | print "temperature : "+str(temp) 43 | delay(500) 44 | 45 | run(setup,loop) 46 | -------------------------------------------------------------------------------- /examples/analog_test.py: -------------------------------------------------------------------------------- 1 | # analog_test.py - Alexander Hiam 2 | # Testing analogRead() 3 | # 4 | # Example circuit: 5 | # -Connect two equal value resistors around 10k ohm in series 6 | # between the 3.3v supply (pin 3 on P9) and GND (pin 2 on P9) 7 | # to form a voltage divider. Where the two resistors connect 8 | # will be near 1.8v (confirm with a voltmeter if available). 9 | # 10 | # -Connect two potentiometers so that each has one of its outer 11 | # pins connected to GND and the other to the 1.8v of the 12 | # voltage divider. Connect the center pin of one to AIN0 (pin 13 | # 39 on P9) and the other to AIN2 (pin 37 on P9). 14 | # 15 | # -Run this program and watch the output as you turn the pots. 16 | # 17 | # *** NOTICE *** 18 | # The maximum ADC input voltage is 1.8v, 19 | # applying greater voltages will likely cause 20 | # permanent damage to the ADC module! 21 | # 22 | # This example is in the public domain 23 | 24 | 25 | # Import PyBBIO library: 26 | from bbio import * 27 | 28 | pot1 = AIN0 # pin 39 on header P9 29 | pot2 = AIN2 # pin 37 on header P9 30 | 31 | def setup(): 32 | # Nothing to do here 33 | pass 34 | 35 | def loop(): 36 | # Get the ADC values: 37 | val1 = analogRead(pot1) 38 | val2 = analogRead(pot2) 39 | # And convert to voltages: 40 | voltage1 = inVolts(val1) 41 | voltage2 = inVolts(val2) 42 | print " pot1 ADC value: %i - voltage: %fv" % (val1, voltage1) 43 | print " pot2 ADC value: %i - voltage: %fv\n" % (val2, voltage2) 44 | delay(500) 45 | 46 | # Start the loop: 47 | run(setup, loop) 48 | -------------------------------------------------------------------------------- /examples/available_pins.py: -------------------------------------------------------------------------------- 1 | # available_pins.py - Alexander Hiam 2 | # Prints all the pins available for IO expansion by their 3 | # names used in PyBBIO (refer to beaglebone schematic for 4 | # header locations). 5 | # 6 | # This example is in the public domain 7 | 8 | # Import PyBBIO library: 9 | from bbio import * 10 | from bbio.platform.beaglebone import config 11 | 12 | # Create a setup function: 13 | def setup(): 14 | print "\n GPIO pins:" 15 | for i in config.GPIO.keys(): 16 | print " %s" % i 17 | print "\n ADC pins:" 18 | for i in config.ADC.keys(): 19 | print " %s" % i 20 | print "\n PWM pins:" 21 | for i in config.PWM_PINS.keys(): 22 | print " %s" % i 23 | 24 | 25 | # Create a main function: 26 | def loop(): 27 | # No need to keep running 28 | stop() 29 | 30 | # Start the loop: 31 | run(setup, loop) 32 | 33 | -------------------------------------------------------------------------------- /examples/blink.py: -------------------------------------------------------------------------------- 1 | # blink.py - Alexander Hiam - 2/2012 2 | # Blinks two of the Beagleboard's on-board LEDs until CTRL-C is pressed. 3 | # 4 | # This example is in the public domain 5 | 6 | # Import PyBBIO library: 7 | from bbio import * 8 | 9 | # Create a setup function: 10 | def setup(): 11 | # Set the two LEDs as outputs: 12 | pinMode(USR2, OUTPUT) 13 | pinMode(USR3, OUTPUT) 14 | 15 | # Start one high and one low: 16 | digitalWrite(USR2, HIGH) 17 | digitalWrite(USR3, LOW) 18 | 19 | # Create a main function: 20 | def loop(): 21 | # Toggle the two LEDs and sleep a few seconds: 22 | toggle(USR2) 23 | toggle(USR3) 24 | delay(500) 25 | 26 | # Start the loop: 27 | run(setup, loop) 28 | -------------------------------------------------------------------------------- /examples/digitalRead.py: -------------------------------------------------------------------------------- 1 | # digitalRead.py - Alexander Hiam - 2/2012 2 | # USR3 LED mirrors GPIO1_6 until CTRL-C is pressed. 3 | # 4 | # This example is in the public domain 5 | 6 | # Import PyBBIO library: 7 | from bbio import * 8 | 9 | # Create a setup function: 10 | def setup(): 11 | # Set the GPIO pins: 12 | pinMode(USR3, OUTPUT) 13 | pinMode(GPIO1_6, INPUT) 14 | 15 | # Create a main function: 16 | def loop(): 17 | state = digitalRead(GPIO1_6) 18 | digitalWrite(USR3, state) 19 | # It's good to put a bit of a delay in if possible 20 | # to keep the processor happy: 21 | delay(100) 22 | 23 | # Start the loop: 24 | run(setup, loop) 25 | -------------------------------------------------------------------------------- /examples/encoder_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | """ 3 | encoder_test.py 4 | Rekha Seethamraju 5 | 6 | An example to demonstrate the use of the eQEP library 7 | for PyBBIO. 8 | 9 | This example program is in the public domain. 10 | """ 11 | from bbio import * 12 | from bbio.libraries.RotaryEncoder import RotaryEncoder 13 | 14 | encoder = RotaryEncoder(RotaryEncoder.EQEP2b) 15 | 16 | def setup(): 17 | encoder.setAbsolute() 18 | encoder.zero() 19 | 20 | def loop(): 21 | print "encoder position : "+encoder.getPosition() 22 | delay(1000) 23 | 24 | run(setup, loop) 25 | -------------------------------------------------------------------------------- /examples/fade.py: -------------------------------------------------------------------------------- 1 | # fade.py - Alexander Hiam - 10/2012 2 | # Uses pulse width modulation to fade an LED on PWM1A 3 | # (pin 14 on header P9). 4 | # 5 | # This example is in the public domain 6 | 7 | # Import PyBBIO library: 8 | from bbio import * 9 | 10 | LED = PWM1A 11 | brightness = 0 # Global variable to store brightness level 12 | inc = 1 # How much to increment the brightness by 13 | pause = 1 # Delay in ms between each step 14 | 15 | # Create a setup function: 16 | def setup(): 17 | # nothing to do here 18 | pass 19 | 20 | # Create a main function: 21 | def loop(): 22 | global brightness, inc 23 | 24 | # Set the PWM duty cycle: 25 | analogWrite(LED, brightness) 26 | # Increment value: 27 | brightness += inc 28 | if ((brightness == 255) or (brightness == 0)): 29 | # Change increment direction: 30 | inc *= -1 31 | # Sleep a bit: 32 | delay(pause) 33 | 34 | # Start the loop: 35 | run(setup, loop) 36 | -------------------------------------------------------------------------------- /examples/interrupt.py: -------------------------------------------------------------------------------- 1 | # interrupt.py - Alexander Hiam - 12/2013 2 | # Sets P9.12 as an input with a pull-up resistor and attaches a 3 | # falling edge interrupt. The 5th time the pin goes low the interrupt 4 | # is detached. 5 | # 6 | # This example is in the public domain 7 | 8 | from bbio import * 9 | 10 | pin = GPIO1_28 11 | 12 | n_interrupts = 0 13 | 14 | def countInterrupts(): 15 | # This function will be called every time the pin goes low 16 | global n_interrupts 17 | n_interrupts += 1 18 | print "interrupt # %i" % n_interrupts 19 | if n_interrupts >= 5: 20 | print "detaching interrupt" 21 | detachInterrupt(pin) 22 | 23 | def setup(): 24 | pinMode(pin, INPUT, PULLUP) 25 | attachInterrupt(pin, countInterrupts, FALLING) 26 | print "falling edge interrupt attached to P9.12 (GPIO1_28)" 27 | 28 | def loop(): 29 | print "The loop continues..." 30 | delay(1000) 31 | 32 | run(setup, loop) -------------------------------------------------------------------------------- /examples/knock.py: -------------------------------------------------------------------------------- 1 | """ 2 | knock.py - Alexander Hiam - 3/21/2012 3 | Adapted from the Ardiuno knock.pde example skecth for use 4 | with PyBBIO - https://github.com/alexanderhiam/PyBBIO 5 | 6 | Uses a Piezo element to detect knocks. If a knock is detected 7 | above the defined threshold one of the on-board LEDs is toggled 8 | and 'knock' is written to stdout. 9 | 10 | This is based quite directly on the Knock Sensor example 11 | sketch, which can be found in the Arduino IDE examples or 12 | here: 13 | http://www.arduino.cc/en/Tutorial/Knock 14 | 15 | Version history of knock.pde: 16 | created 25 Mar 2007 17 | by David Cuartielles 18 | modified 4 Sep 2010 19 | by Tom Igoe 20 | 21 | This example is in the public domain. 22 | """ 23 | 24 | from bbio import * 25 | 26 | LED = USR3 # On-board LED 27 | KNOCK_SENSOR = A0 # AIN0 - pin 39 on header P9 28 | THRESHOLD = 245 # analogRead() value > THRESHOLD indicates knock 29 | 30 | 31 | def setup(): 32 | pinMode(LED, OUTPUT) 33 | print "PyBBIO Knock Sensor" 34 | 35 | def loop(): 36 | value = analogRead(KNOCK_SENSOR) 37 | #print value 38 | if (value > THRESHOLD): 39 | toggle(LED) 40 | print "knock!" 41 | delay(100) 42 | run(setup, loop) 43 | -------------------------------------------------------------------------------- /examples/phant_test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | ''' 4 | phant_test.py 5 | Rekha Seethamraju 6 | 7 | An example to demonstrate the use of the PhantStream library 8 | for PyBBIO. 9 | It reads from the analog pin and posts onto a phant data stream 10 | to a field called voltage every 10s. 11 | 12 | This example program is in the public domain. 13 | 14 | 15 | To use the PhantStream library: 16 | make a steam on the phant server https://data.sparkfun.com/streams/make 17 | or install phant on the bbb and get the public key, private key and the url 18 | call - 19 | PhantStream("*public key*",(optional)"*private key*",(optional)"*url*") 20 | if the stream is being hosted on Spark Fun's server, it can be left blank. 21 | 22 | For additional information read the wiki page. 23 | https://github.com/alexanderhiam/PyBBIO/wiki/PhantStream 24 | ''' 25 | from bbio import * 26 | from bbio.libraries.IoT.phant import PhantStream 27 | 28 | 29 | pot = AIN0 30 | field_name = "voltage" 31 | public_key = ""#required 32 | private_key = ""#optional 33 | p = PhantStream(public_key,private_key) 34 | def setup(): 35 | pass 36 | 37 | def loop(): 38 | val = analogRead(pot) 39 | v = inVolts(val) 40 | samples = { 41 | field_name : v 42 | } 43 | p.send(samples) 44 | delay(10000) 45 | 46 | run(setup,loop) 47 | -------------------------------------------------------------------------------- /examples/remote_temp_control.py: -------------------------------------------------------------------------------- 1 | ''' 2 | remote_temp_control.py 3 | Rekha Seethamraju 4 | 5 | An example to demonstrate the use of PyBBIO to control room temperature 6 | remotely with the help of a fan and heater. 7 | 8 | This example uses leds to depict a fan and a heater. 9 | The temperature sensor used is a ADT7310. 10 | Below 18 C, heater is switched ON. Above 25, fan os switched ON. 11 | It sends an email if temperature is above critical temperature (40 C). 12 | 13 | Working video : Coming soon 14 | 15 | This example program is in the public domain. 16 | ''' 17 | from bbio import * 18 | from bbio.libraries.ADT7310 import * 19 | from email.mime.text import MIMEText 20 | from email.mime.multipart import MIMEMultipart 21 | 22 | adt = ADT7310(0,0) 23 | #critical pin 24 | pinc = GPIO1_18 25 | heaterled = GPIO1_28 26 | fanled = GPIO3_17 27 | # sender == sender email address 28 | # reciever == recipient's email address 29 | sender = "sender@email.com" 30 | reciever = "reciever@email.com" 31 | 32 | 33 | def criticalalarm(): 34 | text = "Temperature is too high and not controllable.\n \ 35 | Check controls.\n" 36 | sendmsg(text) 37 | 38 | def sendmsg(message): 39 | print "Sending email notifcation" 40 | text = message 41 | msg = MIMEMultipart('alternative') 42 | msg['Subject'] = "Beaglebone Temperature Control" 43 | msg['From'] = sender 44 | msg['To'] = reciever 45 | msg.attach(MIMEText(text, 'plain')) 46 | server = smtplib.SMTP("smtp.gmail.com", 587) 47 | server.starttls() 48 | server.login(sender,'password') 49 | server.sendmail(sender, reciever, msg.as_string()) 50 | print "send" 51 | 52 | 53 | def setup(): 54 | #sets low temperature threshold 55 | adt.setLowTemp(18) 56 | #sets high temperature threshold 57 | adt.setHighTemp(25) 58 | #sets critical temperature threshold 59 | adt.setCriticalTemp(40) 60 | #sets the function to call when interrupt pin in active. 61 | adt.setCriticalAlarm(pinc,criticalalarm) 62 | pinMode(heaterled,OUTPUT) 63 | pinMode(fanled,OUTPUT) 64 | digitalWrite(heaterled,LOW) 65 | digitalWrite(fanled,LOW) 66 | 67 | def loop(): 68 | temp = adt.getTemp() 69 | 70 | if (temp <= 18): 71 | digitalWrite(heaterled,HIGH) 72 | digitalWrite(fanled,LOW) 73 | 74 | elif (temp > 18 and temp <= 25 ): 75 | digitalWrite(heaterled,LOW) 76 | digitalWrite(fanled,LOW) 77 | 78 | elif(temp > 25): 79 | digitalWrite(heaterled,LOW) 80 | digitalWrite(fanled,HIGH) 81 | 82 | delay(5000) 83 | 84 | run(setup,loop) 85 | -------------------------------------------------------------------------------- /examples/security_cam.py: -------------------------------------------------------------------------------- 1 | """ 2 | security_cam.py 3 | Rekha Seethamraju 4 | 5 | An example to demonstrate the use of the WebCam and MMA7660 libraries of PyBBIO 6 | to set up a security camera that takes a picture and sends an email and sms if 7 | a motion is detected (pir motion sensor) or the camera is tampered with (MMA7660) 8 | 9 | This example program is in the public domain. 10 | """ 11 | from bbio import * 12 | import smtplib 13 | from bbio.libraries.WebCam import WebCam 14 | from email.mime.text import MIMEText 15 | from email.mime.multipart import MIMEMultipart 16 | from email.mime.image import MIMEImage 17 | from bbio.libraries.MMA7660 import MMA7660 18 | 19 | cam = WebCam() 20 | pir = GPIO1_28 21 | accel = MMA7660(2) 22 | INT_PIN = GPIO1_16 23 | sender = 'sender_email@gmail.com' 24 | reciever = 'reciver_emial@gmail.com' 25 | password = 'sender_email_password' 26 | #change the smtp address below if not using gmail 27 | sms = 'sms_gateway_address' 28 | # can be obtained from http://www.ukrainecalling.com/email-to-text.aspx 29 | 30 | def setup(): 31 | int_cfg = accel.INT_SHX | \ 32 | accel.INT_SHY | \ 33 | accel.INT_SHZ 34 | accel.setInterrupt(int_cfg, INT_PIN, accelCallback) 35 | accel.settapthreshold(30) 36 | accel.setTapDebounce(15) 37 | pinMode(pir,INPUT,PULLUP) 38 | attachInterrupt(pir, motiondetect, RISING) 39 | 40 | def loop(): 41 | print "The loop continues..." 42 | delay(1000) 43 | 44 | def accelCallback(back_front, portrait_landscape, tap, shake): 45 | ''' 46 | detects shake interrupt 47 | ''' 48 | print "shake detected" 49 | cam.takeSnapshot("sample") 50 | if shake == 1: 51 | sendmsg(1) 52 | 53 | def motiondetect(): 54 | ''' 55 | motion detect interrupt function 56 | ''' 57 | print "motion detected" 58 | cam.takeSnapshot("sample") 59 | sendmsg(2) 60 | 61 | def sendmsg(num): 62 | ''' 63 | sends an email and sms with the picture 64 | ''' 65 | if num == 1: 66 | text = "Shake Detected" 67 | if num == 2: 68 | text = "Motion Detected" 69 | print "Sending email notifcation" 70 | msg = MIMEMultipart() 71 | msg['Subject'] = "Beaglebone Remote Security" 72 | msg['From'] = sender 73 | msg['To'] = reciever 74 | msg.attach(MIMEText(text, 'plain')) 75 | img = open("sample.jpeg", "rb") 76 | msg.attach(MIMEImage(img.read())) 77 | img.close() 78 | # if not using gmail smtp adress has to change 79 | server = smtplib.SMTP("smtp.gmail.com", 587) 80 | server.starttls() 81 | server.login(sender,password) 82 | server.sendmail(sender, reciever, msg.as_string()) 83 | server.sendmail(sender, sms, msg.as_string()) 84 | print "sent email" 85 | 86 | run(setup,loop) -------------------------------------------------------------------------------- /examples/serial_echo.py: -------------------------------------------------------------------------------- 1 | # serial_echo.py - Alexander Hiam - 4/15/12 2 | # 3 | # Prints all incoming data on Serial2 and echos it back. 4 | # 5 | # Serial2 TX = pin 21 on P9 header 6 | # Serial2 RX = pin 22 on P9 header 7 | # 8 | # This example is in the public domain 9 | 10 | from bbio import * 11 | 12 | def setup(): 13 | # Start Serial2 at 9600 baud: 14 | Serial2.begin(9600) 15 | 16 | 17 | def loop(): 18 | if (Serial2.available()): 19 | # There's incoming data 20 | data = '' 21 | while(Serial2.available()): 22 | # If multiple characters are being sent we want to catch 23 | # them all, so add received byte to our data string and 24 | # delay a little to give the next byte time to arrive: 25 | data += Serial2.read() 26 | delay(5) 27 | 28 | # Print what was sent: 29 | print "Data received:\n '%s'" % data 30 | # And write it back to the serial port: 31 | Serial2.write(data) 32 | # And a little delay to keep the Beaglebone happy: 33 | delay(200) 34 | 35 | run(setup, loop) 36 | -------------------------------------------------------------------------------- /examples/serial_server.py: -------------------------------------------------------------------------------- 1 | # serial_server.py - Alexander Hiam - 4/15/12 2 | # 3 | # Creates a simple web interface to the Serial2 port. 4 | # 5 | # Serial2 TX = pin 21 on P9 header 6 | # Serial2 RX = pin 22 on P9 header 7 | # 8 | # Run this program and navigate to http://your_beaglebone_ip:8000 9 | # in your web brower. 10 | # 11 | # See BBIOServer tutorial: 12 | # https://github.com/alexanderhiam/PyBBIO/wiki/BBIOServer 13 | # 14 | # This example is in the public domain 15 | 16 | from bbio import * 17 | from bbio.libraries.BBIOServer import * 18 | 19 | # Create a server instance: 20 | server = BBIOServer() 21 | 22 | # A global buffer for received data: 23 | data ='' 24 | 25 | def serial_tx(string): 26 | """ Sends given string to Serial2. """ 27 | Serial2.println(string) 28 | 29 | def serial_rx(): 30 | """ Returns received data if any, otherwise current data buffer. """ 31 | global data 32 | if (Serial2.available()): 33 | # There's incoming data 34 | data ='' 35 | while(Serial2.available()): 36 | # If multiple characters are being sent we want to catch 37 | # them all, so add received byte to our data string and 38 | # delay a little to give the next byte time to arrive: 39 | data += Serial2.read() 40 | delay(5) 41 | return data 42 | 43 | def setup(): 44 | # Start the serial port at 9600 baud: 45 | Serial2.begin(9600) 46 | # Create the web page: 47 | serial = Page("Serial") 48 | serial.add_text("A simple interface to Serial2.") 49 | serial.add_entry(lambda string: serial_tx(string), "Send", newline=True) 50 | serial.add_monitor(lambda: serial_rx(), "Received:", newline=True) 51 | 52 | # Start the server: 53 | server.start(serial) 54 | 55 | def loop(): 56 | # Server has stopped; exit happily: 57 | stop() 58 | 59 | run(setup, loop) 60 | -------------------------------------------------------------------------------- /examples/switch.py: -------------------------------------------------------------------------------- 1 | # switch.py - Alexander Hiam - 2/2012 2 | # 3 | # Uses a switch to toggle the state of two LEDs. 4 | # Demonstrates the use of global variables in Python. 5 | # 6 | # The circuit: 7 | # - Momentary switch between 3.3v and GPIO1_15 8 | # - 10k ohm resistor from GPIO1_15 to ground 9 | # - Green LED from GPIO1_17 through 330 ohm resistor to ground 10 | # - Red LED from GPIO3_21 through 330 ohm resistor to ground 11 | # 12 | # This example is in the public domain 13 | 14 | # Import PyBBIO library: 15 | from bbio import * 16 | 17 | SWITCH = GPIO1_15 # P8.15 18 | LED_GRN = GPIO1_17 # P9.23 19 | LED_RED = GPIO3_21 # P9.25 20 | 21 | LED_STATE = 0 # 0=green LED lit, 1=red LED lit. 22 | SW_STATE = 0 # =1 when switch pressed; only change LED_STATE 23 | # once per press. 24 | 25 | # Create a setup function: 26 | def setup(): 27 | # Set the switch as input: 28 | pinMode(SWITCH, INPUT) 29 | # Set the LEDs as outputs: 30 | pinMode(LED_GRN, OUTPUT) 31 | pinMode(LED_RED, OUTPUT) 32 | 33 | # Create a main function: 34 | def main(): 35 | global LED_STATE, SW_STATE 36 | # Python requires you explicitely declare all global variables 37 | # that you want to change within a code block using the global 38 | # statement; see: 39 | # http://docs.python.org/reference/simple_stmts.html#the-global-statement 40 | 41 | if (digitalRead(SWITCH) == HIGH): 42 | if (SW_STATE == 0): 43 | # Just pressed, not held down. 44 | # Set SW_STATE and toggle LED_STATE 45 | SW_STATE = 1 46 | LED_STATE ^= 1 47 | # Otherwise switch is held down, don't do anything. 48 | else: 49 | # Switch not pressed, reset SW_STATE: 50 | SW_STATE = 0 51 | 52 | if (LED_STATE == 0): 53 | digitalWrite(LED_GRN, HIGH) 54 | digitalWrite(LED_RED, LOW) 55 | else: 56 | digitalWrite(LED_GRN, LOW) 57 | digitalWrite(LED_RED, HIGH) 58 | # It's good to put a bit of a delay in if possible 59 | # to keep the processor happy: 60 | delay(50) 61 | 62 | # Start the loop: 63 | run(setup, main) 64 | -------------------------------------------------------------------------------- /examples/webcam_bbioserver_test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | webcam_bbioserver_test.py 3 | Rekha Seethamraju 4 | 5 | An example to demonstrate the use of the WebCam and BBIOServer libraries for PyBBIO. 6 | 7 | This example program is in the public domain. 8 | ''' 9 | from bbio import * 10 | from bbio.libraries.WebCam import WebCam 11 | 12 | from bbio.libraries.BBIOServer import * 13 | 14 | cam = WebCam() 15 | delay(10000) 16 | server = BBIOServer() 17 | cam.startStreaming() 18 | 19 | vid = Page("Webcam Video") 20 | vid.add_video("192.168.7.2","5000") 21 | server.start(vid) 22 | 23 | cam.stopStreaming() 24 | -------------------------------------------------------------------------------- /examples/webcam_test.py: -------------------------------------------------------------------------------- 1 | ''' 2 | webcam_test.py 3 | Rekha Seethamraju 4 | 5 | An example to demonstrate the use of the WebCam library 6 | for PyBBIO. 7 | 8 | This example program is in the public domain. 9 | ''' 10 | 11 | from bbio import * 12 | from bbio.libraries.WebCam import WebCam 13 | 14 | cam = WebCam() 15 | s = 0 16 | 17 | def setup(): 18 | pass 19 | 20 | def loop(): 21 | global s 22 | location = "pic"+str(s) 23 | cam.takeSnapshot(location) 24 | print "saving image to %s" % location 25 | s += 1 26 | delay(10000) 27 | 28 | run(setup, loop) -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | description-file = README.md -------------------------------------------------------------------------------- /tests/io_test.py: -------------------------------------------------------------------------------- 1 | # io_test.py - Alexander Hiam 2 | # This was a quick test I wrote before starting in on PyBBIO. 3 | # It's a good demonstration of how to use /dev/mem for hardware 4 | # access. Blinks the on-board LED marked USR2 5 | 6 | from mmap import mmap 7 | import time, struct 8 | 9 | GPIO1_offset = 0x4804c000 # Start of GPIO1 mux 10 | GPIO1_size = 0x4804cfff-GPIO1_offset 11 | GPIO_OE = 0x134 12 | GPIO_SETDATAOUT = 0x194 13 | GPIO_CLEARDATAOUT = 0x190 14 | LED2 = 1<<22 # Pin 22 in gpio registers 15 | 16 | f = open("/dev/mem", "r+b" ) 17 | map = mmap(f.fileno(), GPIO1_size, offset=GPIO1_offset) 18 | f.close() # Only needed to make map 19 | 20 | # Grab the entire GPIO_OE register: 21 | packed_reg = map[GPIO_OE:GPIO_OE+4] # This is a packed string 22 | # Unpack it: 23 | reg_status = struct.unpack("; 24 | __overlay__ { 25 | /* avoid stupid warning */ 26 | #address-cells = <1>; 27 | #size-cells = <1>; 28 | tscadc { 29 | compatible = "ti,ti-tscadc"; 30 | reg = <0x44e0d000 0x1000>; 31 | interrupt-parent = <&intc>; 32 | interrupts = <16>; 33 | ti,hwmods = "adc_tsc"; 34 | status = "okay"; 35 | adc { 36 | ti,adc-channels = <0 1 2 3 4 5 6 7>; 37 | }; 38 | }; 39 | }; 40 | }; 41 | }; -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN0-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN0"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.39"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN0 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN0"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN1-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN1"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.40"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN1 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN1"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN2-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN2"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.37"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN2 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN2"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN3-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN3"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.38"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN3 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN3"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN4-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN4"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.33"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN4 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN4"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN5-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN5"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.36"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN5 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN5"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN6-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN6"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "P9.35"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN6 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN6"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-AIN7-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "PyBBIO-AIN7"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "vsys"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: PyBBIO-AIN7 { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "AIN7"; 24 | vsense-scale = <100>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-ecap0-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 0's eCAP 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-ecap0"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&ecap0>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-ecap1-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 1's eCAP 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-ecap1"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&ecap1>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-ehrpwm1-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 1's high resolution PWM 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-ehrpwm1"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&ehrpwm1>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-ehrpwm2-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 2's high resolution PWM 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-ehrpwm2"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&ehrpwm2>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-epwmss0-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 0 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-epwmss0"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&epwmss0>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-epwmss1-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 1 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-epwmss1"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&epwmss1>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-epwmss2-00A0.dts: -------------------------------------------------------------------------------- 1 | /* Enables the BeagleBone's PWM sub system 2 2 | * 3 | * This overlay was created for PyBBIO: 4 | * github.com/alexanderhiam/PyBBIO 5 | * 6 | * This file is in the Public Domain. 7 | */ 8 | 9 | /dts-v1/; 10 | /plugin/; 11 | /{ 12 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 13 | /* identification */ 14 | part-number = "PyBBIO-epwmss2"; 15 | version = "00A0"; 16 | fragment@0 { 17 | target = <&epwmss2>; 18 | __overlay__ { 19 | status = "okay"; 20 | }; 21 | }; 22 | }; 23 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-eqep0-00A0.dts: -------------------------------------------------------------------------------- 1 | /* 2 | * Enabled the eQEP0 module and muxes the A and B input pins. Requires epwmss0 3 | * to be enabled. 4 | * 5 | * Based on bone_eqep0.dts 6 | https://github.com/Teknoman117/beaglebot/blob/master/encoders/dts/bone_eqep0.dts 7 | * Original copyright: 8 | * Copyright (C) 2013 Nathaniel R. Lewis - http://nathanielrlewis.com/ 9 | * 10 | * This program is free software; you can redistribute it and/or modify 11 | * it under the terms of the GNU General Public License version 2 as 12 | * published by the Free Software Foundation. 13 | * 14 | * Enable eQEP0 on the Beaglebone Black - incompatible with BB White because 15 | * most of the eQEP0 pins on Beaglebone white are not broken out. 16 | */ 17 | /dts-v1/; 18 | /plugin/; 19 | 20 | / { 21 | compatible = "ti,beaglebone-black"; 22 | 23 | /* identification */ 24 | part-number = "PyBBIO-eqep0"; 25 | version = "00A0"; 26 | 27 | exclusive-use = 28 | "P9.42", 29 | "P9.27", 30 | "eqep0"; 31 | 32 | fragment@0 { 33 | target = <&am33xx_pinmux>; 34 | __overlay__ { 35 | pinctrl_eqep0: pinctrl_eqep0_pins { 36 | pinctrl-single,pins = < 37 | 0x1A0 0x31 /* P9_42 = GPIO3_18 = EQEP0A_in, MODE1 */ 38 | 0x1A4 0x31 /* P9_27 = GPIO3_19 = EQEP0B_in, MODE1 */ 39 | >; 40 | }; 41 | }; 42 | }; 43 | 44 | 45 | fragment@2 { 46 | target = <&eqep0>; 47 | __overlay__ { 48 | pinctrl-names = "default"; 49 | pinctrl-0 = <&pinctrl_eqep0>; 50 | 51 | count_mode = <0>; /* 0 - Quadrature mode, normal 90 phase offset cha & chb. 1 - Direction mode. cha input = clock, chb input = direction */ 52 | swap_inputs = <0>; /* Are channel A and channel B swapped? (0 - no, 1 - yes) */ 53 | invert_qa = <1>; /* Should we invert the channel A input? */ 54 | invert_qb = <1>; /* Should we invert the channel B input? I invert these because my encoder outputs drive transistors that pull down the pins */ 55 | invert_qi = <0>; /* Should we invert the index input? */ 56 | invert_qs = <0>; /* Should we invert the strobe input? */ 57 | 58 | status = "okay"; 59 | }; 60 | }; 61 | }; 62 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-eqep1-00A0.dts: -------------------------------------------------------------------------------- 1 | /* 2 | * Enabled the eQEP1 module and muxes the A and B input pins. Requires epwmss1 3 | * to be enabled. 4 | * 5 | * Based on bone_eqep1.dts 6 | https://github.com/Teknoman117/beaglebot/blob/master/encoders/dts/bone_eqep1.dts 7 | * Original copyright: 8 | * Copyright (C) 2013 Nathaniel R. Lewis - http://nathanielrlewis.com/ 9 | * 10 | * This program is free software; you can redistribute it and/or modify 11 | * it under the terms of the GNU General Public License version 2 as 12 | * published by the Free Software Foundation. 13 | * 14 | * Enable eQEP1 on the Beaglebone White and Black 15 | */ 16 | /dts-v1/; 17 | /plugin/; 18 | 19 | / { 20 | compatible = "ti,beaglebone-black"; 21 | 22 | /* identification */ 23 | part-number = "PyBBIO-eqep1"; 24 | version = "00A0"; 25 | 26 | exclusive-use = 27 | "P8.33", 28 | "P8.35", 29 | "eqep1"; 30 | 31 | fragment@0 { 32 | target = <&am33xx_pinmux>; 33 | __overlay__ { 34 | pinctrl_eqep1: pinctrl_eqep1_pins { 35 | pinctrl-single,pins = < 36 | 0x0D4 0x32 /* P8_33 = GPIO0_9 = EQEP1B_in, MODE2 */ 37 | 0x0D0 0x32 /* P8_35 = GPIO0_8 = EQEP1A_in, MODE2 */ 38 | >; 39 | }; 40 | }; 41 | }; 42 | 43 | 44 | fragment@2 { 45 | target = <&eqep1>; 46 | __overlay__ { 47 | pinctrl-names = "default"; 48 | pinctrl-0 = <&pinctrl_eqep1>; 49 | 50 | count_mode = <0>; /* 0 - Quadrature mode, normal 90 phase offset cha & chb. 1 - Direction mode. cha input = clock, chb input = direction */ 51 | swap_inputs = <0>; /* Are channel A and channel B swapped? (0 - no, 1 - yes) */ 52 | invert_qa = <1>; /* Should we invert the channel A input? */ 53 | invert_qb = <1>; /* Should we invert the channel B input? I invert these because my encoder outputs drive transistors that pull down the pins */ 54 | invert_qi = <0>; /* Should we invert the index input? */ 55 | invert_qs = <0>; /* Should we invert the strobe input? */ 56 | 57 | status = "okay"; 58 | }; 59 | }; 60 | }; 61 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-eqep2-00A0.dts: -------------------------------------------------------------------------------- 1 | /* 2 | * Enabled the eQEP2 module and muxes the A and B input pins. Requires epwmss2 3 | * to be enabled. 4 | * 5 | * Based on bone_eqep2.dts 6 | https://github.com/Teknoman117/beaglebot/blob/master/encoders/dts/bone_eqep2.dts 7 | * Original copyright: 8 | * Copyright (C) 2013 Nathaniel R. Lewis - http://nathanielrlewis.com/ 9 | * 10 | * This program is free software; you can redistribute it and/or modify 11 | * it under the terms of the GNU General Public License version 2 as 12 | * published by the Free Software Foundation. 13 | * 14 | * Enable eQEP2 on the Beaglebone White and Black 15 | */ 16 | /dts-v1/; 17 | /plugin/; 18 | 19 | / { 20 | compatible = "ti,beaglebone-black"; 21 | 22 | /* identification */ 23 | part-number = "PyBBIO-eqep2"; 24 | version = "00A0"; 25 | 26 | exclusive-use = 27 | "P8.41", 28 | "P8.42", 29 | "eqep2"; 30 | 31 | fragment@0 { 32 | target = <&am33xx_pinmux>; 33 | __overlay__ { 34 | pinctrl_eqep2: pinctrl_eqep2_pins { 35 | pinctrl-single,pins = < 36 | 0x0B0 0x33 /* P8_41 = GPIO2_10 = EQEP2A_in, MODE3 */ 37 | 0x0B4 0x33 /* P8_42 = GPIO2_11 = EQEP2B_in, MODE3 */ 38 | >; 39 | }; 40 | }; 41 | }; 42 | 43 | 44 | fragment@2 { 45 | target = <&eqep2>; 46 | __overlay__ { 47 | pinctrl-names = "default"; 48 | pinctrl-0 = <&pinctrl_eqep2>; 49 | 50 | count_mode = <0>; /* 0 - Quadrature mode, normal 90 phase offset cha & chb. 1 - Direction mode. cha input = clock, chb input = direction */ 51 | swap_inputs = <0>; /* Are channel A and channel B swapped? (0 - no, 1 - yes) */ 52 | invert_qa = <1>; /* Should we invert the channel A input? */ 53 | invert_qb = <1>; /* Should we invert the channel B input? I invert these because my encoder outputs drive transistors that pull down the pins */ 54 | invert_qi = <0>; /* Should we invert the index input? */ 55 | invert_qs = <0>; /* Should we invert the strobe input? */ 56 | 57 | status = "okay"; 58 | }; 59 | }; 60 | }; 61 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-eqep2b-00A0.dts: -------------------------------------------------------------------------------- 1 | /* 2 | * Enabled the eQEP2 module and muxes the alternate A and B input pins. Requires 3 | * epwmss2 to be enabled. 4 | * 5 | * Based on bone_eqep2b.dts 6 | https://github.com/Teknoman117/beaglebot/blob/master/encoders/dts/bone_eqep2.dts 7 | * Original copyright: 8 | * Copyright (C) 2013 Nathaniel R. Lewis - http://nathanielrlewis.com/ 9 | * 10 | * This program is free software; you can redistribute it and/or modify 11 | * it under the terms of the GNU General Public License version 2 as 12 | * published by the Free Software Foundation. 13 | * 14 | * Enable eQEP2 on the Beaglebone White and Black 15 | * These pins don't conflict with the HDMI 16 | */ 17 | /dts-v1/; 18 | /plugin/; 19 | 20 | / { 21 | compatible = "ti,beaglebone-black"; 22 | 23 | /* identification */ 24 | part-number = "PyBBIO-eqep2"; 25 | version = "00A0"; 26 | 27 | exclusive-use = 28 | "P8.12", 29 | "P8.11", 30 | "eqep2"; 31 | 32 | fragment@0 { 33 | target = <&am33xx_pinmux>; 34 | __overlay__ { 35 | pinctrl_eqep2: pinctrl_eqep2_pins { 36 | pinctrl-single,pins = < 37 | 0x030 0x34 /* P8_12 = GPIO1_12 = EQEP2A_in, MODE4 */ 38 | 0x034 0x34 /* P8_11 = GPIO1_13 = EQEP2B_in, MODE4 */ 39 | >; 40 | }; 41 | }; 42 | }; 43 | 44 | 45 | fragment@2 { 46 | target = <&eqep2>; 47 | __overlay__ { 48 | pinctrl-names = "default"; 49 | pinctrl-0 = <&pinctrl_eqep2>; 50 | 51 | count_mode = <0>; /* 0 - Quadrature mode, normal 90 phase offset cha & chb. 1 - Direction mode. cha input = clock, chb input = direction */ 52 | swap_inputs = <0>; /* Are channel A and channel B swapped? (0 - no, 1 - yes) */ 53 | invert_qa = <1>; /* Should we invert the channel A input? */ 54 | invert_qb = <1>; /* Should we invert the channel B input? I invert these because my encoder outputs drive transistors that pull down the pins */ 55 | invert_qi = <0>; /* Should we invert the index input? */ 56 | invert_qs = <0>; /* Should we invert the strobe input? */ 57 | 58 | status = "okay"; 59 | }; 60 | }; 61 | }; 62 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_2-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_2"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_2"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_2_rxactive_nopull: pinmux_pybbio_gpio0_2_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 336 0x2f /* spi0_sclk - rx active | no pull | MODE7 (gpio0_2) */ 24 | >; 25 | }; 26 | pybbio_gpio0_2_rxactive_pullup: pinmux_pybbio_gpio0_2_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 336 0x37 /* spi0_sclk - rx active | pull up | MODE7 (gpio0_2) */ 29 | >; 30 | }; 31 | pybbio_gpio0_2_rxactive_pulldown: pinmux_pybbio_gpio0_2_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 336 0x27 /* spi0_sclk - rx active | pull down | MODE7 (gpio0_2) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_2_nopull: pinmux_pybbio_gpio0_2_nopull { 38 | pinctrl-single,pins = < 39 | 336 0x0f /* spi0_sclk - rx active | no pull | MODE7 (gpio0_2) */ 40 | >; 41 | }; 42 | pybbio_gpio0_2_pullup: pinmux_pybbio_gpio0_2_pullup { 43 | pinctrl-single,pins = < 44 | 336 0x17 /* spi0_sclk - rx active | pull up | MODE7 (gpio0_2) */ 45 | >; 46 | }; 47 | pybbio_gpio0_2_pulldown: pinmux_pybbio_gpio0_2_pulldown { 48 | pinctrl-single,pins = < 49 | 336 0x07 /* spi0_sclk - rx active | pull down | MODE7 (gpio0_2) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_2 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_2_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_2_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_2_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_2_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_2_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_2_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_3-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_3"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_3"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_3_rxactive_nopull: pinmux_pybbio_gpio0_3_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 340 0x2f /* spi0_d0 - rx active | no pull | MODE7 (gpio0_3) */ 24 | >; 25 | }; 26 | pybbio_gpio0_3_rxactive_pullup: pinmux_pybbio_gpio0_3_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 340 0x37 /* spi0_d0 - rx active | pull up | MODE7 (gpio0_3) */ 29 | >; 30 | }; 31 | pybbio_gpio0_3_rxactive_pulldown: pinmux_pybbio_gpio0_3_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 340 0x27 /* spi0_d0 - rx active | pull down | MODE7 (gpio0_3) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_3_nopull: pinmux_pybbio_gpio0_3_nopull { 38 | pinctrl-single,pins = < 39 | 340 0x0f /* spi0_d0 - rx active | no pull | MODE7 (gpio0_3) */ 40 | >; 41 | }; 42 | pybbio_gpio0_3_pullup: pinmux_pybbio_gpio0_3_pullup { 43 | pinctrl-single,pins = < 44 | 340 0x17 /* spi0_d0 - rx active | pull up | MODE7 (gpio0_3) */ 45 | >; 46 | }; 47 | pybbio_gpio0_3_pulldown: pinmux_pybbio_gpio0_3_pulldown { 48 | pinctrl-single,pins = < 49 | 340 0x07 /* spi0_d0 - rx active | pull down | MODE7 (gpio0_3) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_3 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_3_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_3_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_3_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_3_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_3_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_3_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_4-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_4"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_4"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_4_rxactive_nopull: pinmux_pybbio_gpio0_4_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 344 0x2f /* spi0_d1 - rx active | no pull | MODE7 (gpio0_4) */ 24 | >; 25 | }; 26 | pybbio_gpio0_4_rxactive_pullup: pinmux_pybbio_gpio0_4_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 344 0x37 /* spi0_d1 - rx active | pull up | MODE7 (gpio0_4) */ 29 | >; 30 | }; 31 | pybbio_gpio0_4_rxactive_pulldown: pinmux_pybbio_gpio0_4_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 344 0x27 /* spi0_d1 - rx active | pull down | MODE7 (gpio0_4) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_4_nopull: pinmux_pybbio_gpio0_4_nopull { 38 | pinctrl-single,pins = < 39 | 344 0x0f /* spi0_d1 - rx active | no pull | MODE7 (gpio0_4) */ 40 | >; 41 | }; 42 | pybbio_gpio0_4_pullup: pinmux_pybbio_gpio0_4_pullup { 43 | pinctrl-single,pins = < 44 | 344 0x17 /* spi0_d1 - rx active | pull up | MODE7 (gpio0_4) */ 45 | >; 46 | }; 47 | pybbio_gpio0_4_pulldown: pinmux_pybbio_gpio0_4_pulldown { 48 | pinctrl-single,pins = < 49 | 344 0x07 /* spi0_d1 - rx active | pull down | MODE7 (gpio0_4) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_4 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_4_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_4_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_4_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_4_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_4_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_4_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_5-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_5"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_5"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_5_rxactive_nopull: pinmux_pybbio_gpio0_5_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 348 0x2f /* spi0_cs0 - rx active | no pull | MODE7 (gpio0_5) */ 24 | >; 25 | }; 26 | pybbio_gpio0_5_rxactive_pullup: pinmux_pybbio_gpio0_5_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 348 0x37 /* spi0_cs0 - rx active | pull up | MODE7 (gpio0_5) */ 29 | >; 30 | }; 31 | pybbio_gpio0_5_rxactive_pulldown: pinmux_pybbio_gpio0_5_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 348 0x27 /* spi0_cs0 - rx active | pull down | MODE7 (gpio0_5) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_5_nopull: pinmux_pybbio_gpio0_5_nopull { 38 | pinctrl-single,pins = < 39 | 348 0x0f /* spi0_cs0 - rx active | no pull | MODE7 (gpio0_5) */ 40 | >; 41 | }; 42 | pybbio_gpio0_5_pullup: pinmux_pybbio_gpio0_5_pullup { 43 | pinctrl-single,pins = < 44 | 348 0x17 /* spi0_cs0 - rx active | pull up | MODE7 (gpio0_5) */ 45 | >; 46 | }; 47 | pybbio_gpio0_5_pulldown: pinmux_pybbio_gpio0_5_pulldown { 48 | pinctrl-single,pins = < 49 | 348 0x07 /* spi0_cs0 - rx active | pull down | MODE7 (gpio0_5) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_5 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_5_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_5_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_5_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_5_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_5_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_5_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_8-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_8"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_8"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_8_rxactive_nopull: pinmux_pybbio_gpio0_8_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 208 0x2f /* lcd_data12 - rx active | no pull | MODE7 (gpio0_8) */ 24 | >; 25 | }; 26 | pybbio_gpio0_8_rxactive_pullup: pinmux_pybbio_gpio0_8_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 208 0x37 /* lcd_data12 - rx active | pull up | MODE7 (gpio0_8) */ 29 | >; 30 | }; 31 | pybbio_gpio0_8_rxactive_pulldown: pinmux_pybbio_gpio0_8_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 208 0x27 /* lcd_data12 - rx active | pull down | MODE7 (gpio0_8) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_8_nopull: pinmux_pybbio_gpio0_8_nopull { 38 | pinctrl-single,pins = < 39 | 208 0x0f /* lcd_data12 - rx active | no pull | MODE7 (gpio0_8) */ 40 | >; 41 | }; 42 | pybbio_gpio0_8_pullup: pinmux_pybbio_gpio0_8_pullup { 43 | pinctrl-single,pins = < 44 | 208 0x17 /* lcd_data12 - rx active | pull up | MODE7 (gpio0_8) */ 45 | >; 46 | }; 47 | pybbio_gpio0_8_pulldown: pinmux_pybbio_gpio0_8_pulldown { 48 | pinctrl-single,pins = < 49 | 208 0x07 /* lcd_data12 - rx active | pull down | MODE7 (gpio0_8) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_8 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_8_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_8_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_8_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_8_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_8_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_8_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio0_9-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio0_9"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio0_9"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio0_9_rxactive_nopull: pinmux_pybbio_gpio0_9_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 212 0x2f /* lcd_data13 - rx active | no pull | MODE7 (gpio0_9) */ 24 | >; 25 | }; 26 | pybbio_gpio0_9_rxactive_pullup: pinmux_pybbio_gpio0_9_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 212 0x37 /* lcd_data13 - rx active | pull up | MODE7 (gpio0_9) */ 29 | >; 30 | }; 31 | pybbio_gpio0_9_rxactive_pulldown: pinmux_pybbio_gpio0_9_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 212 0x27 /* lcd_data13 - rx active | pull down | MODE7 (gpio0_9) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio0_9_nopull: pinmux_pybbio_gpio0_9_nopull { 38 | pinctrl-single,pins = < 39 | 212 0x0f /* lcd_data13 - rx active | no pull | MODE7 (gpio0_9) */ 40 | >; 41 | }; 42 | pybbio_gpio0_9_pullup: pinmux_pybbio_gpio0_9_pullup { 43 | pinctrl-single,pins = < 44 | 212 0x17 /* lcd_data13 - rx active | pull up | MODE7 (gpio0_9) */ 45 | >; 46 | }; 47 | pybbio_gpio0_9_pulldown: pinmux_pybbio_gpio0_9_pulldown { 48 | pinctrl-single,pins = < 49 | 212 0x07 /* lcd_data13 - rx active | pull down | MODE7 (gpio0_9) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio0_9 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio0_9_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio0_9_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio0_9_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio0_9_nopull>; 71 | pinctrl-4 = <&pybbio_gpio0_9_pullup>; 72 | pinctrl-5 = <&pybbio_gpio0_9_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_0-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_0"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_0"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_0_rxactive_nopull: pinmux_pybbio_gpio1_0_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 0 0x2f /* gpmc_ad0 - rx active | no pull | MODE7 (gpio1_0) */ 24 | >; 25 | }; 26 | pybbio_gpio1_0_rxactive_pullup: pinmux_pybbio_gpio1_0_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 0 0x37 /* gpmc_ad0 - rx active | pull up | MODE7 (gpio1_0) */ 29 | >; 30 | }; 31 | pybbio_gpio1_0_rxactive_pulldown: pinmux_pybbio_gpio1_0_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 0 0x27 /* gpmc_ad0 - rx active | pull down | MODE7 (gpio1_0) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_0_nopull: pinmux_pybbio_gpio1_0_nopull { 38 | pinctrl-single,pins = < 39 | 0 0x0f /* gpmc_ad0 - rx active | no pull | MODE7 (gpio1_0) */ 40 | >; 41 | }; 42 | pybbio_gpio1_0_pullup: pinmux_pybbio_gpio1_0_pullup { 43 | pinctrl-single,pins = < 44 | 0 0x17 /* gpmc_ad0 - rx active | pull up | MODE7 (gpio1_0) */ 45 | >; 46 | }; 47 | pybbio_gpio1_0_pulldown: pinmux_pybbio_gpio1_0_pulldown { 48 | pinctrl-single,pins = < 49 | 0 0x07 /* gpmc_ad0 - rx active | pull down | MODE7 (gpio1_0) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_0 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_0_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_0_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_0_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_0_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_0_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_0_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_1-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_1"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_1"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_1_rxactive_nopull: pinmux_pybbio_gpio1_1_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 4 0x2f /* gpmc_ad1 - rx active | no pull | MODE7 (gpio1_1) */ 24 | >; 25 | }; 26 | pybbio_gpio1_1_rxactive_pullup: pinmux_pybbio_gpio1_1_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 4 0x37 /* gpmc_ad1 - rx active | pull up | MODE7 (gpio1_1) */ 29 | >; 30 | }; 31 | pybbio_gpio1_1_rxactive_pulldown: pinmux_pybbio_gpio1_1_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 4 0x27 /* gpmc_ad1 - rx active | pull down | MODE7 (gpio1_1) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_1_nopull: pinmux_pybbio_gpio1_1_nopull { 38 | pinctrl-single,pins = < 39 | 4 0x0f /* gpmc_ad1 - rx active | no pull | MODE7 (gpio1_1) */ 40 | >; 41 | }; 42 | pybbio_gpio1_1_pullup: pinmux_pybbio_gpio1_1_pullup { 43 | pinctrl-single,pins = < 44 | 4 0x17 /* gpmc_ad1 - rx active | pull up | MODE7 (gpio1_1) */ 45 | >; 46 | }; 47 | pybbio_gpio1_1_pulldown: pinmux_pybbio_gpio1_1_pulldown { 48 | pinctrl-single,pins = < 49 | 4 0x07 /* gpmc_ad1 - rx active | pull down | MODE7 (gpio1_1) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_1 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_1_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_1_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_1_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_1_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_1_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_1_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_16-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_16"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_16"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_16_rxactive_nopull: pinmux_pybbio_gpio1_16_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 64 0x2f /* gpmc_a0 - rx active | no pull | MODE7 (gpio1_16) */ 24 | >; 25 | }; 26 | pybbio_gpio1_16_rxactive_pullup: pinmux_pybbio_gpio1_16_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 64 0x37 /* gpmc_a0 - rx active | pull up | MODE7 (gpio1_16) */ 29 | >; 30 | }; 31 | pybbio_gpio1_16_rxactive_pulldown: pinmux_pybbio_gpio1_16_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 64 0x27 /* gpmc_a0 - rx active | pull down | MODE7 (gpio1_16) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_16_nopull: pinmux_pybbio_gpio1_16_nopull { 38 | pinctrl-single,pins = < 39 | 64 0x0f /* gpmc_a0 - rx active | no pull | MODE7 (gpio1_16) */ 40 | >; 41 | }; 42 | pybbio_gpio1_16_pullup: pinmux_pybbio_gpio1_16_pullup { 43 | pinctrl-single,pins = < 44 | 64 0x17 /* gpmc_a0 - rx active | pull up | MODE7 (gpio1_16) */ 45 | >; 46 | }; 47 | pybbio_gpio1_16_pulldown: pinmux_pybbio_gpio1_16_pulldown { 48 | pinctrl-single,pins = < 49 | 64 0x07 /* gpmc_a0 - rx active | pull down | MODE7 (gpio1_16) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_16 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_16_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_16_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_16_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_16_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_16_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_16_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_17-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_17"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_17"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_17_rxactive_nopull: pinmux_pybbio_gpio1_17_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 68 0x2f /* gpmc_a1 - rx active | no pull | MODE7 (gpio1_17) */ 24 | >; 25 | }; 26 | pybbio_gpio1_17_rxactive_pullup: pinmux_pybbio_gpio1_17_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 68 0x37 /* gpmc_a1 - rx active | pull up | MODE7 (gpio1_17) */ 29 | >; 30 | }; 31 | pybbio_gpio1_17_rxactive_pulldown: pinmux_pybbio_gpio1_17_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 68 0x27 /* gpmc_a1 - rx active | pull down | MODE7 (gpio1_17) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_17_nopull: pinmux_pybbio_gpio1_17_nopull { 38 | pinctrl-single,pins = < 39 | 68 0x0f /* gpmc_a1 - rx active | no pull | MODE7 (gpio1_17) */ 40 | >; 41 | }; 42 | pybbio_gpio1_17_pullup: pinmux_pybbio_gpio1_17_pullup { 43 | pinctrl-single,pins = < 44 | 68 0x17 /* gpmc_a1 - rx active | pull up | MODE7 (gpio1_17) */ 45 | >; 46 | }; 47 | pybbio_gpio1_17_pulldown: pinmux_pybbio_gpio1_17_pulldown { 48 | pinctrl-single,pins = < 49 | 68 0x07 /* gpmc_a1 - rx active | pull down | MODE7 (gpio1_17) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_17 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_17_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_17_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_17_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_17_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_17_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_17_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_18-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_18"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_18"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_18_rxactive_nopull: pinmux_pybbio_gpio1_18_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 72 0x2f /* gpmc_a2 - rx active | no pull | MODE7 (gpio1_18) */ 24 | >; 25 | }; 26 | pybbio_gpio1_18_rxactive_pullup: pinmux_pybbio_gpio1_18_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 72 0x37 /* gpmc_a2 - rx active | pull up | MODE7 (gpio1_18) */ 29 | >; 30 | }; 31 | pybbio_gpio1_18_rxactive_pulldown: pinmux_pybbio_gpio1_18_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 72 0x27 /* gpmc_a2 - rx active | pull down | MODE7 (gpio1_18) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_18_nopull: pinmux_pybbio_gpio1_18_nopull { 38 | pinctrl-single,pins = < 39 | 72 0x0f /* gpmc_a2 - rx active | no pull | MODE7 (gpio1_18) */ 40 | >; 41 | }; 42 | pybbio_gpio1_18_pullup: pinmux_pybbio_gpio1_18_pullup { 43 | pinctrl-single,pins = < 44 | 72 0x17 /* gpmc_a2 - rx active | pull up | MODE7 (gpio1_18) */ 45 | >; 46 | }; 47 | pybbio_gpio1_18_pulldown: pinmux_pybbio_gpio1_18_pulldown { 48 | pinctrl-single,pins = < 49 | 72 0x07 /* gpmc_a2 - rx active | pull down | MODE7 (gpio1_18) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_18 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_18_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_18_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_18_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_18_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_18_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_18_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_2-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_2"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_2"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_2_rxactive_nopull: pinmux_pybbio_gpio1_2_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 8 0x2f /* gpmc_ad2 - rx active | no pull | MODE7 (gpio1_2) */ 24 | >; 25 | }; 26 | pybbio_gpio1_2_rxactive_pullup: pinmux_pybbio_gpio1_2_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 8 0x37 /* gpmc_ad2 - rx active | pull up | MODE7 (gpio1_2) */ 29 | >; 30 | }; 31 | pybbio_gpio1_2_rxactive_pulldown: pinmux_pybbio_gpio1_2_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 8 0x27 /* gpmc_ad2 - rx active | pull down | MODE7 (gpio1_2) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_2_nopull: pinmux_pybbio_gpio1_2_nopull { 38 | pinctrl-single,pins = < 39 | 8 0x0f /* gpmc_ad2 - rx active | no pull | MODE7 (gpio1_2) */ 40 | >; 41 | }; 42 | pybbio_gpio1_2_pullup: pinmux_pybbio_gpio1_2_pullup { 43 | pinctrl-single,pins = < 44 | 8 0x17 /* gpmc_ad2 - rx active | pull up | MODE7 (gpio1_2) */ 45 | >; 46 | }; 47 | pybbio_gpio1_2_pulldown: pinmux_pybbio_gpio1_2_pulldown { 48 | pinctrl-single,pins = < 49 | 8 0x07 /* gpmc_ad2 - rx active | pull down | MODE7 (gpio1_2) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_2 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_2_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_2_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_2_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_2_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_2_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_2_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_3-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_3"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_3"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_3_rxactive_nopull: pinmux_pybbio_gpio1_3_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 12 0x2f /* gpmc_ad3 - rx active | no pull | MODE7 (gpio1_3) */ 24 | >; 25 | }; 26 | pybbio_gpio1_3_rxactive_pullup: pinmux_pybbio_gpio1_3_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 12 0x37 /* gpmc_ad3 - rx active | pull up | MODE7 (gpio1_3) */ 29 | >; 30 | }; 31 | pybbio_gpio1_3_rxactive_pulldown: pinmux_pybbio_gpio1_3_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 12 0x27 /* gpmc_ad3 - rx active | pull down | MODE7 (gpio1_3) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_3_nopull: pinmux_pybbio_gpio1_3_nopull { 38 | pinctrl-single,pins = < 39 | 12 0x0f /* gpmc_ad3 - rx active | no pull | MODE7 (gpio1_3) */ 40 | >; 41 | }; 42 | pybbio_gpio1_3_pullup: pinmux_pybbio_gpio1_3_pullup { 43 | pinctrl-single,pins = < 44 | 12 0x17 /* gpmc_ad3 - rx active | pull up | MODE7 (gpio1_3) */ 45 | >; 46 | }; 47 | pybbio_gpio1_3_pulldown: pinmux_pybbio_gpio1_3_pulldown { 48 | pinctrl-single,pins = < 49 | 12 0x07 /* gpmc_ad3 - rx active | pull down | MODE7 (gpio1_3) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_3 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_3_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_3_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_3_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_3_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_3_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_3_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_4-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_4"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_4"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_4_rxactive_nopull: pinmux_pybbio_gpio1_4_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 16 0x2f /* gpmc_ad4 - rx active | no pull | MODE7 (gpio1_4) */ 24 | >; 25 | }; 26 | pybbio_gpio1_4_rxactive_pullup: pinmux_pybbio_gpio1_4_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 16 0x37 /* gpmc_ad4 - rx active | pull up | MODE7 (gpio1_4) */ 29 | >; 30 | }; 31 | pybbio_gpio1_4_rxactive_pulldown: pinmux_pybbio_gpio1_4_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 16 0x27 /* gpmc_ad4 - rx active | pull down | MODE7 (gpio1_4) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_4_nopull: pinmux_pybbio_gpio1_4_nopull { 38 | pinctrl-single,pins = < 39 | 16 0x0f /* gpmc_ad4 - rx active | no pull | MODE7 (gpio1_4) */ 40 | >; 41 | }; 42 | pybbio_gpio1_4_pullup: pinmux_pybbio_gpio1_4_pullup { 43 | pinctrl-single,pins = < 44 | 16 0x17 /* gpmc_ad4 - rx active | pull up | MODE7 (gpio1_4) */ 45 | >; 46 | }; 47 | pybbio_gpio1_4_pulldown: pinmux_pybbio_gpio1_4_pulldown { 48 | pinctrl-single,pins = < 49 | 16 0x07 /* gpmc_ad4 - rx active | pull down | MODE7 (gpio1_4) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_4 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_4_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_4_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_4_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_4_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_4_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_4_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_5-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_5"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_5"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_5_rxactive_nopull: pinmux_pybbio_gpio1_5_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 20 0x2f /* gpmc_ad5 - rx active | no pull | MODE7 (gpio1_5) */ 24 | >; 25 | }; 26 | pybbio_gpio1_5_rxactive_pullup: pinmux_pybbio_gpio1_5_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 20 0x37 /* gpmc_ad5 - rx active | pull up | MODE7 (gpio1_5) */ 29 | >; 30 | }; 31 | pybbio_gpio1_5_rxactive_pulldown: pinmux_pybbio_gpio1_5_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 20 0x27 /* gpmc_ad5 - rx active | pull down | MODE7 (gpio1_5) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_5_nopull: pinmux_pybbio_gpio1_5_nopull { 38 | pinctrl-single,pins = < 39 | 20 0x0f /* gpmc_ad5 - rx active | no pull | MODE7 (gpio1_5) */ 40 | >; 41 | }; 42 | pybbio_gpio1_5_pullup: pinmux_pybbio_gpio1_5_pullup { 43 | pinctrl-single,pins = < 44 | 20 0x17 /* gpmc_ad5 - rx active | pull up | MODE7 (gpio1_5) */ 45 | >; 46 | }; 47 | pybbio_gpio1_5_pulldown: pinmux_pybbio_gpio1_5_pulldown { 48 | pinctrl-single,pins = < 49 | 20 0x07 /* gpmc_ad5 - rx active | pull down | MODE7 (gpio1_5) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_5 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_5_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_5_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_5_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_5_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_5_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_5_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_6-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_6"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_6"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_6_rxactive_nopull: pinmux_pybbio_gpio1_6_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 24 0x2f /* gpmc_ad6 - rx active | no pull | MODE7 (gpio1_6) */ 24 | >; 25 | }; 26 | pybbio_gpio1_6_rxactive_pullup: pinmux_pybbio_gpio1_6_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 24 0x37 /* gpmc_ad6 - rx active | pull up | MODE7 (gpio1_6) */ 29 | >; 30 | }; 31 | pybbio_gpio1_6_rxactive_pulldown: pinmux_pybbio_gpio1_6_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 24 0x27 /* gpmc_ad6 - rx active | pull down | MODE7 (gpio1_6) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_6_nopull: pinmux_pybbio_gpio1_6_nopull { 38 | pinctrl-single,pins = < 39 | 24 0x0f /* gpmc_ad6 - rx active | no pull | MODE7 (gpio1_6) */ 40 | >; 41 | }; 42 | pybbio_gpio1_6_pullup: pinmux_pybbio_gpio1_6_pullup { 43 | pinctrl-single,pins = < 44 | 24 0x17 /* gpmc_ad6 - rx active | pull up | MODE7 (gpio1_6) */ 45 | >; 46 | }; 47 | pybbio_gpio1_6_pulldown: pinmux_pybbio_gpio1_6_pulldown { 48 | pinctrl-single,pins = < 49 | 24 0x07 /* gpmc_ad6 - rx active | pull down | MODE7 (gpio1_6) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_6 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_6_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_6_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_6_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_6_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_6_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_6_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio1_7-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio1_7"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio1_7"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio1_7_rxactive_nopull: pinmux_pybbio_gpio1_7_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 28 0x2f /* gpmc_ad7 - rx active | no pull | MODE7 (gpio1_7) */ 24 | >; 25 | }; 26 | pybbio_gpio1_7_rxactive_pullup: pinmux_pybbio_gpio1_7_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 28 0x37 /* gpmc_ad7 - rx active | pull up | MODE7 (gpio1_7) */ 29 | >; 30 | }; 31 | pybbio_gpio1_7_rxactive_pulldown: pinmux_pybbio_gpio1_7_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 28 0x27 /* gpmc_ad7 - rx active | pull down | MODE7 (gpio1_7) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio1_7_nopull: pinmux_pybbio_gpio1_7_nopull { 38 | pinctrl-single,pins = < 39 | 28 0x0f /* gpmc_ad7 - rx active | no pull | MODE7 (gpio1_7) */ 40 | >; 41 | }; 42 | pybbio_gpio1_7_pullup: pinmux_pybbio_gpio1_7_pullup { 43 | pinctrl-single,pins = < 44 | 28 0x17 /* gpmc_ad7 - rx active | pull up | MODE7 (gpio1_7) */ 45 | >; 46 | }; 47 | pybbio_gpio1_7_pulldown: pinmux_pybbio_gpio1_7_pulldown { 48 | pinctrl-single,pins = < 49 | 28 0x07 /* gpmc_ad7 - rx active | pull down | MODE7 (gpio1_7) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio1_7 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio1_7_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio1_7_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio1_7_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio1_7_nopull>; 71 | pinctrl-4 = <&pybbio_gpio1_7_pullup>; 72 | pinctrl-5 = <&pybbio_gpio1_7_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_1-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_1"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_1"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_1_rxactive_nopull: pinmux_pybbio_gpio2_1_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 140 0x2f /* gpmc_clk - rx active | no pull | MODE7 (gpio2_1) */ 24 | >; 25 | }; 26 | pybbio_gpio2_1_rxactive_pullup: pinmux_pybbio_gpio2_1_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 140 0x37 /* gpmc_clk - rx active | pull up | MODE7 (gpio2_1) */ 29 | >; 30 | }; 31 | pybbio_gpio2_1_rxactive_pulldown: pinmux_pybbio_gpio2_1_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 140 0x27 /* gpmc_clk - rx active | pull down | MODE7 (gpio2_1) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_1_nopull: pinmux_pybbio_gpio2_1_nopull { 38 | pinctrl-single,pins = < 39 | 140 0x0f /* gpmc_clk - rx active | no pull | MODE7 (gpio2_1) */ 40 | >; 41 | }; 42 | pybbio_gpio2_1_pullup: pinmux_pybbio_gpio2_1_pullup { 43 | pinctrl-single,pins = < 44 | 140 0x17 /* gpmc_clk - rx active | pull up | MODE7 (gpio2_1) */ 45 | >; 46 | }; 47 | pybbio_gpio2_1_pulldown: pinmux_pybbio_gpio2_1_pulldown { 48 | pinctrl-single,pins = < 49 | 140 0x07 /* gpmc_clk - rx active | pull down | MODE7 (gpio2_1) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_1 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_1_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_1_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_1_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_1_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_1_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_1_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_4-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_4"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_4"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_4_rxactive_nopull: pinmux_pybbio_gpio2_4_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 152 0x2f /* gpmc_wen - rx active | no pull | MODE7 (gpio2_4) */ 24 | >; 25 | }; 26 | pybbio_gpio2_4_rxactive_pullup: pinmux_pybbio_gpio2_4_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 152 0x37 /* gpmc_wen - rx active | pull up | MODE7 (gpio2_4) */ 29 | >; 30 | }; 31 | pybbio_gpio2_4_rxactive_pulldown: pinmux_pybbio_gpio2_4_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 152 0x27 /* gpmc_wen - rx active | pull down | MODE7 (gpio2_4) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_4_nopull: pinmux_pybbio_gpio2_4_nopull { 38 | pinctrl-single,pins = < 39 | 152 0x0f /* gpmc_wen - rx active | no pull | MODE7 (gpio2_4) */ 40 | >; 41 | }; 42 | pybbio_gpio2_4_pullup: pinmux_pybbio_gpio2_4_pullup { 43 | pinctrl-single,pins = < 44 | 152 0x17 /* gpmc_wen - rx active | pull up | MODE7 (gpio2_4) */ 45 | >; 46 | }; 47 | pybbio_gpio2_4_pulldown: pinmux_pybbio_gpio2_4_pulldown { 48 | pinctrl-single,pins = < 49 | 152 0x07 /* gpmc_wen - rx active | pull down | MODE7 (gpio2_4) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_4 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_4_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_4_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_4_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_4_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_4_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_4_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_6-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_6"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_6"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_6_rxactive_nopull: pinmux_pybbio_gpio2_6_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 160 0x2f /* lcd_data0 - rx active | no pull | MODE7 (gpio2_6) */ 24 | >; 25 | }; 26 | pybbio_gpio2_6_rxactive_pullup: pinmux_pybbio_gpio2_6_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 160 0x37 /* lcd_data0 - rx active | pull up | MODE7 (gpio2_6) */ 29 | >; 30 | }; 31 | pybbio_gpio2_6_rxactive_pulldown: pinmux_pybbio_gpio2_6_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 160 0x27 /* lcd_data0 - rx active | pull down | MODE7 (gpio2_6) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_6_nopull: pinmux_pybbio_gpio2_6_nopull { 38 | pinctrl-single,pins = < 39 | 160 0x0f /* lcd_data0 - rx active | no pull | MODE7 (gpio2_6) */ 40 | >; 41 | }; 42 | pybbio_gpio2_6_pullup: pinmux_pybbio_gpio2_6_pullup { 43 | pinctrl-single,pins = < 44 | 160 0x17 /* lcd_data0 - rx active | pull up | MODE7 (gpio2_6) */ 45 | >; 46 | }; 47 | pybbio_gpio2_6_pulldown: pinmux_pybbio_gpio2_6_pulldown { 48 | pinctrl-single,pins = < 49 | 160 0x07 /* lcd_data0 - rx active | pull down | MODE7 (gpio2_6) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_6 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_6_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_6_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_6_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_6_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_6_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_6_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_7-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_7"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_7"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_7_rxactive_nopull: pinmux_pybbio_gpio2_7_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 164 0x2f /* lcd_data1 - rx active | no pull | MODE7 (gpio2_7) */ 24 | >; 25 | }; 26 | pybbio_gpio2_7_rxactive_pullup: pinmux_pybbio_gpio2_7_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 164 0x37 /* lcd_data1 - rx active | pull up | MODE7 (gpio2_7) */ 29 | >; 30 | }; 31 | pybbio_gpio2_7_rxactive_pulldown: pinmux_pybbio_gpio2_7_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 164 0x27 /* lcd_data1 - rx active | pull down | MODE7 (gpio2_7) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_7_nopull: pinmux_pybbio_gpio2_7_nopull { 38 | pinctrl-single,pins = < 39 | 164 0x0f /* lcd_data1 - rx active | no pull | MODE7 (gpio2_7) */ 40 | >; 41 | }; 42 | pybbio_gpio2_7_pullup: pinmux_pybbio_gpio2_7_pullup { 43 | pinctrl-single,pins = < 44 | 164 0x17 /* lcd_data1 - rx active | pull up | MODE7 (gpio2_7) */ 45 | >; 46 | }; 47 | pybbio_gpio2_7_pulldown: pinmux_pybbio_gpio2_7_pulldown { 48 | pinctrl-single,pins = < 49 | 164 0x07 /* lcd_data1 - rx active | pull down | MODE7 (gpio2_7) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_7 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_7_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_7_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_7_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_7_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_7_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_7_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_8-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_8"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_8"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_8_rxactive_nopull: pinmux_pybbio_gpio2_8_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 168 0x2f /* lcd_data2 - rx active | no pull | MODE7 (gpio2_8) */ 24 | >; 25 | }; 26 | pybbio_gpio2_8_rxactive_pullup: pinmux_pybbio_gpio2_8_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 168 0x37 /* lcd_data2 - rx active | pull up | MODE7 (gpio2_8) */ 29 | >; 30 | }; 31 | pybbio_gpio2_8_rxactive_pulldown: pinmux_pybbio_gpio2_8_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 168 0x27 /* lcd_data2 - rx active | pull down | MODE7 (gpio2_8) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_8_nopull: pinmux_pybbio_gpio2_8_nopull { 38 | pinctrl-single,pins = < 39 | 168 0x0f /* lcd_data2 - rx active | no pull | MODE7 (gpio2_8) */ 40 | >; 41 | }; 42 | pybbio_gpio2_8_pullup: pinmux_pybbio_gpio2_8_pullup { 43 | pinctrl-single,pins = < 44 | 168 0x17 /* lcd_data2 - rx active | pull up | MODE7 (gpio2_8) */ 45 | >; 46 | }; 47 | pybbio_gpio2_8_pulldown: pinmux_pybbio_gpio2_8_pulldown { 48 | pinctrl-single,pins = < 49 | 168 0x07 /* lcd_data2 - rx active | pull down | MODE7 (gpio2_8) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_8 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_8_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_8_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_8_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_8_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_8_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_8_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-gpio2_9-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-gpio2_9"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "gpio2_9"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_gpio2_9_rxactive_nopull: pinmux_pybbio_gpio2_9_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 172 0x2f /* lcd_data3 - rx active | no pull | MODE7 (gpio2_9) */ 24 | >; 25 | }; 26 | pybbio_gpio2_9_rxactive_pullup: pinmux_pybbio_gpio2_9_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 172 0x37 /* lcd_data3 - rx active | pull up | MODE7 (gpio2_9) */ 29 | >; 30 | }; 31 | pybbio_gpio2_9_rxactive_pulldown: pinmux_pybbio_gpio2_9_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 172 0x27 /* lcd_data3 - rx active | pull down | MODE7 (gpio2_9) */ 34 | >; 35 | }; 36 | 37 | pybbio_gpio2_9_nopull: pinmux_pybbio_gpio2_9_nopull { 38 | pinctrl-single,pins = < 39 | 172 0x0f /* lcd_data3 - rx active | no pull | MODE7 (gpio2_9) */ 40 | >; 41 | }; 42 | pybbio_gpio2_9_pullup: pinmux_pybbio_gpio2_9_pullup { 43 | pinctrl-single,pins = < 44 | 172 0x17 /* lcd_data3 - rx active | pull up | MODE7 (gpio2_9) */ 45 | >; 46 | }; 47 | pybbio_gpio2_9_pulldown: pinmux_pybbio_gpio2_9_pulldown { 48 | pinctrl-single,pins = < 49 | 172 0x07 /* lcd_data3 - rx active | pull down | MODE7 (gpio2_9) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-gpio2_9 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_gpio2_9_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_gpio2_9_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_gpio2_9_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_gpio2_9_nopull>; 71 | pinctrl-4 = <&pybbio_gpio2_9_pullup>; 72 | pinctrl-5 = <&pybbio_gpio2_9_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-usr0-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-usr0"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "usr0"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_usr0_rxactive_nopull: pinmux_pybbio_usr0_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 84 0x2f /* gpmc_a5 - rx active | no pull | MODE7 (usr0) */ 24 | >; 25 | }; 26 | pybbio_usr0_rxactive_pullup: pinmux_pybbio_usr0_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 84 0x37 /* gpmc_a5 - rx active | pull up | MODE7 (usr0) */ 29 | >; 30 | }; 31 | pybbio_usr0_rxactive_pulldown: pinmux_pybbio_usr0_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 84 0x27 /* gpmc_a5 - rx active | pull down | MODE7 (usr0) */ 34 | >; 35 | }; 36 | 37 | pybbio_usr0_nopull: pinmux_pybbio_usr0_nopull { 38 | pinctrl-single,pins = < 39 | 84 0x0f /* gpmc_a5 - rx active | no pull | MODE7 (usr0) */ 40 | >; 41 | }; 42 | pybbio_usr0_pullup: pinmux_pybbio_usr0_pullup { 43 | pinctrl-single,pins = < 44 | 84 0x17 /* gpmc_a5 - rx active | pull up | MODE7 (usr0) */ 45 | >; 46 | }; 47 | pybbio_usr0_pulldown: pinmux_pybbio_usr0_pulldown { 48 | pinctrl-single,pins = < 49 | 84 0x07 /* gpmc_a5 - rx active | pull down | MODE7 (usr0) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-usr0 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_usr0_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_usr0_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_usr0_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_usr0_nopull>; 71 | pinctrl-4 = <&pybbio_usr0_pullup>; 72 | pinctrl-5 = <&pybbio_usr0_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-usr1-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-usr1"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "usr1"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_usr1_rxactive_nopull: pinmux_pybbio_usr1_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 88 0x2f /* gpmc_a6 - rx active | no pull | MODE7 (usr1) */ 24 | >; 25 | }; 26 | pybbio_usr1_rxactive_pullup: pinmux_pybbio_usr1_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 88 0x37 /* gpmc_a6 - rx active | pull up | MODE7 (usr1) */ 29 | >; 30 | }; 31 | pybbio_usr1_rxactive_pulldown: pinmux_pybbio_usr1_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 88 0x27 /* gpmc_a6 - rx active | pull down | MODE7 (usr1) */ 34 | >; 35 | }; 36 | 37 | pybbio_usr1_nopull: pinmux_pybbio_usr1_nopull { 38 | pinctrl-single,pins = < 39 | 88 0x0f /* gpmc_a6 - rx active | no pull | MODE7 (usr1) */ 40 | >; 41 | }; 42 | pybbio_usr1_pullup: pinmux_pybbio_usr1_pullup { 43 | pinctrl-single,pins = < 44 | 88 0x17 /* gpmc_a6 - rx active | pull up | MODE7 (usr1) */ 45 | >; 46 | }; 47 | pybbio_usr1_pulldown: pinmux_pybbio_usr1_pulldown { 48 | pinctrl-single,pins = < 49 | 88 0x07 /* gpmc_a6 - rx active | pull down | MODE7 (usr1) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-usr1 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_usr1_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_usr1_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_usr1_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_usr1_nopull>; 71 | pinctrl-4 = <&pybbio_usr1_pullup>; 72 | pinctrl-5 = <&pybbio_usr1_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-usr2-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-usr2"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "usr2"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_usr2_rxactive_nopull: pinmux_pybbio_usr2_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 92 0x2f /* gpmc_a7 - rx active | no pull | MODE7 (usr2) */ 24 | >; 25 | }; 26 | pybbio_usr2_rxactive_pullup: pinmux_pybbio_usr2_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 92 0x37 /* gpmc_a7 - rx active | pull up | MODE7 (usr2) */ 29 | >; 30 | }; 31 | pybbio_usr2_rxactive_pulldown: pinmux_pybbio_usr2_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 92 0x27 /* gpmc_a7 - rx active | pull down | MODE7 (usr2) */ 34 | >; 35 | }; 36 | 37 | pybbio_usr2_nopull: pinmux_pybbio_usr2_nopull { 38 | pinctrl-single,pins = < 39 | 92 0x0f /* gpmc_a7 - rx active | no pull | MODE7 (usr2) */ 40 | >; 41 | }; 42 | pybbio_usr2_pullup: pinmux_pybbio_usr2_pullup { 43 | pinctrl-single,pins = < 44 | 92 0x17 /* gpmc_a7 - rx active | pull up | MODE7 (usr2) */ 45 | >; 46 | }; 47 | pybbio_usr2_pulldown: pinmux_pybbio_usr2_pulldown { 48 | pinctrl-single,pins = < 49 | 92 0x07 /* gpmc_a7 - rx active | pull down | MODE7 (usr2) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-usr2 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_usr2_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_usr2_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_usr2_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_usr2_nopull>; 71 | pinctrl-4 = <&pybbio_usr2_pullup>; 72 | pinctrl-5 = <&pybbio_usr2_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/PyBBIO-usr3-00A0.dts: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | 7 | part-number = "PyBBIO-usr3"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | 14 | /* the hardware IP uses */ 15 | "usr3"; 16 | 17 | fragment@0 { 18 | target = <&am33xx_pinmux>; 19 | __overlay__ { 20 | 21 | pybbio_usr3_rxactive_nopull: pinmux_pybbio_usr3_rxactive_nopull { 22 | pinctrl-single,pins = < 23 | 96 0x2f /* gpmc_a8 - rx active | no pull | MODE7 (usr3) */ 24 | >; 25 | }; 26 | pybbio_usr3_rxactive_pullup: pinmux_pybbio_usr3_rxactive_pullup { 27 | pinctrl-single,pins = < 28 | 96 0x37 /* gpmc_a8 - rx active | pull up | MODE7 (usr3) */ 29 | >; 30 | }; 31 | pybbio_usr3_rxactive_pulldown: pinmux_pybbio_usr3_rxactive_pulldown { 32 | pinctrl-single,pins = < 33 | 96 0x27 /* gpmc_a8 - rx active | pull down | MODE7 (usr3) */ 34 | >; 35 | }; 36 | 37 | pybbio_usr3_nopull: pinmux_pybbio_usr3_nopull { 38 | pinctrl-single,pins = < 39 | 96 0x0f /* gpmc_a8 - rx active | no pull | MODE7 (usr3) */ 40 | >; 41 | }; 42 | pybbio_usr3_pullup: pinmux_pybbio_usr3_pullup { 43 | pinctrl-single,pins = < 44 | 96 0x17 /* gpmc_a8 - rx active | pull up | MODE7 (usr3) */ 45 | >; 46 | }; 47 | pybbio_usr3_pulldown: pinmux_pybbio_usr3_pulldown { 48 | pinctrl-single,pins = < 49 | 96 0x07 /* gpmc_a8 - rx active | pull down | MODE7 (usr3) */ 50 | >; 51 | }; 52 | 53 | }; 54 | }; 55 | 56 | fragment@1 { 57 | target = <&ocp>; /* On-Chip Peripherals */ 58 | __overlay__ { 59 | PyBBIO-usr3 { 60 | compatible = "bone-pinmux-helper"; /* Use the pinmux helper */ 61 | status="okay"; 62 | /* Define custom names for indexes in pinctrl array: */ 63 | pinctrl-names = "mode_0b00101111", "mode_0b00110111", "mode_0b00100111", 64 | "mode_0b00001111", "mode_0b00010111", "mode_0b00000111"; 65 | /* Set the elements of the pinctrl array to the pinmux overlays 66 | defined above: */ 67 | pinctrl-0 = <&pybbio_usr3_rxactive_nopull>; 68 | pinctrl-1 = <&pybbio_usr3_rxactive_pullup>; 69 | pinctrl-2 = <&pybbio_usr3_rxactive_pulldown>; 70 | pinctrl-3 = <&pybbio_usr3_nopull>; 71 | pinctrl-4 = <&pybbio_usr3_pullup>; 72 | pinctrl-5 = <&pybbio_usr3_pulldown>; 73 | }; 74 | }; 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /tools/overlays/adc-template.txt: -------------------------------------------------------------------------------- 1 | /dts-v1/; 2 | /plugin/; 3 | 4 | /{ 5 | compatible = "ti,beaglebone", "ti,beaglebone-black"; 6 | /* identification */ 7 | part-number = "{overlay_name}"; 8 | version = "00A0"; 9 | 10 | /* state the resources this cape uses */ 11 | exclusive-use = 12 | /* the pin header uses */ 13 | "{header_pin}"; 14 | 15 | fragment@0 { 16 | target = <&ocp>; 17 | __overlay__ { 18 | /* avoid stupid warning */ 19 | #address-cells = <1>; 20 | #size-cells = <1>; 21 | adc_helper: {overlay_name} { 22 | compatible = "bone-iio-helper"; 23 | vsense-name = "{adc_ch}"; 24 | vsense-scale = <{adc_scale}>; 25 | status = "okay"; 26 | }; 27 | }; 28 | }; 29 | }; 30 | -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-ADC-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-ADC-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN3-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN3-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN4-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN4-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN5-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN5-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN6-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN6-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-AIN7-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-AIN7-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-ecap0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-ecap0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-ecap1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-ecap1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-ehrpwm1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-ehrpwm1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-ehrpwm2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-ehrpwm2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-epwmss0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-epwmss0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-epwmss1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-epwmss1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-epwmss2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-epwmss2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-eqep0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-eqep0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-eqep1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-eqep1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-eqep2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-eqep2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-eqep2b-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-eqep2b-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_10-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_10-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_11-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_11-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_12-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_12-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_13-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_13-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_14-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_14-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_15-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_15-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_20-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_20-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_22-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_22-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_23-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_23-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_26-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_26-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_27-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_27-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_3-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_3-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_30-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_30-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_31-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_31-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_4-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_4-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_5-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_5-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_7-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_7-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_8-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_8-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio0_9-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio0_9-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_12-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_12-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_13-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_13-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_14-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_14-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_15-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_15-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_16-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_16-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_17-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_17-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_18-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_18-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_19-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_19-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_28-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_28-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_29-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_29-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_3-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_3-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_30-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_30-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_31-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_31-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_4-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_4-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_5-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_5-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_6-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_6-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio1_7-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio1_7-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_10-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_10-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_11-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_11-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_12-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_12-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_13-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_13-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_14-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_14-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_15-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_15-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_16-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_16-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_17-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_17-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_22-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_22-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_23-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_23-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_24-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_24-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_25-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_25-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_3-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_3-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_4-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_4-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_5-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_5-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_6-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_6-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_7-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_7-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_8-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_8-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio2_9-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio2_9-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_14-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_14-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_15-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_15-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_16-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_16-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_17-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_17-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_19-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_19-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-gpio3_21-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-gpio3_21-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-usr0-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-usr0-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-usr1-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-usr1-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-usr2-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-usr2-00A0.dtbo -------------------------------------------------------------------------------- /tools/overlays/compiled/PyBBIO-usr3-00A0.dtbo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/graycatlabs/PyBBIO/0d46115059ed7ec0c17afb6dd7ed2f507b4f2b8a/tools/overlays/compiled/PyBBIO-usr3-00A0.dtbo --------------------------------------------------------------------------------