3. 40PIN 功能使用

旭日X3派支持40PIN功能管脚,兼容树莓派的40PIN功能,接口定义请查看 旭日X3派40PIN

3.1. 管脚复用配置

40PIN的管脚会按照 旭日X3派40PIN 所示,默认使能 UART、SPI、I2C、I2S这些专用功能,并且加载对应的驱动,如果要把这些管脚当作GPIO功能使用,建议先通过 srpi-config 软件 disable 相应的功能。

通过 ssh方式 登录设备后,执行以下命令打开配置窗口:

sudo srpi-config

image-20220511173307239

okay配置对应管脚为专用功能,disabled配置对应管脚为GPIO模式,配置 重启 后生效。

  • 键盘上、下键选择功能项, 回车键开关功能

  • 键盘左、右键选择 Select 和 Exit ,回车键确认

3.2. 使用旭日X3派GPIO

旭日X3派默认已经安装了PythonHobot.GPIO,可以通过导入模块,并且查看其版本信息。

3.2.1. 导入Hobot.GPIO

sunrise@ubuntu:~$ sudo python3
Python 3.8.10 (default, Mar 15 2022, 12:22:08) 
Type "help", "copyright", "credits" or "license" for more information.
>>> import Hobot.GPIO as GPIO
Get board ID: 0x504
>>> GPIO.VERSION
'0.0.2'
>>> GPIO.model
'X3PI'

检测是否导入成功:

try:
    import Hobot.GPIO as GPIO
except RuntimeError:
    print("Error importing Hobot.GPIO!  This is probably because you need superuser privileges.  You can achieve this by using 'sudo' to run your script")

3.2.2. 设置引脚编号方式

旭日X3派的引脚编号有3种模式:

  • BOARD(the pin number of the 40 pin GPIO header):物理引脚序号,在硬件上丝印上可以直接看到的序号,物理上正好一一对应。

  • BCM(the Broadcom SoC GPIO numbers):BCM是根据博通SoC的GPIO规则命名的。

  • CVM 使用字符串代替数字,对应于CVM / CVB连接器的信号名称。

  • SOC 对应的编号是旭日X3M芯片的GPIO管脚序号,与芯片数据手册一一对应。

设置编码方式:

GPIO.setmode(GPIO.BOARD)
# or
GPIO.setmode(GPIO.BCM)
# or
GPIO.setmode(GPIO.CVM)
# or 
GPIO.setmode(GPIO.SOC)

查询编码方式:

mode = GPIO.getmode()

输出: BOARD, BCM, CVM, SOC or None

3.2.3. 警告信息

您尝试使用的 GPIO 可能已在当前应用程序外部使用。在这种情况下,GPIO 库将向您发出警告。如果您在设置模式和频道之前尝试清理,它也会警告您。要禁用警告,请调用:

GPIO.setwarnings(False)

3.2.4. 设置管脚

GPIO 通道必须在用作输入或输出之前进行设置。要将通道配置为输入,请调用:

# (其中通道基于上面讨论的引脚编号模式)
GPIO.setup(channel, GPIO.IN)

要设置输出,请调用:

GPIO.setup(channel, GPIO.OUT)

也可以为输出通道指定一个初始值:

GPIO.setup(channel, GPIO.OUT, initial=GPIO.HIGH)

将通道设置为输出时,也可以同时设置多个通道:

# 根据需要添加尽可能多的通道。您还可以使用元组: (18,12,13)
channels = [18, 12, 13]
GPIO.setup(channels, GPIO.OUT)

3.2.5. 输入操作

要读取通道的值,请使用:

GPIO.input(channel)

将返回 0 或者 1。 0 代表 GPIO.LOW, 1 代表 GPIO.HIGH。

3.2.6. 输出操作

要设置配置为输出的引脚的值,请使用:

GPIO.output(channel, state)

其中 state 可以是 GPIO.LOW 或 GPIO.HIGH。

3.2.7. 清理管脚占用

在程序结束时,最好清理通道。要清理所有使用的通道,请调用:

GPIO.cleanup()

如果只清理特定通道,请使用:

# 清除单个通道
GPIO.cleanup(channel)
# 清除一组通道
GPIO.cleanup( (channel1, channel2) )
GPIO.cleanup( [channel1, channel2] )

3.2.8. 查看管脚状态

此功能允许您检查提供的 GPIO 通道的功能:

GPIO.gpio_function(channel)

该函数返回 IN 或 OUT。

3.2.9. 边沿检测与中断

边沿是电信号从低到高(上升沿)或从高到低(下降沿)的改变,这种改变可以看作是一种事件的发生,这种事件可以用来触发一个CPU中断信号。

除了忙轮询之外,本库还提供了三种额外的方法来监视输入事件:

3.2.9.1. wait_for_edge() 函数

此函数阻塞调用线程,直到检测到提供的边缘。该函数可以如下调用:

GPIO.wait_for_edge(channel, GPIO.RISING)

第二个参数指定要检测的边沿,可以是 GPIO.RISING、GPIO.FALLING 或 GPIO.BOTH。如果您只想将等待限制为指定的时间,可以选择设置超时:

# 超时以毫秒为单位
GPIO.wait_for_edge(channel, GPIO.RISING, timeout=500)

该函数返回检测到边缘的通道,如果发生超时,则返回 None。

3.2.9.2. event_detected() 函数

此函数可用于定期检查自上次调用以来是否发生了事件。该函数可以按如下方式设置和调用:

# 在通道GPIO上设置上升沿检测
GPIO.add_event_detect(channel, GPIO.RISING)
if GPIO.event_detected(channel):
    print("Rising edge event detected")

您可以检测 GPIO.RISING、GPIO.FALLING 或 GPIO.BOTH 的事件。

3.2.9.3. 检测到边沿事件时运行回调函数

此功能可用于为回调函数运行第二个线程。因此,回调函数可以与您的主程序并发运行以响应边沿事件。此功能可按如下方式使用:

# 定义回调函数
def callback_fn(channel):
    print("Callback called from channel %s" % channel)

# 添加上升沿检测
GPIO.add_event_detect(channel, GPIO.RISING, callback=callback_fn)

如果需要,也可以添加多个回调,如下所示:

def callback_one(channel):
    print("First Callback")

def callback_two(channel):
    print("Second Callback")

GPIO.add_event_detect(channel, GPIO.RISING)
GPIO.add_event_callback(channel, callback_one)
GPIO.add_event_callback(channel, callback_two)

在这种情况下,两个回调是按顺序运行的,而不是同时运行的,因为只有一个线程运行所有回调函数。

为了通过将多个事件合并为一个事件来防止多次调用回调函数,可以选择设置去抖动时间:

# 以毫秒为单位设置的去抖时间
GPIO.add_event_detect(channel, GPIO.RISING, callback=callback_fn, bouncetime=200)

3.2.9.4. 关闭中断

如果不再需要边沿检测,可以将其删除,如下所示:

GPIO.remove_event_detect(channel)

3.2.10. 测试例程

/app/40pin_samples/目录下提供主要的测试例程:

测试例程名 说明
simple_out.py 单个管脚输出测试
simple_input.py 单个管脚输入测试
button_led.py 一个管脚作为按键输入,一个管脚作为输出控制LED
test_all_pins_input.py 所有管脚的输入测试代码
test_all_pins.py 所有管脚的输出测试代码
button_event.py 捕获管脚的上升沿、下降沿事件
button_interrupt.py 中断方式处理管脚的上升沿、下降沿事件
  • GPIO 设置为输出模式,1秒钟切换输出电平,可以用于控制LED灯的循环亮灭, 测试代码 simple_out.py

#!/usr/bin/env python3

import Hobot.GPIO as GPIO
import time

# 定义使用的GPIO通道为38
output_pin = 38 # BOARD 编码 38

def main():
    # 设置管脚编码模式为硬件编号 BOARD
    GPIO.setmode(GPIO.BOARD)
    # 设置为输出模式,并且初始化为高电平
    GPIO.setup(output_pin, GPIO.OUT, initial=GPIO.HIGH)
    # 记录当前管脚状态
    curr_value = GPIO.HIGH
    print("Starting demo now! Press CTRL+C to exit")
    try:
        # 间隔1秒时间,循环控制LED灯亮灭
        while True:
            time.sleep(1)
            GPIO.output(output_pin, curr_value)
            curr_value ^= GPIO.HIGH
    finally:
        GPIO.cleanup()

if __name__=='__main__':
    main()
  • GPIO 设置为输入模式,通过忙轮询方式读取管脚电平值,测试代码 simple_input.py

#!/usr/bin/env python3

import Hobot.GPIO as GPIO
import time

# 定义使用的GPIO通道为38
input_pin = 38 # BOARD 编码 38 

def main():
    prev_value = None

    # 设置管脚编码模式为硬件编号 BOARD
    GPIO.setmode(GPIO.BOARD)
    # 设置为输入模式
    GPIO.setup(input_pin, GPIO.IN)

    print("Starting demo now! Press CTRL+C to exit")
    try:
        # 间隔1秒时间,循环控制LED灯亮灭
        while True:
            # 读取管脚电平
            value = GPIO.input(input_pin)
            if value != prev_value:
                if value == GPIO.HIGH:
                    value_str = "HIGH"
                else:
                    value_str = "LOW"
                print("Value read from pin {} : {}".format(input_pin, value_str))
                prev_value = value
            time.sleep(1)
    finally:
        GPIO.cleanup()

if __name__=='__main__':
    main()
  • GPIO 设置为输入模式,捕获管脚的上升沿、下降沿事件,测试代码 button_event.py, 实现检测38号管脚的下降沿,然后控制36号管脚的输出:

#!/usr/bin/env python3

import Hobot.GPIO as GPIO
import time

# 定义使用的GPIO通道:
# 36号作为输出,可以点亮一个LED
# 38号作为输入,可以接一个按钮
led_pin = 36 # BOARD 编码 36
but_pin = 38 # BOARD 编码 38

# 禁用警告信息
GPIO.setwarnings(False)

def main():
    # 设置管脚编码模式为硬件编号 BOARD
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(led_pin, GPIO.OUT)  # LED pin set as output
    GPIO.setup(but_pin, GPIO.IN)  # button pin set as input

    # Initial state for LEDs:
    GPIO.output(led_pin, GPIO.LOW)

    print("Starting demo now! Press CTRL+C to exit")
    try:
        while True:
            print("Waiting for button event")
            GPIO.wait_for_edge(but_pin, GPIO.FALLING)

            # event received when button pressed
            print("Button Pressed!")
            GPIO.output(led_pin, GPIO.HIGH)
            time.sleep(1)
            GPIO.output(led_pin, GPIO.LOW)
    finally:
        GPIO.cleanup()  # cleanup all GPIOs

if __name__ == '__main__':
    main()
  • GPIO 设置为输入模式,启动gpio中断功能,响应管脚的上升沿、下降沿事件,测试代码 button_interrupt.py, 实现检测38号管脚的下降沿,然后控制36号管脚快速切换高低电平5秒钟:

#!/usr/bin/env python3

import Hobot.GPIO as GPIO
import time

# Pin Definitions:
led_pin_1 = 12
led_pin_2 = 13
but_pin = 18

# 定义使用的GPIO通道:
# 35号作为输出,可以点亮一个LED
# 36号作为输出,可以点亮一个LED
# 38号作为输入,可以接一个按钮
led_pin = 35 # BOARD 编码 36
led_pin2 = 36 # BOARD 编码 36
but_pin = 38 # BOARD 编码 38

# 禁用警告信息
GPIO.setwarnings(False)

# 按下按钮时 LED 2 快速闪烁 5 次
def blink(channel):
    print("Blink LED 2")
    for i in range(5):
        GPIO.output(led_pin_2, GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(led_pin_2, GPIO.LOW)
        time.sleep(0.5)

def main():
    # Pin Setup:
    GPIO.setmode(GPIO.BOARD)  # BOARD pin-numbering scheme
    GPIO.setup([led_pin_1, led_pin_2], GPIO.OUT)  # LED pins set as output
    GPIO.setup(but_pin, GPIO.IN)  # button pin set as input

    # Initial state for LEDs:
    GPIO.output(led_pin_1, GPIO.LOW)
    GPIO.output(led_pin_2, GPIO.LOW)

    # 把blink函数注册为按钮下降沿事件的中断处理函数
    GPIO.add_event_detect(but_pin, GPIO.FALLING, callback=blink, bouncetime=10)
    # 开始测试, Led1 缓慢闪烁
    print("Starting demo now! Press CTRL+C to exit")
    try:
        while True:
            # blink LED 1 slowly
            GPIO.output(led_pin_1, GPIO.HIGH)
            time.sleep(2)
            GPIO.output(led_pin_1, GPIO.LOW)
            time.sleep(2)
    finally:
        GPIO.cleanup()  # cleanup all GPIOs

if __name__ == '__main__':
    main()

3.3. 使用PWM

Hobot.GPIO 库仅在带有附加硬件 PWM 控制器的引脚上支持 PWM。与 RPi.GPIO 库不同,Hobot.GPIO 库不实现软件模拟 PWM。旭日X3派支持 2 个 PWM 通道。

请参阅 /app/40pin_samples/simple_pwm.py了解如何使用 PWM 通道的详细信息。

测试说明: 打开 output_pin 指定的PWM通道,初始占空比 25%, 先每0.25秒增加5%占空比,达到100%之后再每0.25秒减少5%占空比,在正常输出波形时,可以通过示波器或者逻辑分析仪测量输出信号,观察波形。

#!/usr/bin/env python3

import Hobot.GPIO as GPIO
import time

# 支持PWM的管脚: 32 and 33
output_pin = 33

def main():
    # Pin Setup:
    # Board pin-numbering scheme
    GPIO.setmode(GPIO.BOARD)
    # 支持的频率范围: 48KHz ~ 192MHz
    p = GPIO.PWM(output_pin, 48000)
    # 初始占空比 25%, 先每0.25秒增加5%占空比,达到100%之后再每0.25秒减少5%占空比
    val = 25
    incr = 5
    p.start(val)

    print("PWM running. Press CTRL+C to exit.")
    try:
        while True:
            time.sleep(0.25)
            if val >= 100:
                incr = -incr
            if val <= 0:
                incr = -incr
            val += incr
            p.ChangeDutyCycle(val)
    finally:
        p.stop()
        GPIO.cleanup()

if __name__ == '__main__':
    main()

3.4. 使用串口

旭日X3派在40PIN上默认使能 UART3,物理管脚号 8 和 10,IO电压 3.3V。

请参阅 /app/40pin_samples/test_serial.py了解如何使用串口的详细信息。

回环测试: 把TXD和RXD在硬件上进行连接,然后运行测试程序,进行写和读操作,预期结果是读出的数据要完全等于写入的数据

硬件连接: 把TXD和RXD通过跳线帽直接硬件上连接在一起

image-20220512101820743

回环测试过程:

  • 运行 python3 /app/40pin_samples/test_serial.py

  • 从打印的串口设备(其中/dev/ttyS0是系统调试口,不建议对它进行测试,除非你完全明白它的作用)中选择总线号和片选号作为输入选项,例如选则测试 /dev/ttyS3,按回车键确认,并输入波特率参数:

List of enabled UART:
/dev/ttyS0  /dev/ttyS1  /dev/ttyS3  /dev/ttyUSB0

请输出需要测试的串口设备名:/dev/ttyS3
请输入波特率(9600,19200,38400,57600,115200,921600):921600
Serial<id=0x7f819dcac0, open=True>(port='/dev/ttyS3', baudrate=921600, bytesize=8, parity='N', stopbits=1, timeout=1, xonxoff=False, rtscts=False, dsrdtr=False)
  • 程序正确运行起来后会持续打印 Send: AA55Recv:  AA55

Starting demo now! Press CTRL+C to exit
Send:  AA55
Recv:  AA55

实现代码如下:

#!/usr/bin/env python3

import sys
import os
import time

# 导入python串口库
import serial
import serial.tools.list_ports

def serialTest():
    print("List of enabled UART:")
    os.system('ls /dev/tty[a-zA-Z]*')
    uart_dev= input("请输出需要测试的串口设备名:")

    baudrate = input("请输入波特率(9600,19200,38400,57600,115200,921600):")
    try:
        ser = serial.Serial(uart_dev, int(baudrate), timeout=1) # 1s timeout
    except Exception as e:
        print("open serial failed!\n")

    print(ser)

    print("Starting demo now! Press CTRL+C to exit")

    while True:
        test_data = "AA55"
        write_num = ser.write(test_data.encode('UTF-8'))
        print("Send: ", test_data)

        received_data = ser.read(write_num).decode('UTF-8')
        print("Recv: ", received_data)

        time.sleep(1)

    ser.close()
    return 0


if __name__ == '__main__':
    if serialTest() != 0:
        print("Serial test failed!")
    else:
        print("Serial test success!")

3.5. 使用I2C

旭日X3派在40Pin上默认使能 I2C0,物理管脚号 3 和 5,IO电压3.3V。

请参阅 /app/40pin_samples/test_i2c.py了解如何使用I2C的详细信息。

测试方法说明:

  • 运行测试程序 python3 /app/40pin_samples/test_i2c.py

  • 首先列出当前系统使能的i2c总线

  • 通过输入总线号扫描得到当前总线上连接了哪些外设

  • 输入外设地址(16进制数),测试程序会从外设上读取以这个字节数

运行效果如下:

Starting demo now! Press CTRL+C to exit
List of enabled I2C controllers:
/dev/i2c-0  /dev/i2c-1  /dev/i2c-2
Please input I2C BUS num:2
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- 3b -- -- -- -- 
40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --                         
Please input I2C device num(Hex):40
Read data from device 40 on I2C bus 2
read value= b' '

实现代码如下:

#!/usr/bin/env python3

import sys
import os
import time

# 导入i2cdev
from i2cdev import I2C

def i2cdevTest():
    # device, bus = 0x51, 0
    bus = input("Please input I2C BUS num:")
    os.system('i2cdetect -y -r ' + bus)
    device = input("Please input I2C device num(Hex):")
    print("Read data from device %s on I2C bus %s" % (device, bus))
    i2c = I2C(eval("0x" + device), int(bus))
    value = i2c.read(1)
    i2c.write(value)
    print("read value=", value)
    i2c.close()

if __name__ == '__main__':
    print("Starting demo now! Press CTRL+C to exit")
    print("List of enabled I2C controllers:")
    os.system('ls /dev/i2c*')
    while True:
        i2cdevTest()

3.6. 使用SPI

旭日X3派在40Pin上物理管脚 19, 21, 23, 24引出了旭日X3芯片的 SPI2 总线,支持一个片选,IO电压3.3V。

请参阅 /app/40pin_samples/test_spi.py了解如何使用I2C的详细信息。

回环测试: 把MISO和MOSI在硬件上进行连接,然后运行spi测试程序,进行写和读操作,预期结果是读出的数据要完全等于写入的数据

硬件连接: 把MISO和MOSI通过跳线帽直接硬件上连接在一起

image-20220512101915524

回环测试过程:

  • 运行 python3 /app/40pin_samples/test_spi.py

  • 从打印的spi控制器中选择总线号和片选号作为输入选项,例如选择测试 spidev0.0,则bus numcs num都是0,按回车键确认:

List of enabled spi controllers:
/dev/spidev0.0  /dev/spidev0.1
Please input SPI bus num:0
Please input SPI cs num:0
  • 程序正确运行起来后会持续打印 0x55 0xAA,如果打印的是 0x00 0x00,那么就说明spi的回环测试失败。

Starting demo now! Press CTRL+C to exit
0x55 0xAA
0x55 0xAA

实现代码如下:

#!/usr/bin/env python3

from __future__ import print_function
import sys
import os
import time

# 导入spidev模块
import spidev

def BytesToHex(Bytes):
    return ''.join(["0x%02X " % x for x in Bytes]).strip()

def spidevTest():
    # 设置spi的bus号(0, 1, 2)和片选(0, 1)
    spi_bus = input("Please input SPI bus num:")
    spi_device = input("Please input SPI cs num:")
    # 创建spidev类的对象以访问基于spidev的Python函数。
    spi=spidev.SpiDev()
    # 打开spi总线句柄
    spi.open(int(spi_bus), int(spi_device))

    # 设置 spi 频率为 12MHz
    spi.max_speed_hz = 12000000

    print("Starting demo now! Press CTRL+C to exit")

    # 发送 [0x55, 0xAA], 接收 到的应该也是 [0x55, 0xAA]
    try:
        while True:
            resp = spi.xfer2([0x55, 0xAA])
            print(BytesToHex(resp))
            time.sleep(1)

    except KeyboardInterrupt:
        spi.close()

if __name__ == '__main__':
    print("List of enabled spi controllers:")
    os.system('ls /dev/spidev*')

    spidevTest()