树莓派 4B 多串口配置_树莓派4b串口通信

0. 实验准备以及原理

0.1 实验准备

安装树莓派官方系统的树莓派 4B，有 python 环境，安装了 serial 库
杜邦线若干
屏幕或者可以使用 VNC 进入到树莓派的图形界面

0.2 原理

树莓派 4B 有 UART0（PL011）、UART1（mini UART）和 4 个 PL011 串口共计有 6 个 UART

1. 硬件串口配置

可以将硬件串口（例如 /dev/ttyAMA0）配置为普通的串口设备，以便与其他设备进行串口通信

确保树莓派的引脚上的串口功能没有被占用。默认情况下，树莓派的 GPIO 引脚会使用串口功能。可以通过编辑 /boot/config.txt 文件来禁用串口功能。在文件的末尾添加或修改以下行，保存文件后重启树莓派（可以使用vi来编辑此文件，vi 的使用可以查看这一篇文章）：

enable_uart=1
1

在终端中运行以下命令可以确认驱动是否已经加载：

ls -l /dev/ttyAMA0
1

能看到下面的输出就代表驱动是正常的

默认情况下，树莓派会将 /dev/ttyAMA0 用作终端串口，而不是普通的串口设备。可以通过编辑 /boot/cmdline.txt 文件来禁用终端串口。找到以 console=serial0 开头的行，并将其修改为 console=tty1，如下图所示

确保你的用户被添加到 dialout 组中，以便具有串口访问权限。运行以下命令将当前用户添加到 dialout 组：

sudo usermod -a -G dialout $USER
1

在添加到 dialout 组后，需要注销并重新登录才能使更改生效，到这里硬件串口就配置完成了，不需要看其他的可以直接跳到最后一节进行验证

2. 其他串口配置

2.1 展示所有串口命令

输出下面的命令可以看到所有的串口

dtoverlay -a | grep uart
1

2.2 查看特定串口信息

使用下面的命令会展示串口的配置信息

dtoverlay -h uart3
1

2.3 配置开启串口 UART2-5

在/boot/config.txt的末尾添加如下的代码，保存重启树莓派

dtoverlay=uart2
dtoverlay=uart3
dtoverlay=uart4
dtoverlay=uart5
1
2
3
4

查看是否生效

ls /dev/ttyAMA*
1

结果如下图

到这里就打开了所有的串口了

3. 验证结果

各 UART 串口与 GPIO 对应关系：

GPIO14 = TXD0 -> ttyAMA0
GPIO0  = TXD2 -> ttyAMA1
GPIO4  = TXD3 -> ttyAMA2
GPIO8  = TXD4 -> ttyAMA3
GPIO12 = TXD5 -> ttyAMA4

GPIO15 = RXD0 -> ttyAMA0
GPIO1  = RXD2 -> ttyAMA1
GPIO5  = RXD3 -> ttyAMA2
GPIO9  = RXD4 -> ttyAMA3
GPIO13 = RXD5 -> ttyAMA4
1
2
3
4
5
6
7
8
9
10
11

这里进行两个验证：UART2的自环测试，UART2和3的串口间通信，以及一个究极测试：同时打开所有的串口（包括USB转的，看看树莓派的CPU使用率有多少）

3.1 UART2的自环测试

杜邦线短接 GPIO4 和 GPIO5
编写下面的 python 程序

import serial

ser1 = serial.Serial(port='/dev/ttyAMA2',baudrate=115200)
ser1.write(b'Hello, World!\n')

data = ser1.readline()
print(data)
1
2
3
4
5
6
7

执行结果如下图

3.2 UART2和3的串口间通信

使用杜邦线按照下图的方式进行连接

GPIO4(TXD3)-------GPIO9(RXD2)
GPIO5(RXD3)-------GPIO8(TXD2)
1
2

然后编写如下的程序

import serial

ser2 = serial.Serial(port='/dev/ttyAMA2',baudrate=115200)
ser3 = serial.Serial(port='/dev/ttyAMA3',baudrate=115200)

ser2.write(b'hello ser3,I am ser2\n')
ser3.write(b'hello ser2,I am ser3\n')
line2 = ser2.readline()
line3 = ser3.readline()
print('ser2Rec:'+str(line2))
print('ser3Rec:'+str(line3))
1
2
3
4
5
6
7
8
9
10
11

结果如下图，说明串口生效，实验成功：

3.3 究极测试

同时打开 USB0、USB1 和 ttyAMA0 到 ttyAMA4 一共 7 个串口，发送数据的同时存储数据，查看一下 CPU 的使用率
我的配置为：
USB0、1 使用 UART 转 TTL 模块，使用电脑发送数据过来
ttyAMA0 作为硬件串口，然后改为的通用串口，也使用 UART 转 TTL 模块，电脑发送数据过来
ttyAMA1 和 ttyAMA4 连接
ttyAMA2 和 ttyAMA3 连接
对应的连接图可以参考上面的GPIO对照着连线
代码如下

import serial
import time
import threading
import sys
READ = 1
READTIME = 600

ser0 = serial.Serial(port='/dev/ttyAMA0',baudrate=115200)
ser1 = serial.Serial(port='/dev/ttyAMA1',baudrate=115200)
ser2 = serial.Serial(port='/dev/ttyAMA2',baudrate=115200)
ser3 = serial.Serial(port='/dev/ttyAMA3',baudrate=115200)
ser4 = serial.Serial(port='/dev/ttyAMA4',baudrate=115200)
serUSB0 = serial.Serial(port='/dev/ttyUSB0',baudrate=115200)
serUSB1 = serial.Serial(port='/dev/ttyUSB1',baudrate=115200)

def WriteSer1():
    global READ
    while(READ):
        ser1.write(b'I am ser1')
        
def WriteSer2():
    global READ
    while(READ):
        ser2.write(b'I am ser2')
        
def WriteSer3():
    global READ
    while(READ):
        ser3.write(b'I am ser3')
        
def WriteSer4():
    global READ
    while(READ):
        ser4.write(b'I am ser4')
        
def ReadSer0():
    ser0.write(bytearray([0xaa,0x0a]))
    global READ
    data0 = b''
    while(READ):
        if(ser0.in_waiting):
            data0 +=  ser0.read(ser0.in_waiting)
    f = open('ser0.bin','ab')
    f.write(data0)
    f.close()
    
def ReadSer1():
    global READ
    data1 = b''
    while(READ):
        if(ser1.in_waiting):
            data1 +=  ser1.read(ser1.in_waiting)
    f = open('ser1.bin','ab')
    f.write(data1)
    f.close()
    
def ReadSer2():
    global READ
    data2 = b''
    while(READ):
        if(ser2.in_waiting):
            data2 +=  ser2.read(ser2.in_waiting)
    f = open('ser2.bin','ab')
    f.write(data2)
    f.close()

def ReadSer3():
    global READ
    data3 = b''
    while(READ):
        if(ser3.in_waiting):
            data3 +=  ser3.read(ser3.in_waiting)
    f = open('ser3.bin','ab')
    f.write(data3)
    f.close()
    
def ReadSer4():
    global READ
    data4 = b''
    while(READ):
        if(ser4.in_waiting):
            data4 +=  ser4.read(ser4.in_waiting)
    f = open('ser4.bin','ab')
    f.write(data4)
    f.close()
    
def ReadSerUSB0():
    global READ
    dataUSB0 = b''
    while(READ):
        if(serUSB0.in_waiting):
            dataUSB0 +=  serUSB0.read(serUSB0.in_waiting)
    f = open('serUSB0.bin','ab')
    f.write(dataUSB0)
    f.close()
    
def ReadSerUSB1():
    global READ
    dataUSB1 = b''
    while(READ):
        if(serUSB1.in_waiting):
            dataUSB1 +=  serUSB1.read(serUSB1.in_waiting)
    f = open('serUSB1.bin','ab')
    f.write(dataUSB1)
    f.close()
#%%
def start():
    global READ
    timeStart = time.time()
    
    ser1Write_thread = threading.Thread(target=WriteSer1)
    ser2Write_thread = threading.Thread(target=WriteSer2)
    ser3Write_thread = threading.Thread(target=WriteSer3)
    ser4Write_thread = threading.Thread(target=WriteSer4)
    
    ser0_thread = threading.Thread(target=ReadSer0)
    ser1_thread = threading.Thread(target=ReadSer1)
    ser2_thread = threading.Thread(target=ReadSer2)
    ser3_thread = threading.Thread(target=ReadSer3)
    ser4_thread = threading.Thread(target=ReadSer4)
    serUSB0_thread = threading.Thread(target=ReadSerUSB0)
    serUSB1_thread = threading.Thread(target=ReadSerUSB1)
    
    ser1Write_thread.start()
    ser2Write_thread.start()
    ser3Write_thread.start()
    ser4Write_thread.start()
    
    ser0_thread.start()
    ser1_thread.start()
    ser2_thread.start()
    ser3_thread.start()
    ser4_thread.start()
    serUSB0_thread.start()
    serUSB1_thread.start()
    
    time.sleep(READTIME)

    READ = False

    print('test time'+str(time.time()-timeStart))
    sys.exit()
    
if __name__ == '__main__':
    start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

使用命令，来查看当前CPU的使用率

htop
1

可以发现即使跑了这么多的串口，树莓派的 CPU 使用率依旧不算很高，4 核差不多都在 40% 的利用率左右