From: Melissa LeBlanc-Williams Date: Mon, 5 May 2025 19:39:50 +0000 (-0700) Subject: Merge branch 'main' of https://github.com/fb0u/Adafruit_Blinka into fb0u X-Git-Tag: 8.57.0~3^2 X-Git-Url: https://git.ayoreis.com/Adafruit_Blinka-hackapet.git/commitdiff_plain/074378ed284105b5099de2eeb7e62bd0a76628f6?hp=119412cc2c5e1a9f9f0ad302a01c33e1c261e28e Merge branch 'main' of https://github.com/fb0u/Adafruit_Blinka into fb0u --- diff --git a/setup.py b/setup.py index 92ce579..b793194 100755 --- a/setup.py +++ b/setup.py @@ -31,7 +31,7 @@ if os.path.exists("/proc/device-tree/compatible"): elif b"brcm,bcm2712" in compat: board_reqs = [ "rpi_ws281x>=4.0.0", - "rpi-lgpio", + "lgpio", "Adafruit-Blinka-Raspberry-Pi5-Neopixel", ] # Pi 4 and Earlier diff --git a/src/adafruit_blinka/board/bananapi/bpif5.py b/src/adafruit_blinka/board/bananapi/bpif5.py new file mode 100644 index 0000000..3fbc280 --- /dev/null +++ b/src/adafruit_blinka/board/bananapi/bpif5.py @@ -0,0 +1,71 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Pin definitions for the Banana Pi F5.""" + +from adafruit_blinka.microcontroller.allwinner.t527 import pin + +# I2C +I2C4_SCL = pin.I2C4_SCL +I2C4_SDA = pin.I2C4_SDA +I2C5_SCL = pin.I2C5_SCL +I2C5_SDA = pin.I2C5_SDA + +# Default I2C +SCL = I2C5_SCL +SDA = I2C5_SDA + +# UART +UART2_TX = pin.UART2_TX +UART2_RX = pin.UART2_RX +UART7_TX = pin.UART7_TX +UART7_RX = pin.UART7_RX + +# Default UART +TX = UART7_TX +RX = UART7_RX +TXD = UART7_TX +RXD = UART7_RX + +# SPI +SPI1_MOSI = pin.SPI1_MOSI +SPI1_MISO = pin.SPI1_MISO +SPI1_SCLK = pin.SPI1_SCLK +SPI1_CS0 = pin.SPI1_CS0 + +# Default SPI +MOSI = SPI1_MOSI +MISO = SPI1_MISO +SCLK = SPI1_SCLK +CS = SPI1_CS0 + +# Pinout reference: +# https://wiki.banana-pi.org/Banana_Pi_BPI-M4_Berry#BPI-M4_Berry_40-pin_header +D3 = pin.PI9 +D5 = pin.PI8 +D7 = pin.PI10 +D8 = pin.PB13 +D10 = pin.PB14 +D11 = pin.PB0 +D12 = pin.PB5 +D13 = pin.PB1 +D15 = pin.PB2 +D16 = pin.PB11 +D18 = pin.PB12 +D19 = pin.PI4 +D21 = pin.PI5 +D22 = pin.PI7 +D23 = pin.PI3 +D24 = pin.PI2 +D26 = pin.PI6 +D27 = pin.PI1 +D28 = pin.PI0 +D29 = pin.PB3 +D31 = pin.PL4 +D32 = pin.PI11 +D33 = pin.PL5 +D35 = pin.PB6 +D36 = pin.PI12 +D37 = pin.PB4 +D38 = pin.PB8 +D40 = pin.PB7 diff --git a/src/adafruit_blinka/board/horizon/rdkx3.py b/src/adafruit_blinka/board/horizon/rdkx3.py new file mode 100644 index 0000000..e132cb1 --- /dev/null +++ b/src/adafruit_blinka/board/horizon/rdkx3.py @@ -0,0 +1,54 @@ +# SPDX-FileCopyrightText: 2024 Hajime Fujimoto +# +# SPDX-License-Identifier: MIT +"""Pin definitions for RDK-X3.""" + +from adafruit_blinka.microcontroller.horizon.sunrise_x3 import pin + +D0 = pin.D0 +D1 = pin.D1 + +D2 = pin.D2 +SDA = pin.SDA +D3 = pin.D3 +SCL = pin.SCL + +D4 = pin.D4 +D5 = pin.D5 +D6 = pin.D6 + +D7 = pin.D7 +CE1 = pin.D7 +D8 = pin.D8 +CE0 = pin.D8 +D9 = pin.D9 +MISO = pin.D9 +D10 = pin.D10 +MOSI = pin.D10 +D11 = pin.D11 +SCLK = pin.D11 +SCK = pin.D11 + +D12 = pin.D12 +D13 = pin.D13 + +D14 = pin.D14 +TXD = pin.D14 +D15 = pin.D15 +RXD = pin.D15 +# create alias for most of the examples +TX = pin.D14 +RX = pin.D15 + +D16 = pin.D16 +D17 = pin.D17 +D18 = pin.D18 +D19 = pin.D19 +D20 = pin.D20 +D21 = pin.D21 +D22 = pin.D22 +D23 = pin.D23 +D24 = pin.D24 +D25 = pin.D25 +D26 = pin.D26 +D27 = pin.D27 diff --git a/src/adafruit_blinka/board/orangepi/orangepi3lts.py b/src/adafruit_blinka/board/orangepi/orangepi3lts.py new file mode 100644 index 0000000..25ef624 --- /dev/null +++ b/src/adafruit_blinka/board/orangepi/orangepi3lts.py @@ -0,0 +1,34 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Pin definitions for the Orange Pi 3 LTS.""" + +from adafruit_blinka.microcontroller.allwinner.h6 import pin + +PD26 = pin.PD26 +SDA = pin.PD26 +PD25 = pin.PD25 +SCL = pin.PD25 +PD22 = pin.PD22 +PL2 = pin.PL2 +PL3 = pin.PL3 +PD24 = pin.PD24 +UART3_RX = pin.PD24 +PD18 = pin.PD18 +PD23 = pin.PD23 +UART3_TX = pin.PD23 +PL10 = pin.PL10 +PD15 = pin.PD15 +PD16 = pin.PD16 +PH5 = pin.PH5 +PH6 = pin.PH6 +PD21 = pin.PD21 +PH4 = pin.PH4 +SPI1_CLK = pin.PH4 +PH3 = pin.PH3 +SPI1_CS = pin.PH3 +PL8 = pin.PL8 + +SCLK = pin.PH4 +MOSI = pin.PH5 +MISO = pin.PH6 diff --git a/src/adafruit_blinka/board/radxa/radxazero3.py b/src/adafruit_blinka/board/radxa/radxazero3.py index 46a44d6..04b8d14 100644 --- a/src/adafruit_blinka/board/radxa/radxazero3.py +++ b/src/adafruit_blinka/board/radxa/radxazero3.py @@ -63,3 +63,7 @@ TXD = D0_D1 RXD = D0_D0 TX = D0_D1 RX = D0_D0 + +# PWM +PWM8 = D3_B1 +PWM9 = D3_B2 diff --git a/src/adafruit_blinka/board/raspberrypi/raspi_5.py b/src/adafruit_blinka/board/raspberrypi/raspi_5.py new file mode 100644 index 0000000..ef09c3a --- /dev/null +++ b/src/adafruit_blinka/board/raspberrypi/raspi_5.py @@ -0,0 +1,58 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Pin definitions for Raspberry Pi 5 models using the BCM2712.""" + +from adafruit_blinka.microcontroller.bcm2712 import pin + +D0 = pin.D0 +D1 = pin.D1 + +D2 = pin.D2 +SDA = pin.SDA +D3 = pin.D3 +SCL = pin.SCL + +D4 = pin.D4 +D5 = pin.D5 +D6 = pin.D6 + +D7 = pin.D7 +CE1 = pin.D7 +D8 = pin.D8 +CE0 = pin.D8 +D9 = pin.D9 +MISO = pin.D9 +D10 = pin.D10 +MOSI = pin.D10 +D11 = pin.D11 +SCLK = pin.D11 +SCK = pin.D11 + +D12 = pin.D12 +D13 = pin.D13 + +D14 = pin.D14 +TXD = pin.D14 +D15 = pin.D15 +RXD = pin.D15 +# create alias for most of the examples +TX = pin.D14 +RX = pin.D15 + +D16 = pin.D16 +D17 = pin.D17 +D18 = pin.D18 +D19 = pin.D19 +MISO_1 = pin.D19 +D20 = pin.D20 +MOSI_1 = pin.D20 +D21 = pin.D21 +SCLK_1 = pin.D21 +SCK_1 = pin.D21 +D22 = pin.D22 +D23 = pin.D23 +D24 = pin.D24 +D25 = pin.D25 +D26 = pin.D26 +D27 = pin.D27 diff --git a/src/adafruit_blinka/board/vicharak/axon.py b/src/adafruit_blinka/board/vicharak/axon.py new file mode 100644 index 0000000..93f331b --- /dev/null +++ b/src/adafruit_blinka/board/vicharak/axon.py @@ -0,0 +1,88 @@ +# SPDX-FileCopyrightText: 2025 djkabutar +# See https://docs.vicharak.in/vicharak_sbcs/vaaman/vaaman-gpio-description for pinout +# +# SPDX-License-Identifier: MIT +"""Pin definitions for the Vicharak Vaaman.""" + +from adafruit_blinka.microcontroller.rockchip.rk3588 import pin + +D2 = pin.GPIO0_B6 +D4 = pin.GPIO0_B5 +D9 = pin.GPIO2_C1 +D10 = pin.GPIO2_B6 +D11 = pin.GPIO2_C0 +D12 = pin.GPIO2_B7 +D13 = pin.GPIO0_C0 +D17 = pin.GPIO1_D0 +D18 = pin.GPIO1_D1 +D19 = pin.GPIO1_D3 +D20 = pin.GPIO1_D2 +D23 = pin.GPIO1_B3 +D29 = pin.ADC_IN1 +D30 = pin.ADC_IN2 +D28 = pin.ADC_IN3 +D27 = pin.ADC_IN4 + +# UART +# UART2_M0 +UART2_RX = D2 +UART2_TX = D4 +# UART1_M0 +UART1_RX = D10 +UART1_TX = D12 +UART1_CSTN = D9 +UART1_RSTN = D11 +# UART6_M2 +UART6_RX = D17 +UART6_TX = D18 +# UART4_M0 +UART4_RX = D19 +UART4_TX = D20 + +# Default UART -> UART2_M0 +UART_RX = UART2_RX +UART_TX = UART2_TX + +# I2C +# I2C2_M1 +I2C2_SCL = D9 +I2C2_SDA = D11 +# I2C5_M4 +I2C5_SCL = D10 +I2C5_SDA = D12 +# I2C7_M0 +I2C7_SCL = D17 +I2C7_SDA = D18 +# I2C1_M4 +I2C1_SCL = D20 +I2C1_SDA = D19 + +# Default I2C -> I2C2_M1 +SCL = I2C2_SCL +SDA = I2C2_SDA + +# SPI +# SPI1_M2 +SPI_MOSI = D18 +SPI_MISO = D17 +SPI_CLK = D20 +SPI_SCLK = SPI_CLK +SPI_CS0 = D19 +SPI_CS = SPI_CS0 + +MOSI = D18 +MISO = D17 +SCLK = SPI_CLK +CS = D19 + +# PWM +# PWM0_M1 +PWM0 = D20 +PWM1_M0 = D13 +PWM1_M1 = D19 + +# ADC +ADC_IN1 = D29 +ADC_IN2 = D30 +ADC_IN3 = D28 +ADC_IN4 = D27 diff --git a/src/adafruit_blinka/board/vicharak/vaaman.py b/src/adafruit_blinka/board/vicharak/vaaman.py new file mode 100644 index 0000000..6147f71 --- /dev/null +++ b/src/adafruit_blinka/board/vicharak/vaaman.py @@ -0,0 +1,52 @@ +# SPDX-FileCopyrightText: 2025 djkabutar +# See https://docs.vicharak.in/vicharak_sbcs/vaaman/vaaman-gpio-description for pinout +# +# SPDX-License-Identifier: MIT +"""Pin definitions for the Vicharak Vaaman.""" + +from adafruit_blinka.microcontroller.rockchip.rk3399 import pin + +D7 = pin.GPIO2_B3 +D8 = pin.GPIO4_C4 +D10 = pin.GPIO4_C3 +D11 = pin.GPIO4_C2 +D12 = pin.GPIO4_A3 +D13 = pin.GPIO4_C6 +D15 = pin.GPIO4_C5 +D16 = pin.GPIO4_D2 +D18 = pin.GPIO4_D4 +D22 = pin.GPIO4_D5 +D27 = pin.GPIO2_A0 +D28 = pin.GPIO2_A1 +D29 = pin.GPIO2_B2 +D31 = pin.GPIO2_B1 +D32 = pin.GPIO3_C0 +D33 = pin.GPIO2_B4 +D35 = pin.GPIO4_A5 +D36 = pin.GPIO4_A4 +D37 = pin.GPIO4_D6 +D38 = pin.GPIO4_A6 +D40 = pin.GPIO4_A7 + +SDA2 = D27 +SCL2 = D28 + +SDA6 = D31 +SCL6 = D29 + +SDA7 = pin.I2C7_SDA +SCL7 = pin.I2C7_SCL + +SDA = SDA2 +SCL = SCL2 + +UART2_TX = D8 +UART2_RX = D10 + +UART_TX = UART2_TX +UART_RX = UART2_RX + +PWM0 = pin.PWM0 +PWM1 = pin.PWM1 + +ADC_IN0 = pin.ADC_IN0 diff --git a/src/adafruit_blinka/microcontroller/allwinner/t527/__init__.py b/src/adafruit_blinka/microcontroller/allwinner/t527/__init__.py new file mode 100644 index 0000000..ed3e8fb --- /dev/null +++ b/src/adafruit_blinka/microcontroller/allwinner/t527/__init__.py @@ -0,0 +1,4 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Definition for the AllWinner T527 chip""" diff --git a/src/adafruit_blinka/microcontroller/allwinner/t527/pin.py b/src/adafruit_blinka/microcontroller/allwinner/t527/pin.py new file mode 100644 index 0000000..5911edc --- /dev/null +++ b/src/adafruit_blinka/microcontroller/allwinner/t527/pin.py @@ -0,0 +1,306 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Allwinner T527 Pin Names""" +import gpiod +from adafruit_blinka.microcontroller.generic_linux.libgpiod_pin import Pin + +chip0 = gpiod.Chip("/dev/gpiochip0") +chip1 = gpiod.Chip("/dev/gpiochip1") +num = chip0.get_info().num_lines + +if num < 100: + __chip_num = 1 + __chip_r_num = 0 +else: + __chip_num = 0 + __chip_r_num = 1 + +chip0.close() +chip1.close() + +PB0 = Pin((__chip_num, 32)) +PB1 = Pin((__chip_num, 33)) +PB2 = Pin((__chip_num, 34)) +PB3 = Pin((__chip_num, 35)) +PB4 = Pin((__chip_num, 36)) +PB5 = Pin((__chip_num, 37)) +PB6 = Pin((__chip_num, 38)) +PB7 = Pin((__chip_num, 39)) +PB8 = Pin((__chip_num, 40)) +PB9 = Pin((__chip_num, 41)) +PB10 = Pin((__chip_num, 42)) +PB11 = Pin((__chip_num, 43)) +PB12 = Pin((__chip_num, 44)) +PB13 = Pin((__chip_num, 45)) +PB14 = Pin((__chip_num, 46)) + +PC0 = Pin((__chip_num, 64)) +PC1 = Pin((__chip_num, 65)) +PC2 = Pin((__chip_num, 66)) +PC3 = Pin((__chip_num, 67)) +PC4 = Pin((__chip_num, 68)) +PC5 = Pin((__chip_num, 69)) +PC6 = Pin((__chip_num, 70)) +PC7 = Pin((__chip_num, 71)) +PC8 = Pin((__chip_num, 72)) +PC9 = Pin((__chip_num, 73)) +PC10 = Pin((__chip_num, 74)) +PC11 = Pin((__chip_num, 75)) +PC12 = Pin((__chip_num, 76)) +PC13 = Pin((__chip_num, 77)) +PC14 = Pin((__chip_num, 78)) +PC15 = Pin((__chip_num, 79)) +PC16 = Pin((__chip_num, 80)) + +PD0 = Pin((__chip_num, 96)) +PD1 = Pin((__chip_num, 97)) +PD2 = Pin((__chip_num, 98)) +PD3 = Pin((__chip_num, 99)) +PD4 = Pin((__chip_num, 100)) +PD5 = Pin((__chip_num, 101)) +PD6 = Pin((__chip_num, 102)) +PD7 = Pin((__chip_num, 103)) +PD8 = Pin((__chip_num, 104)) +PD9 = Pin((__chip_num, 105)) +PD10 = Pin((__chip_num, 106)) +PD11 = Pin((__chip_num, 107)) +PD12 = Pin((__chip_num, 108)) +PD13 = Pin((__chip_num, 109)) +PD14 = Pin((__chip_num, 110)) +PD15 = Pin((__chip_num, 111)) +PD16 = Pin((__chip_num, 112)) +PD17 = Pin((__chip_num, 113)) +PD18 = Pin((__chip_num, 114)) +PD19 = Pin((__chip_num, 115)) +PD20 = Pin((__chip_num, 116)) +PD21 = Pin((__chip_num, 117)) +PD22 = Pin((__chip_num, 118)) +PD23 = Pin((__chip_num, 119)) + +PE0 = Pin((__chip_num, 128)) +PE1 = Pin((__chip_num, 129)) +PE2 = Pin((__chip_num, 130)) +PE3 = Pin((__chip_num, 131)) +PE4 = Pin((__chip_num, 132)) +PE5 = Pin((__chip_num, 133)) +PE6 = Pin((__chip_num, 134)) +PE7 = Pin((__chip_num, 135)) +PE8 = Pin((__chip_num, 136)) +PE9 = Pin((__chip_num, 137)) +PE10 = Pin((__chip_num, 138)) +PE11 = Pin((__chip_num, 139)) +PE12 = Pin((__chip_num, 140)) +PE13 = Pin((__chip_num, 141)) +PE14 = Pin((__chip_num, 142)) +PE15 = Pin((__chip_num, 143)) + +PF0 = Pin((__chip_num, 160)) +PF1 = Pin((__chip_num, 161)) +PF2 = Pin((__chip_num, 162)) +PF3 = Pin((__chip_num, 163)) +PF4 = Pin((__chip_num, 164)) +PF5 = Pin((__chip_num, 165)) +PF6 = Pin((__chip_num, 166)) + +PG0 = Pin((__chip_num, 192)) +PG1 = Pin((__chip_num, 193)) +PG2 = Pin((__chip_num, 194)) +PG3 = Pin((__chip_num, 195)) +PG4 = Pin((__chip_num, 196)) +PG5 = Pin((__chip_num, 197)) +PG6 = Pin((__chip_num, 198)) +PG7 = Pin((__chip_num, 199)) +PG8 = Pin((__chip_num, 200)) +PG9 = Pin((__chip_num, 201)) +PG10 = Pin((__chip_num, 202)) +PG11 = Pin((__chip_num, 203)) +PG12 = Pin((__chip_num, 204)) +PG13 = Pin((__chip_num, 205)) +PG14 = Pin((__chip_num, 206)) + +PH0 = Pin((__chip_num, 224)) +PH1 = Pin((__chip_num, 225)) +PH2 = Pin((__chip_num, 226)) +PH3 = Pin((__chip_num, 227)) +PH4 = Pin((__chip_num, 228)) +PH5 = Pin((__chip_num, 229)) +PH6 = Pin((__chip_num, 230)) +PH7 = Pin((__chip_num, 231)) +PH8 = Pin((__chip_num, 232)) +PH9 = Pin((__chip_num, 233)) +PH10 = Pin((__chip_num, 234)) +PH11 = Pin((__chip_num, 235)) +PH12 = Pin((__chip_num, 236)) +PH13 = Pin((__chip_num, 237)) +PH14 = Pin((__chip_num, 238)) +PH15 = Pin((__chip_num, 239)) +PH16 = Pin((__chip_num, 240)) +PH17 = Pin((__chip_num, 241)) +PH18 = Pin((__chip_num, 242)) +PH19 = Pin((__chip_num, 243)) + +PI0 = Pin((__chip_num, 256)) +PI1 = Pin((__chip_num, 257)) +PI2 = Pin((__chip_num, 258)) +PI3 = Pin((__chip_num, 259)) +PI4 = Pin((__chip_num, 260)) +PI5 = Pin((__chip_num, 261)) +PI6 = Pin((__chip_num, 262)) +PI7 = Pin((__chip_num, 263)) +PI8 = Pin((__chip_num, 264)) +PI9 = Pin((__chip_num, 265)) +PI10 = Pin((__chip_num, 266)) +PI11 = Pin((__chip_num, 267)) +PI12 = Pin((__chip_num, 268)) +PI13 = Pin((__chip_num, 269)) +PI14 = Pin((__chip_num, 270)) +PI15 = Pin((__chip_num, 271)) +PI16 = Pin((__chip_num, 272)) + +PJ0 = Pin((__chip_num, 288)) +PJ1 = Pin((__chip_num, 289)) +PJ2 = Pin((__chip_num, 290)) +PJ3 = Pin((__chip_num, 291)) +PJ4 = Pin((__chip_num, 292)) +PJ5 = Pin((__chip_num, 293)) +PJ6 = Pin((__chip_num, 294)) +PJ7 = Pin((__chip_num, 295)) +PJ8 = Pin((__chip_num, 296)) +PJ9 = Pin((__chip_num, 297)) +PJ10 = Pin((__chip_num, 298)) +PJ11 = Pin((__chip_num, 299)) +PJ12 = Pin((__chip_num, 300)) +PJ13 = Pin((__chip_num, 301)) +PJ14 = Pin((__chip_num, 302)) +PJ15 = Pin((__chip_num, 303)) +PJ16 = Pin((__chip_num, 304)) +PJ17 = Pin((__chip_num, 305)) +PJ18 = Pin((__chip_num, 306)) +PJ19 = Pin((__chip_num, 307)) +PJ20 = Pin((__chip_num, 308)) +PJ21 = Pin((__chip_num, 309)) +PJ22 = Pin((__chip_num, 310)) +PJ23 = Pin((__chip_num, 311)) +PJ24 = Pin((__chip_num, 312)) +PJ25 = Pin((__chip_num, 313)) +PJ26 = Pin((__chip_num, 314)) +PJ27 = Pin((__chip_num, 315)) + +PK0 = Pin((__chip_num, 320)) +PK1 = Pin((__chip_num, 321)) +PK2 = Pin((__chip_num, 322)) +PK3 = Pin((__chip_num, 323)) +PK4 = Pin((__chip_num, 324)) +PK5 = Pin((__chip_num, 325)) +PK6 = Pin((__chip_num, 326)) +PK7 = Pin((__chip_num, 327)) +PK8 = Pin((__chip_num, 328)) +PK9 = Pin((__chip_num, 329)) +PK10 = Pin((__chip_num, 330)) +PK11 = Pin((__chip_num, 331)) +PK12 = Pin((__chip_num, 332)) +PK13 = Pin((__chip_num, 333)) +PK14 = Pin((__chip_num, 334)) +PK15 = Pin((__chip_num, 335)) +PK16 = Pin((__chip_num, 336)) +PK17 = Pin((__chip_num, 337)) +PK18 = Pin((__chip_num, 338)) +PK19 = Pin((__chip_num, 339)) +PK20 = Pin((__chip_num, 340)) +PK21 = Pin((__chip_num, 341)) +PK22 = Pin((__chip_num, 342)) +PK23 = Pin((__chip_num, 343)) + +PL0 = Pin((__chip_r_num, 0)) +PL1 = Pin((__chip_r_num, 1)) +PL2 = Pin((__chip_r_num, 2)) +PL3 = Pin((__chip_r_num, 3)) +PL4 = Pin((__chip_r_num, 4)) +PL5 = Pin((__chip_r_num, 5)) +PL6 = Pin((__chip_r_num, 6)) +PL7 = Pin((__chip_r_num, 7)) +PL8 = Pin((__chip_r_num, 8)) +PL9 = Pin((__chip_r_num, 9)) +PL10 = Pin((__chip_r_num, 10)) +PL11 = Pin((__chip_r_num, 11)) +PL12 = Pin((__chip_r_num, 12)) +PL13 = Pin((__chip_r_num, 13)) + +PM0 = Pin((__chip_r_num, 32)) +PM1 = Pin((__chip_r_num, 33)) +PM2 = Pin((__chip_r_num, 34)) +PM3 = Pin((__chip_r_num, 35)) +PM4 = Pin((__chip_r_num, 36)) +PM5 = Pin((__chip_r_num, 37)) + +# I2C +I2C1_SCL = PB4 +I2C1_SDA = PB5 +I2C4_SCL = PI0 +I2C4_SDA = PI1 +I2C5_SCL = PI8 +I2C5_SDA = PI9 + +i2cPorts = ( + (1, I2C1_SCL, I2C1_SDA), + (4, I2C4_SCL, I2C4_SDA), + (5, I2C5_SCL, I2C5_SDA), +) + +# SPI +SPI1_MOSI = PI4 +SPI1_MISO = PI5 +SPI1_SCLK = PI3 +SPI1_CS0 = PI2 +SPI2_MOSI = PB2 +SPI2_MISO = PB3 +SPI2_SCLK = PB1 +SPI2_CS0 = PB0 + +# ordered as spiId, sckId, mosiId, misoId +spiPorts = ( + (1, SPI1_SCLK, SPI1_MOSI, SPI1_MISO), + (2, SPI2_SCLK, SPI2_MOSI, SPI2_MISO), +) + +# UART +UART2_TX = PB0 +UART2_RX = PB1 +UART3_TX = PI11 +UART3_RX = PI12 +UART4_TX = PI0 +UART4_RX = PI1 +UART5_TX = PI2 +UART5_RX = PI3 +UART6_TX = PI6 +UART6_RX = PI7 +UART7_TX = PB13 +UART7_RX = PB14 + +# ordered as uartId, txId, rxId +uartPorts = ( + (2, UART2_TX, UART2_RX), + (3, UART3_TX, UART3_RX), + (4, UART4_TX, UART4_RX), + (5, UART5_TX, UART5_RX), + (6, UART6_TX, UART6_RX), + (7, UART7_TX, UART7_RX), +) + +# SysFS pwm outputs, pwm channel and pin in first tuple +pwmOuts = [ + ((0, 1), PI0), + ((0, 2), PI1), + ((0, 3), PI2), + ((0, 4), PI3), + ((0, 5), PI4), + ((0, 6), PI5), + ((0, 7), PI6), + ((0, 8), PI7), + ((0, 9), PI8), + ((0, 10), PI9), + ((0, 11), PI10), + ((0, 12), PI11), + ((0, 13), PI12), +] diff --git a/src/adafruit_blinka/microcontroller/bcm2711/pin.py b/src/adafruit_blinka/microcontroller/bcm2711/pin.py index ffc508b..69e0a53 100644 --- a/src/adafruit_blinka/microcontroller/bcm2711/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm2711/pin.py @@ -2,11 +2,9 @@ # # SPDX-License-Identifier: MIT """Broadcom BCM2711 pin names""" -from RPi import GPIO -from adafruit_blinka.microcontroller.bcm283x.pin import Pin -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! +# Use RPi.GPIO pins for Raspberry Pi 4 +from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pin import Pin D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/__init__.py b/src/adafruit_blinka/microcontroller/bcm2712/__init__.py similarity index 100% rename from src/adafruit_blinka/microcontroller/bcm283x/pwmio/__init__.py rename to src/adafruit_blinka/microcontroller/bcm2712/__init__.py diff --git a/src/adafruit_blinka/microcontroller/bcm2712/pin.py b/src/adafruit_blinka/microcontroller/bcm2712/pin.py new file mode 100644 index 0000000..736114f --- /dev/null +++ b/src/adafruit_blinka/microcontroller/bcm2712/pin.py @@ -0,0 +1,100 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""Broadcom BCM2712 pin names""" + +# Use lgpio pins for Raspberry Pi 5 +from adafruit_blinka.microcontroller.generic_linux.lgpio_pin import Pin + +D0 = Pin(0) +D1 = Pin(1) + +D2 = Pin(2) +SDA = Pin(2) +D3 = Pin(3) +SCL = Pin(3) + +D4 = Pin(4) +D5 = Pin(5) +D6 = Pin(6) + +D7 = Pin(7) +CE1 = Pin(7) +D8 = Pin(8) +CE0 = Pin(8) +D9 = Pin(9) +MISO = Pin(9) +D10 = Pin(10) +MOSI = Pin(10) +D11 = Pin(11) +SCLK = Pin(11) # Raspberry Pi naming +SCK = Pin(11) # CircuitPython naming + +D12 = Pin(12) +D13 = Pin(13) + +D14 = Pin(14) +TXD = Pin(14) +D15 = Pin(15) +RXD = Pin(15) + +D16 = Pin(16) +D17 = Pin(17) +D18 = Pin(18) +D19 = Pin(19) +MISO_1 = Pin(19) +D20 = Pin(20) +MOSI_1 = Pin(20) +D21 = Pin(21) +SCLK_1 = Pin(21) +SCK_1 = Pin(21) +D22 = Pin(22) +D23 = Pin(23) +D24 = Pin(24) +D25 = Pin(25) +D26 = Pin(26) +D27 = Pin(27) +D28 = Pin(28) +D29 = Pin(29) +D30 = Pin(30) +D31 = Pin(31) +D32 = Pin(32) +D33 = Pin(33) +D34 = Pin(34) +D35 = Pin(35) +D36 = Pin(36) +D37 = Pin(37) +D38 = Pin(38) +D39 = Pin(39) +D40 = Pin(40) +MISO_2 = Pin(40) +D41 = Pin(41) +MOSI_2 = Pin(41) +D42 = Pin(42) +SCLK_2 = Pin(42) +SCK_2 = Pin(43) +D43 = Pin(43) +D44 = Pin(44) +D45 = Pin(45) + +# ordered as spiId, sckId, mosiId, misoId +spiPorts = ( + (0, SCLK, MOSI, MISO), + (1, SCLK_1, MOSI_1, MISO_1), + (2, SCLK_2, MOSI_2, MISO_2), + (3, D3, D2, D1), + (4, D7, D6, D5), + (5, D15, D14, D13), +) + +# ordered as uartId, txId, rxId +uartPorts = ((1, TXD, RXD),) + +# These are the known hardware I2C ports / pins. +# For software I2C ports created with the i2c-gpio overlay, see: +# https://github.com/adafruit/Adafruit_Python_Extended_Bus +i2cPorts = ( + (1, SCL, SDA), + (0, D1, D0), # both pi 1 and pi 2 i2c ports! + (10, D45, D44), # internal i2c bus for the CM4 +) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pin.py b/src/adafruit_blinka/microcontroller/bcm283x/pin.py index a24ed22..d741ada 100644 --- a/src/adafruit_blinka/microcontroller/bcm283x/pin.py +++ b/src/adafruit_blinka/microcontroller/bcm283x/pin.py @@ -2,73 +2,10 @@ # # SPDX-License-Identifier: MIT """Broadcom BCM283x pin names""" -from RPi import GPIO -GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 -GPIO.setwarnings(False) # shh! +# Use RPi.GPIO pins for Raspberry Pi 1-3B+ +from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pin import Pin - -class Pin: - """Pins dont exist in CPython so...lets make our own!""" - - IN = 0 - OUT = 1 - LOW = 0 - HIGH = 1 - PULL_NONE = 0 - PULL_UP = 1 - PULL_DOWN = 2 - - id = None - _value = LOW - _mode = IN - - def __init__(self, bcm_number): - self.id = bcm_number - - def __repr__(self): - return str(self.id) - - def __eq__(self, other): - return self.id == other - - def init(self, mode=IN, pull=None): - """Initialize the Pin""" - if mode is not None: - if mode == self.IN: - self._mode = self.IN - GPIO.setup(self.id, GPIO.IN) - elif mode == self.OUT: - self._mode = self.OUT - GPIO.setup(self.id, GPIO.OUT) - else: - raise RuntimeError("Invalid mode for pin: %s" % self.id) - if pull is not None: - if self._mode != self.IN: - raise RuntimeError("Cannot set pull resistor on output") - if pull == self.PULL_UP: - GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_UP) - elif pull == self.PULL_DOWN: - GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) - else: - raise RuntimeError("Invalid pull for pin: %s" % self.id) - - def value(self, val=None): - """Set or return the Pin Value""" - if val is not None: - if val == self.LOW: - self._value = val - GPIO.output(self.id, val) - elif val == self.HIGH: - self._value = val - GPIO.output(self.id, val) - else: - raise RuntimeError("Invalid value for pin") - return None - return GPIO.input(self.id) - - -# Pi 1B rev1 only? D0 = Pin(0) D1 = Pin(1) diff --git a/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py new file mode 100644 index 0000000..25a8268 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pin.py @@ -0,0 +1,129 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""A Pin class for use with lgpio.""" + +from pathlib import Path +import lgpio + + +def _get_gpiochip(): + """ + Determines the handle of the GPIO chip device to access. + + iterate through sysfs to find a GPIO chip device with a driver known to be + used for userspace GPIO access. + """ + for dev in Path("/sys/bus/gpio/devices").glob("gpiochip*"): + drivers = set((dev / "of_node/compatible").read_text().split("\0")) + # check if driver names are intended for userspace control + if drivers & { + "raspberrypi,rp1-gpio", + "raspberrypi,bcm2835-gpio", + "raspberrypi,bcm2711-gpio", + }: + return lgpio.gpiochip_open(int(dev.name[-1])) + # return chip0 as a fallback + return lgpio.gpiochip_open(0) + + +CHIP = _get_gpiochip() + + +class Pin: + """Pins dont exist in CPython so...lets make our own!""" + + LOW = 0 + HIGH = 1 + OFF = LOW + ON = HIGH + + # values of lg mode constants + PULL_NONE = 0x80 + PULL_UP = 0x20 + PULL_DOWN = 0x40 + ACTIVE_LOW = 0x02 + + # drive mode lg constants + OPEN_DRAIN = 0x04 + IN = 0x0100 + OUT = 0x0200 + + # LG mode constants + _LG_ALERT = 0x400 + _LG_GROUP = 0x800 + _LG_MODES = IN | OUT | _LG_ALERT | _LG_GROUP + _LG_PULLS = PULL_NONE | PULL_UP | PULL_NONE | ACTIVE_LOW + _LG_DRIVES = OPEN_DRAIN + + id = None + _value = LOW + _mode = IN + + # we want exceptions + lgpio.exceptions = True + + def __init__(self, bcm_number): + self.id = bcm_number + + def __repr__(self): + return str(self.id) + + def __eq__(self, other): + return self.id == other + + def init(self, mode=IN, pull=None): + """Initialize the Pin""" + if mode is not None: + if mode == Pin.IN: + self._mode = Pin.IN + self._set_gpio_mode_in() + elif mode == self.OUT: + self._mode = Pin.OUT + Pin._check_result(lgpio.gpio_claim_output(CHIP, self.id, Pin.LOW)) + else: + raise RuntimeError(f"Invalid mode for pin: {self.id}") + if pull is not None: + if self._mode != Pin.IN: + raise RuntimeError("Can only set pull resistor on input") + if pull in {Pin.PULL_UP, Pin.PULL_DOWN, Pin.PULL_NONE}: + self._set_gpio_mode_in(lflags=pull) + else: + raise RuntimeError(f"Invalid pull for pin: {self.id}") + + def value(self, val=None): + """Set or return the Pin Value""" + if val is not None: + if val == Pin.LOW: + self._value = val + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) + elif val == Pin.HIGH: + self._value = val + Pin._check_result(lgpio.gpio_write(CHIP, self.id, val)) + else: + raise RuntimeError("Invalid value for pin") + return None + return Pin._check_result(lgpio.gpio_read(CHIP, self.id)) + + @staticmethod + def _check_result(result): + """ + convert any result other than zero to a text message and pass it back + as a runtime exception. Typical usage: use the lgpio call as the + argument. + """ + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + return result + + def _set_gpio_mode_in(self, lflags=0): + """ + claim a gpio as input, or modify the flags (PULL_UP, PULL_DOWN, ... ) + """ + # This gpio_free may seem redundant, but is required when + # changing the line-flags of an already acquired input line + try: + lgpio.gpio_free(CHIP, self.id) + except lgpio.error: + pass + Pin._check_result(lgpio.gpio_claim_input(CHIP, self.id, lFlags=lflags)) diff --git a/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py new file mode 100644 index 0000000..e4cf5a7 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/lgpio_pwmout.py @@ -0,0 +1,158 @@ +# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT + +""" PWMOut Class for lgpio lg library tx_pwm library """ + +import lgpio +from adafruit_blinka.microcontroller.generic_linux.lgpio_pin import CHIP + + +class PWMError(IOError): + """Base class for PWM errors.""" + + +class PWMOut: + """Pulse Width Modulation Output Class""" + + def __init__(self, pin, *, frequency=500, duty_cycle=0, variable_frequency=False): + if variable_frequency: + print("Variable Frequency is not supported, ignoring...") + self._pin = pin + result = lgpio.gpio_claim_output(CHIP, self._pin.id, lFlags=lgpio.SET_PULL_NONE) + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + self._enabled = False + self._deinited = False + self._period = 0 + # set frequency + self._frequency = frequency + # set duty + self.duty_cycle = duty_cycle + self.enabled = True + + def __del__(self): + self.deinit() + + def __enter__(self): + return self + + def __exit__(self, _exc_type, _exc_val, _exc_tb): + self.deinit() + + def deinit(self): + """Deinit the PWM.""" + if not self._deinited: + if self.enabled: + self._enabled = False # turn off the pwm + self._deinited = True + + def _is_deinited(self): + """raise Value error if the object has been de-inited""" + if self._deinited: + raise ValueError( + "Object has been deinitialize and can no longer " + "be used. Create a new object." + ) + + @property + def period(self): + """Get or set the PWM's output period in seconds. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + return 1.0 / self.frequency + + @period.setter + def period(self, period): + if not isinstance(period, (int, float)): + raise TypeError("Invalid period type, should be int or float.") + + self.frequency = 1.0 / period + + @property + def duty_cycle(self): + """Get or set the PWM's output duty cycle which is the fraction of + each pulse which is high. 16-bit + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + ValueError: if value is out of bounds of 0.0 to 1.0. + + :type: int, float + """ + return int(self._duty_cycle * 65535) + + @duty_cycle.setter + def duty_cycle(self, duty_cycle): + if not isinstance(duty_cycle, (int, float)): + raise TypeError("Invalid duty cycle type, should be int or float.") + + if not 0 <= duty_cycle <= 65535: + raise ValueError("Invalid duty cycle value, should be between 0 and 65535") + + # convert from 16-bit + duty_cycle /= 65535.0 + + self._duty_cycle = duty_cycle + if self._enabled: + self.enabled = True # turn on with new values + + @property + def frequency(self): + """Get or set the PWM's output frequency in Hertz. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + + return self._frequency + + @frequency.setter + def frequency(self, frequency): + if not isinstance(frequency, (int, float)): + raise TypeError("Invalid frequency type, should be int or float.") + + self._frequency = frequency + if self.enabled: + self.enabled = True # turn on with new values + + @property + def enabled(self): + """Get or set the PWM's output enabled state. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not bool. + + :type: bool + """ + return self._enabled + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError("Invalid enabled type, should be bool.") + + frequency = self._frequency if value else 0 + duty_cycle = round(self._duty_cycle * 100) + self._enabled = value + result = lgpio.tx_pwm(CHIP, self._pin.id, frequency, duty_cycle) + if result < 0: + raise RuntimeError(lgpio.error_text(result)) + return result + + # String representation + def __str__(self): + return ( + f"pin {self._pin} (freq={self.frequency:f} Hz, duty_cycle=" + f"{self.duty_cycle}({round(self.duty_cycle / 655.35)}%)" + ) diff --git a/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py new file mode 100644 index 0000000..cf3acbd --- /dev/null +++ b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pin.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: 2025 Melissa LeBlanc-Williams for Adafruit Industries +# +# SPDX-License-Identifier: MIT +"""A Pin class for use with Rpi.GPIO.""" + +from RPi import GPIO + +GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 +GPIO.setwarnings(False) # shh! + + +class Pin: + """Pins dont exist in CPython so...lets make our own!""" + + IN = 0 + OUT = 1 + LOW = 0 + HIGH = 1 + PULL_NONE = 0 + PULL_UP = 1 + PULL_DOWN = 2 + + id = None + _value = LOW + _mode = IN + + def __init__(self, bcm_number): + self.id = bcm_number + + def __repr__(self): + return str(self.id) + + def __eq__(self, other): + return self.id == other + + def init(self, mode=IN, pull=None): + """Initialize the Pin""" + if mode is not None: + if mode == self.IN: + self._mode = self.IN + GPIO.setup(self.id, GPIO.IN) + elif mode == self.OUT: + self._mode = self.OUT + GPIO.setup(self.id, GPIO.OUT) + else: + raise RuntimeError("Invalid mode for pin: %s" % self.id) + if pull is not None: + if self._mode != self.IN: + raise RuntimeError("Cannot set pull resistor on output") + if pull == self.PULL_UP: + GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_UP) + elif pull == self.PULL_DOWN: + GPIO.setup(self.id, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) + else: + raise RuntimeError("Invalid pull for pin: %s" % self.id) + + def value(self, val=None): + """Set or return the Pin Value""" + if val is not None: + if val == self.LOW: + self._value = val + GPIO.output(self.id, val) + elif val == self.HIGH: + self._value = val + GPIO.output(self.id, val) + else: + raise RuntimeError("Invalid value for pin") + return None + return GPIO.input(self.id) diff --git a/src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py b/src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pwmout.py similarity index 100% rename from src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py rename to src/adafruit_blinka/microcontroller/generic_linux/rpi_gpio_pwmout.py diff --git a/src/adafruit_blinka/microcontroller/horizon/pwmio/PWMOut.py b/src/adafruit_blinka/microcontroller/horizon/pwmio/PWMOut.py new file mode 100644 index 0000000..b940b77 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/horizon/pwmio/PWMOut.py @@ -0,0 +1,174 @@ +# SPDX-FileCopyrightText: 2024 Hajime Fujimoto +# +# SPDX-License-Identifier: MIT +"""Custom PWMOut Wrapper for Hobot.GPIO PWM Class""" +from Hobot import GPIO + +GPIO.setmode(GPIO.BCM) # Use BCM pins D4 = GPIO #4 +GPIO.setwarnings(False) # shh! +GPIO.cleanup() + + +# pylint: disable=unnecessary-pass +class PWMError(IOError): + """Base class for PWM errors.""" + + pass + + +# pylint: enable=unnecessary-pass + + +class PWMOut: + """Pulse Width Modulation Output Class""" + + def __init__(self, pin, *, frequency=48000, duty_cycle=0, variable_frequency=False): + self._pwmpin = None + self._period = 0 + self._open(pin, duty_cycle, frequency, variable_frequency) + + def __del__(self): + self.deinit() + + def __enter__(self): + return self + + def __exit__(self, t, value, traceback): + self.deinit() + + def _open(self, pin, duty=0, freq=500, variable_frequency=False): + if pin == (0, 25): + gpio_pin = 12 + elif pin == (0, 4): + gpio_pin = 13 + else: + raise ValueError("PWM is only available on D12 or D13.") + self._pin = gpio_pin + GPIO.setmode(GPIO.BCM) + # GPIO.setup(self._pin, GPIO.OUT) + self._pwmpin = GPIO.PWM(self._pin, freq) + + if variable_frequency: + print("Variable Frequency is not supported, continuing without it...") + + # set frequency + self.frequency = freq + # set duty + duty = 656 if duty <= 656 else duty + self.duty_cycle = duty + + self.enabled = True + + def deinit(self): + """Deinit the PWM.""" + if self._pwmpin is not None: + self._pwmpin.stop() + GPIO.cleanup(self._pin) + self._pwmpin = None + + def _is_deinited(self): + if self._pwmpin is None: + raise ValueError( + "Object has been deinitialize and can no longer " + "be used. Create a new object." + ) + + @property + def period(self): + """Get or set the PWM's output period in seconds. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + return 1.0 / self.frequency + + @period.setter + def period(self, period): + if not isinstance(period, (int, float)): + raise TypeError("Invalid period type, should be int or float.") + + self.frequency = 1.0 / period + + @property + def duty_cycle(self): + """Get or set the PWM's output duty cycle which is the fraction of + each pulse which is high. 16-bit + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + ValueError: if value is out of bounds of 0.0 to 1.0. + + :type: int, float + """ + return int(self._duty_cycle * 65535) + + @duty_cycle.setter + def duty_cycle(self, duty_cycle): + if not isinstance(duty_cycle, (int, float)): + raise TypeError("Invalid duty cycle type, should be int or float.") + + if not 0 <= duty_cycle <= 65535: + raise ValueError("Invalid duty cycle value, should be between 0 and 65535") + + # convert from 16-bit + duty_cycle /= 65535.0 + + self._duty_cycle = duty_cycle + self._pwmpin.ChangeDutyCycle(round(self._duty_cycle * 100)) + + @property + def frequency(self): + """Get or set the PWM's output frequency in Hertz. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not int or float. + + :type: int, float + """ + + return self._frequency + + @frequency.setter + def frequency(self, frequency): + if not isinstance(frequency, (int, float)): + raise TypeError("Invalid frequency type, should be int or float.") + + self._pwmpin.ChangeFrequency(round(frequency)) + self._frequency = frequency + + @property + def enabled(self): + """Get or set the PWM's output enabled state. + + Raises: + PWMError: if an I/O or OS error occurs. + TypeError: if value type is not bool. + + :type: bool + """ + return self._enabled + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError("Invalid enabled type, should be string.") + + if value: + self._pwmpin.start(round(self._duty_cycle * 100)) + else: + self._pwmpin.stop() + + self._enabled = value + + # String representation + def __str__(self): + return "pin %s (freq=%f Hz, duty_cycle=%f%%)" % ( + self._pin, + self.frequency, + self.duty_cycle, + ) diff --git a/src/adafruit_blinka/microcontroller/horizon/sunrise_x3/pin.py b/src/adafruit_blinka/microcontroller/horizon/sunrise_x3/pin.py new file mode 100644 index 0000000..0161633 --- /dev/null +++ b/src/adafruit_blinka/microcontroller/horizon/sunrise_x3/pin.py @@ -0,0 +1,55 @@ +# SPDX-FileCopyrightText: 2024 Hajime Fujimoto +# +# SPDX-License-Identifier: MIT +"""A Pin class for use with Horizon Sunrise X3.""" + +from adafruit_blinka.microcontroller.generic_linux.libgpiod_pin import Pin + +D0 = Pin((0, 15)) +D1 = Pin((0, 14)) +D2 = Pin((0, 9)) +D3 = Pin((0, 8)) +D4 = Pin((0, 101)) +D5 = Pin((0, 119)) +D6 = Pin((0, 118)) +D7 = Pin((0, 28)) +D8 = Pin((0, 5)) +D9 = Pin((0, 7)) +D10 = Pin((0, 6)) +D11 = Pin((0, 3)) +D12 = Pin((0, 25)) +D13 = Pin((0, 4)) +D14 = Pin((0, 111)) +D15 = Pin((0, 112)) +D16 = Pin((0, 20)) +D17 = Pin((0, 12)) +D18 = Pin((0, 102)) +D19 = Pin((0, 103)) +D20 = Pin((0, 104)) +D21 = Pin((0, 108)) +D22 = Pin((0, 30)) +D23 = Pin((0, 27)) +D24 = Pin((0, 22)) +D25 = Pin((0, 29)) +D26 = Pin((0, 117)) +D27 = Pin((0, 13)) + +SDA = D2 +SCL = D3 +MISO = D9 +MOSI = D10 +SCLK = D11 +SCK = D11 +TXD = D14 +RXD = D15 + +spiPorts = ((1, SCLK, MOSI, MISO),) + +uartPorts = ((0, TXD, RXD),) + +i2cPorts = ((0, SCL, SDA),) + +pwmOuts = ( + ((0, 0), D12), + ((3, 0), D13), +) diff --git a/src/adafruit_blinka/microcontroller/rockchip/rk3566/pin.py b/src/adafruit_blinka/microcontroller/rockchip/rk3566/pin.py index bfb3013..02cdb99 100644 --- a/src/adafruit_blinka/microcontroller/rockchip/rk3566/pin.py +++ b/src/adafruit_blinka/microcontroller/rockchip/rk3566/pin.py @@ -242,6 +242,16 @@ if board in ("ODROID_M1S"): globals()[alias + "_RX"] = GPIO2_A3 uartPorts.append((int(alias[-1]), GPIO2_A4, GPIO2_A3)) +if board in ("RADXA_ZERO3"): + alias = get_pwm_chipid("fe6f0000.pwm") + if alias is not None: + globals()["PWM" + alias] = GPIO3_B1 + pwmOuts.append(((int(alias[-1]), 0), GPIO3_B1)) + alias = get_pwm_chipid("fe6f0010.pwm") + if alias is not None: + globals()["PWM" + alias] = GPIO3_B2 + pwmOuts.append(((int(alias[-1]), 0), GPIO3_B2)) + analogIns = tuple(analogIns) i2cPorts = tuple(i2cPorts) pwmOuts = tuple(pwmOuts) diff --git a/src/adafruit_blinka/microcontroller/rockchip/rk3588/pin.py b/src/adafruit_blinka/microcontroller/rockchip/rk3588/pin.py index 3abb3b8..7f22cb5 100644 --- a/src/adafruit_blinka/microcontroller/rockchip/rk3588/pin.py +++ b/src/adafruit_blinka/microcontroller/rockchip/rk3588/pin.py @@ -175,79 +175,246 @@ GPIO4_D7 = Pin((4, 31)) # UART +UART0_TX_M0 = GPIO0_C5 +UART0_RX_M0 = GPIO0_C4 +UART0_TX_M1 = GPIO0_B1 +UART0_RX_M1 = GPIO0_B0 UART0_TX_M2 = GPIO4_A3 UART0_RX_M2 = GPIO4_A4 +UART1_TX_M0 = GPIO2_B7 +UART1_RX_M0 = GPIO2_B6 UART1_TX_M1 = GPIO1_B6 UART1_RX_M1 = GPIO1_B7 +UART1_TX_M2 = GPIO0_D1 +UART1_RX_M2 = GPIO0_D2 UART2_TX_M0 = GPIO0_B5 UART2_RX_M0 = GPIO0_B6 +UART2_TX_M1 = GPIO0_D0 +UART2_RX_M1 = GPIO0_D1 UART2_TX_M2 = GPIO3_B1 UART2_RX_M2 = GPIO3_B2 UART3_TX_M0 = GPIO1_C1 UART3_RX_M0 = GPIO1_C0 UART3_TX_M1 = GPIO3_B5 UART3_RX_M1 = GPIO3_B6 +UART3_TX_M2 = GPIO4_A5 +UART3_RX_M2 = GPIO4_A6 +UART4_TX_M0 = GPIO1_D2 +UART4_RX_M0 = GPIO1_D3 +UART4_TX_M1 = GPIO3_D1 +UART4_RX_M1 = GPIO3_D0 UART4_TX_M2 = GPIO1_B3 UART4_RX_M2 = GPIO1_B2 +UART5_TX_M0 = GPIO4_D5 +UART5_RX_M0 = GPIO4_D4 +UART5_TX_M1 = GPIO3_C4 +UART5_RX_M1 = GPIO3_C5 +UART5_TX_M2 = GPIO2_D5 +UART5_RX_M2 = GPIO2_D4 +UART6_TX_M0 = GPIO2_A7 +UART6_RX_M0 = GPIO2_A6 +UART6_TX_M1 = GPIO1_A1 +UART6_RX_M1 = GPIO1_A0 +UART6_TX_M2 = GPIO1_D0 +UART6_RX_M2 = GPIO1_D1 +UART7_TX_M0 = GPIO2_B5 +UART7_RX_M0 = GPIO2_B4 UART7_TX_M1 = GPIO3_C0 UART7_RX_M1 = GPIO3_C1 UART7_TX_M2 = GPIO1_B5 UART7_RX_M2 = GPIO1_B4 +UART8_TX_M0 = GPIO4_B0 +UART8_RX_M0 = GPIO4_B1 +UART8_TX_M1 = GPIO3_A2 +UART8_RX_M1 = GPIO3_A3 +UART9_TX_M0 = GPIO2_C2 +UART9_RX_M0 = GPIO2_C4 +UART9_TX_M1 = GPIO4_B4 +UART9_RX_M1 = GPIO4_B5 +UART9_TX_M2 = GPIO3_D5 +UART9_RX_M2 = GPIO3_D4 # ordered as uartId, txId, rxId uartPorts = ( + (0, UART0_TX_M0, UART0_RX_M0), + (0, UART0_TX_M1, UART0_RX_M1), (0, UART0_TX_M2, UART0_RX_M2), + (1, UART1_TX_M0, UART1_RX_M0), (1, UART1_TX_M1, UART1_RX_M1), + (1, UART1_TX_M2, UART1_RX_M2), (2, UART2_TX_M0, UART2_RX_M0), + (2, UART2_TX_M1, UART2_RX_M1), (2, UART2_TX_M2, UART2_RX_M2), (3, UART3_TX_M0, UART3_RX_M0), (3, UART3_TX_M1, UART3_RX_M1), + (3, UART3_TX_M2, UART3_RX_M2), + (4, UART4_TX_M0, UART4_RX_M0), + (4, UART4_TX_M1, UART4_RX_M1), (4, UART4_TX_M2, UART4_RX_M2), + (5, UART5_TX_M0, UART5_RX_M0), + (5, UART5_TX_M1, UART5_RX_M1), + (5, UART5_TX_M2, UART5_RX_M2), + (6, UART6_TX_M0, UART6_RX_M0), + (6, UART6_TX_M1, UART6_RX_M1), + (6, UART6_TX_M2, UART6_RX_M2), + (7, UART7_TX_M0, UART7_RX_M0), (7, UART7_TX_M1, UART7_RX_M1), (7, UART7_TX_M2, UART7_RX_M2), + (8, UART8_TX_M0, UART8_RX_M0), + (8, UART8_TX_M1, UART8_RX_M1), + (9, UART9_TX_M0, UART9_RX_M0), + (9, UART9_TX_M1, UART9_RX_M1), + (9, UART9_TX_M2, UART9_RX_M2), ) # I2C +I2C0_SCL_M0 = GPIO0_B3 +I2C0_SDA_M0 = GPIO0_A6 I2C0_SCL_M1 = GPIO4_C5 I2C0_SDA_M1 = GPIO4_C6 +I2C0_SCL_M2 = GPIO0_D1 +I2C0_SDA_M2 = GPIO0_D2 I2C1_SCL_M0 = GPIO0_B5 I2C1_SDA_M0 = GPIO0_B6 +I2C1_SCL_M1 = GPIO0_B0 +I2C1_SDA_M1 = GPIO0_B1 +I2C1_SCL_M2 = GPIO0_D4 +I2C1_SDA_M2 = GPIO0_D5 +I2C1_SCL_M3 = GPIO2_D4 +I2C1_SDA_M3 = GPIO2_D5 I2C1_SCL_M4 = GPIO1_B1 I2C1_SDA_M4 = GPIO1_B2 +I2C2_SCL_M0 = GPIO0_B7 +I2C2_SDA_M0 = GPIO0_C0 +I2C2_SCL_M1 = GPIO2_C1 +I2C2_SDA_M1 = GPIO2_C0 +I2C2_SCL_M2 = GPIO2_A3 +I2C2_SDA_M2 = GPIO2_A2 +I2C2_SCL_M3 = GPIO1_C5 +I2C2_SDA_M3 = GPIO1_C4 +I2C2_SCL_M4 = GPIO1_A1 +I2C2_SDA_M4 = GPIO1_A0 I2C3_SCL_M0 = GPIO1_C1 I2C3_SDA_M0 = GPIO1_C0 I2C3_SCL_M1 = GPIO3_B7 I2C3_SDA_M1 = GPIO3_C0 +I2C3_SCL_M2 = GPIO4_A4 +I2C3_SDA_M2 = GPIO4_A5 +I2C3_SCL_M3 = GPIO2_B2 +I2C3_SDA_M3 = GPIO2_B3 +I2C3_SCL_M4 = GPIO4_D0 +I2C3_SDA_M4 = GPIO4_D1 +I2C4_SCL_M0 = GPIO3_A6 +I2C4_SDA_M0 = GPIO3_A5 +I2C4_SCL_M1 = GPIO2_B5 +I2C4_SDA_M1 = GPIO2_B4 +I2C4_SCL_M2 = GPIO0_C5 +I2C4_SDA_M2 = GPIO0_C4 I2C4_SCL_M3 = GPIO1_A3 I2C4_SDA_M3 = GPIO1_A2 +I2C4_SCL_M4 = GPIO1_C7 +I2C4_SDA_M4 = GPIO1_C6 +I2C5_SCL_M0 = GPIO3_C7 +I2C5_SDA_M0 = GPIO3_D0 +I2C5_SCL_M1 = GPIO4_B6 +I2C5_SDA_M1 = GPIO4_B7 +I2C5_SCL_M2 = GPIO4_A6 +I2C5_SDA_M2 = GPIO4_A7 +I2C5_SCL_M3 = GPIO1_B6 +I2C5_SDA_M3 = GPIO1_B7 +I2C5_SCL_M4 = GPIO2_B6 +I2C5_SDA_M4 = GPIO2_B7 +I2C6_SCL_M0 = GPIO0_D0 +I2C6_SDA_M0 = GPIO0_C7 +I2C6_SCL_M1 = GPIO1_C3 +I2C6_SDA_M1 = GPIO1_C2 +I2C6_SCL_M2 = GPIO2_C3 +I2C6_SDA_M2 = GPIO2_C2 I2C6_SCL_M3 = GPIO4_B1 I2C6_SDA_M3 = GPIO4_B0 +I2C6_SCL_M4 = GPIO3_A1 +I2C6_SDA_M4 = GPIO3_A0 +I2C7_SCL_M0 = GPIO1_D0 +I2C7_SDA_M0 = GPIO1_D1 +I2C7_SCL_M1 = GPIO4_C3 +I2C7_SDA_M1 = GPIO4_C4 +I2C7_SCL_M2 = GPIO3_D2 +I2C7_SDA_M2 = GPIO3_D3 I2C7_SCL_M3 = GPIO4_B2 I2C7_SDA_M3 = GPIO4_B3 +I2C8_SCL_M0 = GPIO4_D2 +I2C8_SDA_M0 = GPIO4_D3 +I2C8_SCL_M1 = GPIO2_B0 +I2C8_SDA_M1 = GPIO2_B1 I2C8_SCL_M2 = GPIO1_D6 I2C8_SDA_M2 = GPIO1_D7 +I2C8_SCL_M3 = GPIO4_C0 +I2C8_SDA_M3 = GPIO4_C1 I2C8_SCL_M4 = GPIO3_C2 I2C8_SDA_M4 = GPIO3_C3 -I2C5_SDA_M3 = GPIO1_B7 -I2C5_SCL_M3 = GPIO1_B6 # ordered as i2cId, sclId, sdaId i2cPorts = ( + (0, I2C0_SCL_M0, I2C0_SDA_M0), (0, I2C0_SCL_M1, I2C0_SDA_M1), + (0, I2C0_SCL_M2, I2C0_SDA_M2), (1, I2C1_SCL_M0, I2C1_SDA_M0), + (1, I2C1_SCL_M1, I2C1_SDA_M1), + (1, I2C1_SCL_M2, I2C1_SDA_M2), + (1, I2C1_SCL_M3, I2C1_SDA_M3), (1, I2C1_SCL_M4, I2C1_SDA_M4), + (2, I2C2_SCL_M0, I2C2_SDA_M0), + (2, I2C2_SCL_M1, I2C2_SDA_M1), + (2, I2C2_SCL_M2, I2C2_SDA_M2), + (2, I2C2_SCL_M3, I2C2_SDA_M3), + (2, I2C2_SCL_M4, I2C2_SDA_M4), (3, I2C3_SCL_M0, I2C3_SDA_M0), (3, I2C3_SCL_M1, I2C3_SDA_M1), + (3, I2C3_SCL_M2, I2C3_SDA_M2), + (3, I2C3_SCL_M3, I2C3_SDA_M3), + (3, I2C3_SCL_M4, I2C3_SDA_M4), + (4, I2C4_SCL_M0, I2C4_SDA_M0), + (4, I2C4_SCL_M1, I2C4_SDA_M1), + (4, I2C4_SCL_M2, I2C4_SDA_M2), (4, I2C4_SCL_M3, I2C4_SDA_M3), + (4, I2C4_SCL_M4, I2C4_SDA_M4), + (5, I2C5_SCL_M0, I2C5_SDA_M0), + (5, I2C5_SCL_M1, I2C5_SDA_M1), + (5, I2C5_SCL_M2, I2C5_SDA_M2), (5, I2C5_SCL_M3, I2C5_SDA_M3), + (5, I2C5_SCL_M4, I2C5_SDA_M4), + (6, I2C6_SCL_M0, I2C6_SDA_M0), + (6, I2C6_SCL_M1, I2C6_SDA_M1), + (6, I2C6_SCL_M2, I2C6_SDA_M2), (6, I2C6_SCL_M3, I2C6_SDA_M3), + (6, I2C6_SCL_M4, I2C6_SDA_M4), + (7, I2C7_SCL_M0, I2C7_SDA_M0), + (7, I2C7_SCL_M1, I2C7_SDA_M1), + (7, I2C7_SCL_M2, I2C7_SDA_M2), (7, I2C7_SCL_M3, I2C7_SDA_M3), + (8, I2C8_SCL_M0, I2C8_SDA_M0), + (8, I2C8_SCL_M1, I2C8_SDA_M1), (8, I2C8_SCL_M2, I2C8_SDA_M2), + (8, I2C8_SCL_M3, I2C8_SDA_M3), (8, I2C8_SCL_M4, I2C8_SDA_M4), ) # SPI +SPI0_MOSI_M0 = GPIO0_C0 +SPI0_MISO_M0 = GPIO0_C7 +SPI0_CLK_M0 = GPIO0_C6 +SPI0_SCLK_M0 = SPI0_CLK_M0 +SPI0_CS0_M0 = GPIO0_D1 +SPI0_CS1_M0 = GPIO0_B7 + +SPI0_MOSI_M1 = GPIO4_A1 +SPI0_MISO_M1 = GPIO4_A0 +SPI0_CLK_M1 = GPIO4_A2 +SPI0_SCLK_M1 = SPI0_CLK_M1 +SPI0_CS0_M1 = GPIO4_B2 +SPI0_CS1_M1 = GPIO4_B1 + SPI0_MOSI_M2 = GPIO1_B2 SPI0_MISO_M2 = GPIO1_B1 SPI0_CLK_M2 = GPIO1_B3 @@ -255,10 +422,19 @@ SPI0_SCLK_M2 = SPI0_CLK_M2 SPI0_CS0_M2 = GPIO1_B4 SPI0_CS1_M2 = GPIO1_B5 -SPI0_MOSI_M1 = GPIO4_A1 -SPI0_MISO_M1 = GPIO4_A0 -SPI0_SCLK_M1 = GPIO4_A2 -SPI0_CS0_M1 = GPIO4_B2 +SPI0_MOSI_M3 = GPIO3_D2 +SPI0_MISO_M3 = GPIO3_D1 +SPI0_CLK_M3 = GPIO3_D3 +SPI0_SCLK_M3 = SPI0_CLK_M3 +SPI0_CS0_M3 = GPIO3_D4 +SPI0_CS1_M3 = GPIO3_D5 + +SPI1_MOSI_M0 = GPIO2_C2 +SPI1_MISO_M0 = GPIO2_C1 +SPI1_CLK_M0 = GPIO2_C0 +SPI1_SCLK_M0 = SPI1_CLK_M0 +SPI1_CS0_M0 = GPIO2_C3 +SPI1_CS1_M0 = GPIO2_C4 SPI1_MOSI_M1 = GPIO3_B7 SPI1_MISO_M1 = GPIO3_C0 @@ -267,61 +443,214 @@ SPI1_SCLK_M1 = SPI1_CLK_M1 SPI1_CS0_M1 = GPIO3_C2 SPI1_CS1_M1 = GPIO3_C3 -SPI3_MISO_M0 = GPIO4_C4 -SPI3_MOSI_M0 = GPIO4_C5 +SPI1_MOSI_M2 = GPIO1_D1 +SPI1_MISO_M2 = GPIO1_D0 +SPI1_CLK_M2 = GPIO1_D2 +SPI1_SCLK_M2 = SPI1_CLK_M2 +SPI1_CS0_M2 = GPIO1_D3 +SPI1_CS1_M2 = GPIO1_D5 + +SPI2_MOSI_M0 = GPIO1_A5 +SPI2_MISO_M0 = GPIO1_A4 +SPI2_CLK_M0 = GPIO1_A6 +SPI2_SCLK_M0 = SPI2_CLK_M0 +SPI2_CS0_M0 = GPIO1_A7 +SPI2_CS1_M0 = GPIO1_B0 + +SPI2_MOSI_M1 = GPIO4_A5 +SPI2_MISO_M1 = GPIO4_A4 +SPI2_CLK_M1 = GPIO4_A6 +SPI2_SCLK_M1 = SPI2_CLK_M1 +SPI2_CS0_M1 = GPIO4_A7 +SPI2_CS1_M1 = GPIO4_B0 + +SPI2_MOSI_M2 = GPIO0_A6 +SPI2_MISO_M2 = GPIO0_B3 +SPI2_CLK_M2 = GPIO0_A5 +SPI2_SCLK_M2 = SPI2_CLK_M2 +SPI2_CS0_M2 = GPIO0_B1 +SPI2_CS1_M2 = GPIO0_B0 + +SPI3_MOSI_M0 = GPIO4_C4 +SPI3_MISO_M0 = GPIO4_C5 SPI3_SCK_M0 = GPIO4_C6 SPI3_SCLK_M0 = SPI3_SCK_M0 +SPI3_CS0_M0 = GPIO4_C2 +SPI3_CS1_M0 = GPIO4_C3 + +SPI3_MOSI_M1 = GPIO4_B6 +SPI3_MISO_M1 = GPIO4_B5 +SPI3_SCK_M1 = GPIO4_B7 +SPI3_SCLK_M1 = SPI3_SCK_M1 +SPI3_CS0_M1 = GPIO4_C0 +SPI3_CS1_M1 = GPIO4_C1 + +SPI3_MOSI_M2 = GPIO0_D2 +SPI3_MISO_M2 = GPIO0_D0 +SPI3_SCK_M2 = GPIO0_D3 +SPI3_SCLK_M2 = SPI3_SCK_M2 +SPI3_CS0_M2 = GPIO0_D4 +SPI3_CS1_M2 = GPIO0_D5 + +SPI3_MOSI_M3 = GPIO3_C7 +SPI3_MISO_M3 = GPIO3_C6 +SPI3_SCK_M3 = GPIO3_D0 +SPI3_SCLK_M3 = SPI3_SCK_M3 +SPI3_CS0_M3 = GPIO3_C4 +SPI3_CS1_M3 = GPIO3_C5 -SPI4_MISO_M0 = GPIO1_C0 SPI4_MOSI_M0 = GPIO1_C1 +SPI4_MISO_M0 = GPIO1_C0 SPI4_SCK_M0 = GPIO1_C2 SPI4_SCLK_M0 = SPI4_SCK_M0 +SPI4_CS0_M0 = GPIO1_C3 +SPI4_CS1_M0 = GPIO1_C4 + +SPI4_MOSI_M1 = GPIO3_A1 +SPI4_MISO_M1 = GPIO3_A0 +SPI4_SCK_M1 = GPIO3_A2 +SPI4_SCLK_M1 = SPI4_SCK_M1 +SPI4_CS0_M1 = GPIO3_A3 +SPI4_CS1_M1 = GPIO3_A4 + +SPI4_MOSI_M2 = GPIO1_A1 +SPI4_MISO_M2 = GPIO1_A0 +SPI4_SCK_M2 = GPIO1_A2 +SPI4_SCLK_M2 = SPI4_SCK_M2 +SPI4_CS0_M2 = GPIO1_A3 # ordered as spiId, sckId, mosiId, misoId spiPorts = ( - (0, SPI0_SCLK_M2, SPI0_MOSI_M2, SPI0_MISO_M2), + (0, SPI0_SCLK_M0, SPI0_MOSI_M0, SPI0_MISO_M0), (0, SPI0_SCLK_M1, SPI0_MOSI_M1, SPI0_MISO_M1), + (0, SPI0_SCLK_M2, SPI0_MOSI_M2, SPI0_MISO_M2), + (0, SPI0_SCLK_M3, SPI0_MOSI_M3, SPI0_MISO_M3), + (1, SPI1_SCLK_M0, SPI1_MOSI_M0, SPI1_MISO_M0), (1, SPI1_SCLK_M1, SPI1_MOSI_M1, SPI1_MISO_M1), + (1, SPI1_SCLK_M2, SPI1_MOSI_M2, SPI1_MISO_M2), + (2, SPI2_SCLK_M0, SPI2_MOSI_M0, SPI2_MISO_M0), + (2, SPI2_SCLK_M1, SPI2_MOSI_M1, SPI2_MISO_M1), + (2, SPI2_SCLK_M2, SPI2_MOSI_M2, SPI2_MISO_M2), (3, SPI3_SCLK_M0, SPI3_MOSI_M0, SPI3_MISO_M0), + (3, SPI3_SCLK_M1, SPI3_MOSI_M1, SPI3_MISO_M1), + (3, SPI3_SCLK_M2, SPI3_MOSI_M2, SPI3_MISO_M2), + (3, SPI3_SCLK_M3, SPI3_MOSI_M3, SPI3_MISO_M3), (4, SPI4_SCLK_M0, SPI4_MOSI_M0, SPI4_MISO_M0), + (4, SPI4_SCLK_M1, SPI4_MOSI_M1, SPI4_MISO_M1), + (4, SPI4_SCLK_M2, SPI4_MOSI_M2, SPI4_MISO_M2), ) # PWM +PWM0_M0 = GPIO0_D2 +PWM0_M1 = GPIO1_D2 PWM0_M2 = GPIO1_A2 +PWM1_M0 = GPIO0_C0 +PWM1_M1 = GPIO0_D3 PWM1_M2 = GPIO1_A3 +PWM2_M0 = GPIO0_C4 PWM2_M1 = GPIO3_B1 +PWM2_M2 = GPIO4_C2 +PWM3_IR_M0 = GPIO0_D4 PWM3_IR_M1 = GPIO3_B2 +PWM3_IR_M2 = GPIO1_C2 +PWM3_IR_M3 = GPIO1_A7 +PWM3_M0 = PWM3_IR_M0 +PWM3_M1 = PWM3_IR_M1 +PWM3_M2 = PWM3_IR_M2 +PWM3_M3 = PWM3_IR_M3 +PWM4_M0 = GPIO0_C5 +PWM4_M1 = GPIO4_C3 +PWM5_M0 = GPIO0_C6 +PWM5_M1 = GPIO0_C6 PWM5_M2 = GPIO4_C4 +PWM6_M0 = GPIO0_C7 +PWM6_M1 = GPIO4_C1 PWM6_M2 = GPIO4_C5 +PWM7_IR_M0 = GPIO0_D0 +PWM7_IR_M1 = GPIO4_D4 +PWM7_IR_M2 = GPIO1_C3 PWM7_IR_M3 = GPIO4_C6 +PWM7_M0 = PWM7_IR_M0 +PWM7_M1 = PWM7_IR_M1 +PWM7_M2 = PWM7_IR_M2 +PWM7_M3 = PWM7_IR_M3 PWM8_M0 = GPIO3_A7 +PWM8_M1 = GPIO4_D0 +PWM8_M2 = GPIO3_D0 +PWM9_M0 = GPIO3_B0 +PWM9_M1 = GPIO4_D1 +PWM9_M2 = GPIO3_D1 +PWM10_M0 = GPIO3_A0 +PWM10_M1 = GPIO4_D3 PWM10_M2 = GPIO3_D3 +PWM11_IR_M0 = GPIO3_A1 +PWM11_IR_M1 = GPIO4_B4 +PWM11_IR_M2 = GPIO1_C4 PWM11_IR_M3 = GPIO3_D5 +PWM11_M0 = PWM11_IR_M0 +PWM11_M1 = PWM11_IR_M1 +PWM11_M2 = PWM11_IR_M2 +PWM11_M3 = PWM11_IR_M3 PWM12_M0 = GPIO3_B5 -PWM13_M1 = GPIO4_B6 +PWM12_M1 = GPIO4_B5 PWM13_M0 = GPIO3_B6 +PWM13_M1 = GPIO4_B6 PWM13_M2 = GPIO1_B7 PWM14_M0 = GPIO3_C2 PWM14_M1 = GPIO4_B2 PWM14_M2 = GPIO1_D6 PWM15_IR_M0 = GPIO3_C3 PWM15_IR_M1 = GPIO4_B3 +PWM15_IR_M2 = GPIO1_C6 PWM15_IR_M3 = GPIO1_D7 +PWM15_M0 = PWM15_IR_M0 +PWM15_M1 = PWM15_IR_M1 +PWM15_M2 = PWM15_IR_M2 +PWM15_M3 = PWM15_IR_M3 # SysFS pwm outputs, pwm channel and pin in first tuple pwmOuts = ( + ((0, 0), PWM0_M0), + ((0, 0), PWM0_M1), ((0, 0), PWM0_M2), + ((0, 1), PWM1_M0), + ((0, 1), PWM1_M1), ((0, 1), PWM1_M2), + ((0, 2), PWM2_M0), ((0, 2), PWM2_M1), + ((0, 2), PWM2_M2), + ((0, 3), PWM3_IR_M0), ((0, 3), PWM3_IR_M1), + ((0, 3), PWM3_IR_M2), + ((0, 3), PWM3_IR_M3), + ((0, 4), PWM4_M0), + ((0, 4), PWM4_M1), + ((0, 5), PWM5_M0), + ((0, 5), PWM5_M1), ((0, 5), PWM5_M2), + ((0, 6), PWM6_M0), + ((0, 6), PWM6_M1), ((0, 6), PWM6_M2), + ((0, 7), PWM7_IR_M0), + ((0, 7), PWM7_IR_M1), + ((0, 7), PWM7_IR_M2), ((0, 7), PWM7_IR_M3), ((0, 8), PWM8_M0), + ((0, 8), PWM8_M1), + ((0, 8), PWM8_M2), + ((0, 9), PWM9_M0), + ((0, 9), PWM9_M1), + ((0, 9), PWM9_M2), + ((0, 10), PWM10_M0), + ((0, 10), PWM10_M1), ((0, 10), PWM10_M2), + ((0, 11), PWM11_IR_M0), + ((0, 11), PWM11_IR_M1), + ((0, 11), PWM11_IR_M2), ((0, 11), PWM11_IR_M3), ((0, 12), PWM12_M0), + ((0, 12), PWM12_M1), ((0, 13), PWM13_M0), ((0, 13), PWM13_M1), ((0, 13), PWM13_M2), @@ -335,4 +664,20 @@ pwmOuts = ( # SysFS analog inputs, Ordered as analog analogInId, device, and channel ADC_IN0 = 0 -analogIns = ((ADC_IN0, 0, 4),) +ADC_IN1 = 1 +ADC_IN2 = 2 +ADC_IN3 = 3 +ADC_IN4 = 4 +ADC_IN5 = 5 +ADC_IN6 = 6 +ADC_IN7 = 7 +analogIns = ( + (ADC_IN0, 0, 0), + (ADC_IN1, 0, 1), + (ADC_IN2, 0, 2), + (ADC_IN3, 0, 3), + (ADC_IN4, 0, 4), + (ADC_IN5, 0, 5), + (ADC_IN6, 0, 6), + (ADC_IN7, 0, 7), +) diff --git a/src/board.py b/src/board.py index cde9726..cf32fd6 100644 --- a/src/board.py +++ b/src/board.py @@ -41,7 +41,10 @@ elif board_id == ap_board.PYBOARD: elif board_id == ap_board.RASPBERRY_PI_PICO: from adafruit_blinka.board.raspberrypi.pico import * -elif detector.board.any_raspberry_pi_4_board or detector.board.any_raspberry_pi_5_board: +elif detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.board.raspberrypi.raspi_5 import * + +elif detector.board.any_raspberry_pi_4_board: from adafruit_blinka.board.raspberrypi.raspi_4b import * elif detector.board.any_raspberry_pi_40_pin: @@ -128,6 +131,9 @@ elif board_id == ap_board.ORANGE_PI_ZERO_2: elif board_id == ap_board.ORANGE_PI_3: from adafruit_blinka.board.orangepi.orangepi3 import * +elif board_id == ap_board.ORANGE_PI_3_LTS: + from adafruit_blinka.board.orangepi.orangepi3lts import * + elif board_id == ap_board.ORANGE_PI_3B: from adafruit_blinka.board.orangepi.orangepi3b import * @@ -137,7 +143,7 @@ elif board_id == ap_board.ORANGE_PI_4: elif board_id == ap_board.ORANGE_PI_4_LTS: from adafruit_blinka.board.orangepi.orangepi4 import * -elif board_id == ap_board.ORANGE_PI_5: +elif board_id in (ap_board.ORANGE_PI_5, ap_board.ORANGE_PI_5_MAX): from adafruit_blinka.board.orangepi.orangepi5 import * elif board_id == ap_board.ORANGE_PI_5_PLUS: @@ -161,6 +167,9 @@ elif board_id == ap_board.BANANA_PI_M5: elif board_id == ap_board.BANANA_PI_F3: from adafruit_blinka.board.bananapi.bpif3 import * +elif board_id == ap_board.BANANA_PI_F5: + from adafruit_blinka.board.bananapi.bpif5 import * + elif board_id == ap_board.LEMAKER_BANANA_PRO: from adafruit_blinka.board.lemaker.bananapro import * @@ -305,6 +314,12 @@ elif board_id == ap_board.ROCK_PI_5C: elif board_id == ap_board.ROCK_PI_E: from adafruit_blinka.board.radxa.rockpie import * +elif board_id == ap_board.VAAMAN: + from adafruit_blinka.board.vicharak.vaaman import * + +elif board_id == ap_board.AXON: + from adafruit_blinka.board.vicharak.axon import * + elif board_id == ap_board.UDOO_X86: from adafruit_blinka.board.udoo_x86ultra import * @@ -437,6 +452,9 @@ elif board_id == ap_board.VIVID_UNIT: elif board_id == ap_board.INDIEDROID_NOVA: from adafruit_blinka.board.ameridroid.indiedroid_nova import * +elif board_id == ap_board.RDK_X3: + from adafruit_blinka.board.horizon.rdkx3 import * + elif "sphinx" in sys.modules: pass diff --git a/src/digitalio.py b/src/digitalio.py index 6f04984..a35f377 100644 --- a/src/digitalio.py +++ b/src/digitalio.py @@ -15,14 +15,10 @@ from adafruit_blinka.agnostic import board_id, detector # By Chip Class if detector.chip.BCM2XXX: - if board_id in ( - "RASPBERRY_PI_4B", - "RASPBERRY_PI_400", - "RASPBERRY_PI_CM4", - "RASPBERRY_PI_CM4S", - "RASPBERRY_PI_5", - ): - from adafruit_blinka.microcontroller.bcm2711.pin import * + if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.bcm2712.pin import Pin + elif detector.board.any_raspberry_pi_4_board: + from adafruit_blinka.microcontroller.bcm2711.pin import Pin else: from adafruit_blinka.microcontroller.bcm283x.pin import Pin elif detector.chip.AM33XX: @@ -115,12 +111,16 @@ elif detector.chip.H618: from adafruit_blinka.microcontroller.allwinner.h618.pin import Pin elif detector.chip.H616: from adafruit_blinka.microcontroller.allwinner.h616.pin import Pin +elif detector.chip.T527: + from adafruit_blinka.microcontroller.allwinner.t527.pin import Pin elif detector.chip.D1_RISCV: from adafruit_blinka.microcontroller.allwinner.D1.pin import Pin elif detector.chip.TH1520: from adafruit_blinka.microcontroller.thead.th1520.pin import Pin elif detector.chip.K1: from adafruit_blinka.microcontroller.spacemit.k1.pin import Pin +elif detector.chip.SUNRISE_X3: + from adafruit_blinka.microcontroller.horizon.sunrise_x3.pin import Pin # Special Case Boards elif detector.board.ftdi_ft232h: from adafruit_blinka.microcontroller.ftdi_mpsse.ft232h.pin import Pin diff --git a/src/microcontroller/__init__.py b/src/microcontroller/__init__.py index 2792e7b..9f5e0fa 100644 --- a/src/microcontroller/__init__.py +++ b/src/microcontroller/__init__.py @@ -65,6 +65,8 @@ elif chip_id == ap_chip.H618: from adafruit_blinka.microcontroller.allwinner.h618 import * elif chip_id == ap_chip.H616: from adafruit_blinka.microcontroller.allwinner.h616 import * +elif chip_id == ap_chip.T527: + from adafruit_blinka.microcontroller.allwinner.t527 import * elif chip_id == ap_chip.SAMA5: from adafruit_blinka.microcontroller.sama5 import * elif chip_id == ap_chip.T210: @@ -159,6 +161,8 @@ elif chip_id == ap_chip.TH1520: from adafruit_blinka.microcontroller.thead.th1520 import * elif chip_id == ap_chip.K1: from adafruit_blinka.microcontroller.spacemit.k1 import * +elif chip_id == ap_chip.SUNRISE_X3: + from adafruit_blinka.microcontroller.horizon.sunrise_x3 import * elif chip_id == ap_chip.GENERIC_X86: print("WARNING: GENERIC_X86 is not fully supported. Some features may not work.") elif chip_id == ap_chip.OS_AGNOSTIC: diff --git a/src/microcontroller/pin.py b/src/microcontroller/pin.py index 3d4a560..1241672 100644 --- a/src/microcontroller/pin.py +++ b/src/microcontroller/pin.py @@ -4,7 +4,7 @@ """Pins named after their chip name.""" import sys from adafruit_platformdetect.constants import chips as ap_chip, boards as ap_boards -from adafruit_blinka.agnostic import board_id, chip_id +from adafruit_blinka.agnostic import board_id, chip_id, detector # We intentionally are patching into this namespace so skip the wildcard check. # pylint: disable=unused-wildcard-import,wildcard-import,ungrouped-imports @@ -16,13 +16,9 @@ elif chip_id == ap_chip.STM32F405: elif chip_id == ap_chip.RP2040: from adafruit_blinka.microcontroller.rp2040.pin import * elif chip_id == ap_chip.BCM2XXX: - if board_id in ( - "RASPBERRY_PI_4B", - "RASPBERRY_PI_400", - "RASPBERRY_PI_CM4", - "RASPBERRY_PI_CM4S", - "RASPBERRY_PI_5", - ): + if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.bcm2712.pin import * + elif detector.board.any_raspberry_pi_4_board: from adafruit_blinka.microcontroller.bcm2711.pin import * else: from adafruit_blinka.microcontroller.bcm283x.pin import * @@ -58,6 +54,8 @@ elif chip_id == ap_chip.H616: from adafruit_blinka.board.repkapi.repka_pi_4 import * else: from adafruit_blinka.microcontroller.allwinner.h616.pin import * +elif chip_id == ap_chip.T527: + from adafruit_blinka.microcontroller.allwinner.t527.pin import * elif chip_id == ap_chip.SAMA5: from adafruit_blinka.microcontroller.sama5.pin import * elif chip_id == ap_chip.T210: @@ -153,6 +151,8 @@ elif chip_id == ap_chip.RV1103: from adafruit_blinka.microcontroller.rockchip.rv1103.pin import * elif chip_id == ap_chip.RV1106: from adafruit_blinka.microcontroller.rockchip.rv1106.pin import * +elif chip_id == ap_chip.SUNRISE_X3: + from adafruit_blinka.microcontroller.horizon.sunrise_x3.pin import * elif "sphinx" in sys.modules: # pylint: disable=unused-import from adafruit_blinka.microcontroller.generic_micropython import Pin diff --git a/src/pwmio.py b/src/pwmio.py index 72ce0d8..4b3f4c8 100644 --- a/src/pwmio.py +++ b/src/pwmio.py @@ -16,8 +16,11 @@ from adafruit_blinka.agnostic import detector # pylint: disable=unused-import -if detector.board.any_raspberry_pi: - from adafruit_blinka.microcontroller.bcm283x.pwmio.PWMOut import PWMOut +if detector.board.any_raspberry_pi_5_board: + from adafruit_blinka.microcontroller.generic_linux.lgpio_pwmout import PWMOut +elif detector.board.any_raspberry_pi: + # Pi 4 or lower + from adafruit_blinka.microcontroller.generic_linux.rpi_gpio_pwmout import PWMOut elif detector.board.any_bananapi: from adafruit_blinka.microcontroller.generic_linux.sysfs_pwmout import PWMOut elif detector.board.any_coral_board: @@ -50,6 +53,8 @@ elif detector.board.any_luckfox_pico_board: from adafruit_blinka.microcontroller.generic_linux.sysfs_pwmout import PWMOut elif detector.board.any_starfive_id: from adafruit_blinka.microcontroller.starfive.JH7110.pwmio import PWMOut +elif detector.board.any_horizon_board: + from adafruit_blinka.microcontroller.horizon.pwmio.PWMOut import PWMOut elif detector.board.OS_AGNOSTIC_BOARD: from adafruit_blinka.microcontroller.generic_agnostic_board.PWMOut import PWMOut elif (