Python控制硬件：Arduino串口通信与树莓派GPIO实操指南

1. 为什么人人都说“用Python玩硬件”，到底怎么玩

先把这个事情说清楚。很多人一看到“Python控制Arduino或树莓派”这个标题，脑子里是懵的：Arduino本身用C/C++写程序，树莓派装的是Linux系统，Python跟这俩到底什么关系？我当年入坑的时候也绕了不少弯子，这里直接给你捋明白。

核心就一句话：Python不是直接跑在Arduino上（至少现在主流的Arduino Uno跑不了完整的Python解释器），Python是在你的电脑上、或者树莓派上，通过串口、网络或者GPIO去控制这些硬件。

所以这个标题实际上包含了两条完全不同的技术路线：

• 路线A：电脑上的Python + Arduino开发板。Python通过USB串口和Arduino通信，Arduino负责执行底层硬件动作（点灯、读传感器、转舵机），Python负责上层逻辑（数据处理、算法决策、界面展示）。
• 路线B：树莓派上的Python直接操作GPIO。树莓派本身就是一台小电脑，跑完整Linux，Python直接读引脚、写引脚，不需要中间再挂一个单片机。

这两条路线解决的问题不同，适用场景也不同，但核心诉求是一样的：用Python这套舒服的语法和生态，去驱动原本需要底层C语言才能操作的硬件。适合谁？想学硬件但不想啃C语言的新手，做物联网原型验证的工程师，搞机器人、智能小车、自动化项目的爱好者，以及任何想把“程序跑起来”和“硬件动起来”连在一起的人。

我接下来的内容，会先把两个平台的选择逻辑讲清楚，然后分别给出两条路线从0到1的完整实操步骤，最后把我踩过的坑全部抖出来。你要做智能小车、舵机控制、传感器采集，这篇内容都能直接抄作业。

2. 先想明白：你该用Arduino还是树莓派

2.1 两个平台的本质区别

选平台之前，必须搞清楚一个关键点：Arduino是单片机，树莓派是Linux电脑。这不是一个量级的东西，使用方式完全不同。

Arduino Uno这种板子，本质上是一个带CPU、内存和输入输出引脚的微型控制器。它不跑操作系统，程序被编译成二进制烧进去，上电就一遍遍地循环执行。它的优势在于：便宜（几十块钱）、实时性强、功耗极低、引脚可以直接输出PWM波形、稳定性极高。但缺点也很明显：没有操作系统、不能跑Python（至少Uno型号不行）、内存以KB计、做不了复杂计算。

树莓派则是一台完整的ARM架构Linux主机。它可以跑Python解释器，可以装numpy、opencv这种重量级库，可以连接摄像头做图像识别，甚至可以接显示器当桌面电脑用。但它是“准实时”的，因为有Linux系统的调度，GPIO翻转的时序抖动比Arduino大，而且功耗和成本都高一个数量级。

我列个表，方便你选型对照：

2.2 什么时候用“Python + Arduino”

如果你做的是纯硬件控制型项目，比如智能小车、舵机云台、温湿度采集、步进电机控制，请优先考虑Arduino，然后用Python在上位机做控制和数据处理。

我见过太多人犯这个错误：明明只需要让舵机转到指定角度、让小车走个PID巡线，非要用树莓派。结果树莓派启动要30秒，GPIO输出PWM还要靠软件模拟，实时性一塌糊涂，最后项目又臭又长。这种活儿，Arduino干得又稳又便宜，实时性是它的看家本领。

但为什么还要用Python？因为Arduino的C语言写复杂逻辑太痛苦了。比如你要做一个小车，Arduino负责底层电机PID控制和传感器读取，但路径规划、视觉识别、人机交互这些算法放在Arduino上根本跑不动。这时候Python在上位机（电脑或树莓派）负责“大脑”，Arduino负责“手脚”，通过串口协议握手通信，这是最经典的分工。

2.3 什么时候直接用“树莓派 + Python”

如果你的项目核心是计算密集或者依赖Linux生态，直接用树莓派。典型场景包括：摄像头图像识别（需要装OpenCV）、Web控制界面（需要跑Flask/Django）、MQTT物联网网关、语音识别、大数据量的传感器记录和分析。

树莓派对Python的支持是原生的，这一点太爽了。你直接在树莓派上pip install装库，用gpiozero或RPi.GPIO读写引脚，代码风格跟写普通Python程序一模一样。树莓派5的GPIO引脚定义网上资料很多，但核心注意点是：树莓派的GPIO电平是3.3V，不是Arduino的5V，接错会烧板子。这个细节后面实操部分展开讲。

我的建议是：别纠结“哪个更好”，而是看你手里项目的主要矛盾在哪个方向。如果主要是硬件控制，选Arduino；如果主要是软件计算，选树莓派；如果两者兼有，就做串口联动。这也是工程师最常用的方案。

3. 路线A实操：用Python通过串口控制Arduino

3.1 通信原理：Python和Arduino怎么“对话”

Python和Arduino之间最通用可靠的通信方式就是串口（UART over USB）。Arduino开发板上的USB口，内部通过USB转串口芯片（Uno上是CH340或ATmega16U2），把你的USB数据变成了串口数据。Arduino的Serial库负责收发，Python用pyserial库收发，两边通过相同的波特率（baud rate）对上暗号，就能通信了。

一句话类比：串口就像两个人用一台对讲机通话，双方必须先约定好同一个频率（波特率），说话时按下一个键（发送），说完松开（关闭）。如果频率对不上，听到的全是电流杂音（乱码）。

通信协议设计是这个环节的命门。我强烈建议你在项目一开始就定义好协议格式，别图省事先随便发字符串。最简单的协议是以换行符\n结尾的ASCII文本，比如"SERVO:90\n"表示设置舵机到90度，"LED:ON\n"表示开灯。这样Arduino收到一行就解析一行，Python发送时也在字符串末尾加\n。优点是直观、好调试，用串口监视器一眼能看懂。缺点是效率低，但控制类项目完全够用。

如果你的项目数据量大、需要做二进制协议（比如传输图片、浮点数组），那就另说。但初学者从文本行协议入手绝对是最稳的路径。我在自己的智能小车项目里就是用文本协议，几十个命令下来，代码清爽，排查问题也快。

3.2 Arduino端程序设计：接收、解析、执行

Arduino端的代码逻辑非常简单清晰：setup()里初始化串口，loop()里循环读串口，有数据就解析执行。下面是完整的舵机控制示例，用的标准库Servo.h：

// Arduino 端代码：通过串口接收指令控制舵机 #include <Servo.h> Servo myservo; int servoPin = 9; // 舵机信号线接 9 号引脚 int pos = 0; void setup() { Serial.begin(9600); // 和 Python 端波特率保持一致 myservo.attach(servoPin); Serial.println("READY"); // 上电后向上位机报告状态 } void loop() { if (Serial.available() > 0) { String cmd = Serial.readStringUntil('\n'); // 读一行，以换行符结尾 cmd.trim(); // 去掉多余回车和空格 if (cmd.startsWith("SERVO:")) { // 解析 SERVO:90 这种格式，提取角度值 String valueStr = cmd.substring(6); // 从索引6开始截取 int angle = valueStr.toInt(); // 限制角度范围，保护舵机 angle = constrain(angle, 0, 180); myservo.write(angle); Serial.println("OK:ANGLE=" + String(angle)); } else if (cmd == "LED:ON") { digitalWrite(LED_BUILTIN, HIGH); Serial.println("OK:LED_ON"); } else if (cmd == "LED:OFF") { digitalWrite(LED_BUILTIN, LOW); Serial.println("OK:LED_OFF"); } else { Serial.println("ERR:UNKNOWN_CMD"); } } }

这里有几个关键点要特别解释一下。readStringUntil('\n')会一直阻塞等待，直到收到换行符才返回，这保证了一次读取一整条指令，不会出现半条指令的问题。trim()的作用是去掉Windows系统发过来的\r回车符，否则解析会出错，这个坑我当年踩得真够呛。startsWith和substring(6)是字符串解析的常用组合，虽然性能一般，但可读性极高，初学者一眼就能懂。

Arduino端写完这段代码，直接用Arduino IDE编译上传。上传成功后打开IDE自带的串口监视器，波特率选9600，手动输入SERVO:90发送，如果舵机转到了90度，说明Arduino端工作正常，下面就可以接Python了。

3.3 Python端实现：用pyserial发送指令和读取反馈

Python端的事情就两件：往串口发指令、从串口读反馈。核心库是pyserial，安装方式：

pip install pyserial

然后写一个简单的控制脚本，先做连通性测试再说其他：

# Python 端代码：通过串口控制 Arduino 舵机并读取反馈 import serial import time def open_serial(port: str, baudrate: int = 9600, timeout: float = 1.0): """打开串口，自动处理常见异常""" try: ser = serial.Serial( port=port, baudrate=baudrate, timeout=timeout, # 读超时，避免卡死 write_timeout=1.0 ) time.sleep(2) # 等待 Arduino 重置完成，这是关键！ # 清空缓冲区，把 Arduino 上电时打印的乱序信息清掉 ser.reset_input_buffer() print(f"[OK] 串口 {port} 打开成功") return ser except serial.SerialException as e: print(f"[ERR] 无法打开串口 {port}，请检查是否被占用或设备是否连接") raise e def send_command(ser, cmd: str, wait_response: bool = True): """发送指令并等待 Arduino 反馈""" # 拼上换行符，按文本协议发送 ser.write((cmd + "\n").encode('utf-8')) if wait_response: # 读取一行反馈，decode 时去掉结尾的换行和回车 resp = ser.readline().decode('utf-8', errors='ignore').strip() return resp return None if __name__ == "__main__": # Windows 上写 COM3，Linux/macOS 上写 /dev/ttyUSB0 或 /dev/ttyACM0 ser = open_serial("COM3") # 先测试舵机控制 for angle in [0, 45, 90, 135, 180]: resp = send_command(ser, f"SERVO:{angle}") print(f"发送 SERVO:{angle} -> 反馈: {resp}") time.sleep(1) # 测试LED开关 print(send_command(ser, "LED:ON")) time.sleep(1) print(send_command(ser, "LED:OFF")) ser.close()

这里有几个细节值得多说两句。time.sleep(2)这个等待很重要，因为Arduino开发板每次打开串口连接都会自动复位重启（这是Arduino的一个特性，跟板载串口芯片的DTR信号有关），重启期间程序不会执行，如果你立刻发指令，数据就丢了。等两秒让它稳定运行再通信，是无数人用血泪换来的经验。reset_input_buffer()会把Arduino重启过程中打印的无关信息（比如咱们代码里那句READY，但实际上可能出现在任意时机）清掉，确保后面每一条反馈都对应你发的指令。

write_timeout参数也别忘了加，否则当串口出现阻塞时，write()会无限等待，把程序卡死。这种卡死问题排查起来特别隐蔽，我是吃过亏的。encode('utf-8')是把Python字符串转成字节流，decode时用errors='ignore'处理偶尔的乱码字节，可以避免程序因为一个非UTF-8字节而崩溃。

这段代码输出长这样：

[OK] 串口 COM3 打开成功 发送 SERVO:0 -> 反馈: OK:ANGLE=0 发送 SERVO:45 -> 反馈: OK:ANGLE=45 发送 SERVO:90 -> 反馈: OK:ANGLE=90 发送 SERVO:135 -> 反馈: OK:ANGLE=135 发送 SERVO:180 -> 反馈: OK:ANGLE=180 发送 LED:ON -> 反馈: OK:LED_ON 发送 LED:OFF -> 反馈: OK:LED_OFF

能跑到这个效果，你已经在“用Python控制Arduino”这条路上走通了。这个基础框架可以无限扩展：加传感器就是Serial.println(sensorValue)让Python读，加多个电机就是定义MOTOR:LEFT:150这类协议，加PID控制就是在Python端计算好轮速再发下去执行。

3.4 进阶：Python定时采集Arduino传感器数据

舵机控制是“Python发指令、Arduino执行”，传感器采集则是反过来“Arduino上报数据、Python接收处理”。这两种模式往往在一个项目里同时出现。下面这个例子演示Arduino每隔100毫秒读取一个模拟引脚，并通过串口发送给Python，Python负责实时绘图记录。

Arduino端代码（模拟引脚A0读取）：

void setup() { Serial.begin(9600); } void loop() { int sensorValue = analogRead(A0); // 读取A0引脚，范围0-1023 Serial.print("SENSOR:"); Serial.println(sensorValue); delay(100); // 每100ms上报一次 }

Python端接收并绘图：

# 需要安装 matplotlib：pip install matplotlib import serial import matplotlib.pyplot as plt import matplotlib.animation as animation ser = serial.Serial("COM3", 9600, timeout=1) all_data = [] def update(frame): global all_data try: line = ser.readline().decode('utf-8', errors='ignore').strip() if line.startswith("SENSOR:"): value = float(line.split(":")[1]) all_data.append(value) # 只保留最近200个点 if len(all_data) > 200: all_data.pop(0) except Exception as e: print(f"读取异常: {e}") plt.cla() # 清空当前坐标轴 plt.plot(all_data) plt.ylim(0, 1023) plt.xlabel("Sample") plt.ylabel("ADC Value") ani = animation.FuncAnimation(plt.figure(), update, interval=100) plt.show()

这个例子的核心意义在于告诉你：Python控制硬件不只是“发指令”，更重要的是把硬件变成数据源，让Python做数据分析或者可视化。很多传感器项目都可以套用这个模式：温度曲线、光照强度、PM2.5数据、电机电流监测，统统是这个框架。

4. 路线B实操：用Python直接在树莓派上控制GPIO

4.1 树莓派GPIO基础和库选型

树莓派跑着完整的Linux系统，所以“控制”的方式和Arduino完全不同。不需要中间通信，Python直接操作硬件引脚。这相当于把控制逻辑和数据采集都放在同一个程序里，方便快捷，但也要注意Linux系统的非实时性问题。

树莓派端最常用的两个Python库：

• RPi.GPIO：老牌库，文档丰富，很多教程都基于它。但需要sudo权限运行，而且官方维护状态一般。
• gpiozero：官方推荐的库，设计更现代，API更友好，不需要sudo（或者仅对某些功能需要，视系统版本而定），内置了大量设备类，比如LED、Button、Servo、Motor，开箱即用。

我的建议是：新项目优先用gpiozero，代码更简洁，坑更少。但有时候查资料会遇到RPi.GPIO的例子，所以两个都要知道怎么用。树莓派5的GPIO引脚定义和4B不一样了，网上经常见到“树莓派5引脚图”的搜索，但核心接口保持不变（40针排针），大部分库在5代上也能用，只是部分PWM硬件能力有调整，选型时要留意。

下面这个例子是树莓派上点LED灯，用gpiozero写：

# 在树莓派上先安装库 sudo apt update sudo apt install python3-gpiozero python3-pip -y pip install gpiozero

# LED闪烁：树莓派上直接运行 from gpiozero import LED import time # GPIO17是BCM编号方式，对应物理排针的第11脚 led = LED(17) try: while True: led.on() time.sleep(1) led.off() time.sleep(1) except KeyboardInterrupt: pass finally: led.close() # 释放GPIO资源

跑这个程序前，记得把LED接到树莓派引脚上：LED阳极（长脚）通过220欧姆电阻接到GPIO17，阴极（短脚）接GND（物理引脚第6脚）。不接限流电阻直接烧LED或者伤引脚，这是新手最常见的操作事故。

gpiozero读按钮输入也一样简单：

from gpiozero import Button, LED import time # 按钮接GPIO18，LED接GPIO17作为提示灯 button = Button(18, pull_up=True) # 启用内部上拉电阻 led = LED(17) def on_press(): print("按钮被按下") led.on() def on_release(): print("按钮释放") led.off() button.when_pressed = on_press button.when_released = on_release # 保持程序运行 time.sleep(60)

看到了吗？gpiozero把事件回调都封装好了，代码直观得可怕。这里面有个重要的物理细节：树莓派GPIO内部有上拉/下拉电阻可以启用，push按钮的一边接GPIO，另一边接GND，启用内部上拉后，按下时引脚读到低电平，释放时读到高电平。如果你不启用内部上拉，悬空的引脚会读到随机电平，按钮表现就跟神经病一样。这个坑在Arduino里也一样存在，只不过Arduino的引脚上拉电阻默认不能软件配置，需要在pinMode()旁边设置INPUT_PULLUP。

4.2 树莓派上用Python控制PWM舵机

树莓派控制舵机，本质上需要产生50Hz的PWM信号，通过改变脉冲宽度控制舵机角度。这一点，树莓派做得不如Arduino简单，因为普通GPIO没有专用的硬件PWM，要靠软件模拟。gpiozero对舵机的封装还算友好，但校准参数必须手动拿到，否则舵机要么颤抖要么转不动。

from gpiozero import Servo import time # 舵机信号线接GPIO18 servo = Servo(18, min_pulse_width=0.5/1000, max_pulse_width=2.5/1000) # Servo类中 -1 对应0度，0对应90度，1对应180度 for angle in [-1, -0.5, 0, 0.5, 1]: servo.value = angle time.sleep(1) servo.detach() # 释放引脚，停止输出PWM

注意min_pulse_width和max_pulse_width这两个参数。不同的舵机厂商，对“0度”“180度”对应的脉宽定义不一样。普通SG90舵机一般是0.5ms对应0度、2.5ms对应180度，但有的舵机要0.6ms到2.4ms。如果你发现舵机转到极限位置时嗡嗡响、抖动，那就是脉宽范围标定得不合适，需要微调这两个值。这个校准过程，Arduino的Servo.write(angle)会自动做好，树莓派却要自己手动来，也是很多人觉得“树莓派控制舵机麻烦”的原因。

4.3 树莓派上跑Python控制整套智能小车

树莓派做智能小车的典型架构是：Python程序控制电机驱动板（比如L298N或者TB6612），同时利用树莓派的算力跑摄像头识别或PID算法。和Arduino小车相比，树莓派小车的优势在于可以跑OpenCV做视觉巡线，这对纯Arduino来说基本是天方夜谭。

from gpiozero import Motor import time import cv2 import numpy as np # 电机A接GPIO17和GPIO18，电机B接GPIO27和GPIO22 motor_left = Motor(forward=17, backward=18) motor_right = Motor(forward=27, backward=22) def stop_car(): motor_left.stop() motor_right.stop() def forward(speed=0.3): motor_left.forward(speed) motor_right.forward(speed) def turn_left(speed=0.3): motor_left.backward(speed * 0.8) motor_right.forward(speed) def turn_right(speed=0.3): motor_left.forward(speed) motor_right.backward(speed * 0.8) # 简单测试 try: forward(0.3) time.sleep(2) turn_left(0.3) time.sleep(1) turn_right(0.3) time.sleep(1) stop_car() except KeyboardInterrupt: stop_car()

实际做小车时，要注意Motor类的forward()和backward()的参数是0到1之间的浮点数，代表PWM占空比。两个电机的性能不可能完全一致，同样的占空比，轮子转速会有一点差异，小车会跑偏，这是机械和电子都逃不过的事实。解决办法是通过实测给每侧做一个“校正系数”：把左电机速度乘以一个0.9~1.1之间的系数对齐。这种细节，只有动手跑过才会懂。

5. 常见问题与排查技巧实录

这部分是我最想写的，因为上面那些代码网上遍地都是，但真正让你卡住一整天的问题，往往就是这么几个。

5.1 串口问题

“SerialException: could not open port”：这个提示基本说明端口被占用或者设备没连上。在Windows下，Arduino IDE如果开着串口监视器，Python就打不开同一个COM口。先关掉IDE再来。Linux下最常见的是权限问题，运行sudo usermod -a -G dialout $USER把你的用户加入dialout组，然后注销重新登录。另外Linux上设备名不是固定的，今天/dev/ttyUSB0，明天可能变成/dev/ttyUSB1，写个ls /dev/ttyUSB*或dmesg | tail -20看一下最新接入的是哪个。

发送数据全是乱码：百分之九十九是波特率不一致。Arduino端9600，Python端也得9600。还有一个坑是三方USB转串口芯片的时钟误差，如果你用的是CH340，偶尔的乱码可能源于芯片本身，换更高精度的线或者降低波特率能缓解。

Arduino一直收不到我的指令，但串口监视器发可以收到：检查你Python写入的字节序列。很多人写了ser.write("LED:ON")，这是错的，write()需要字节而不是字符串，必须ser.write("LED:ON".encode())，而且文本协议要有结尾符，否则Arduino的readStringUntil('\n')会一直等下去。

5.2 树莓派GPIO问题

“RuntimeError: Please check permissions”：RPi.GPIO需要root权限，你需要在命令前加sudo python3 xxx.py。gpiozero在部分系统上不需要，但如果你设置了系统权限，也可能遇到类似问题，解决办法是gpio readall检查权限。

“Only factory default pin state is available”：这个错误是RPi.GPIO在Python重运行setmode(GPIO.BCM)时发现GPIO还在占用中。原因是你上次运行的程序没有释放硬件资源。写代码时务必加try/finally和GPIO.cleanup()，或者用gpiozero的close()。否则脚本崩溃后，下次再运行就会报这个错，很多人第一次遇到都莫名其妙。

GPIO编号方式混乱导致控制错引脚：树莓派的GPIO有两种编号方式：BCM编号（比如GPIO17）和物理引脚编号（比如第11脚）。你在树莓派上看到“GPIO17”时，它在物理排针上的位置其实是第11脚。网上教程混用这两种编号，你要是没搞清楚，照着别人的代码直接接，灯就是不亮。建议所有新代码统一用BCM编号，查找引脚对照表时看下图：

物理引脚编号是固定的（1~40），BCM编号是芯片定义的（GPIO0~GPIO27），两者不是顺序对应关系。比如BCM GPIO2对应物理第3脚，BCM GPIO3对应物理第5脚。接线前先查对照表，别想当然。

舵机抖动或者无力：树莓派的3.3V GPIO驱动能力有限，舵机工作电流较大，不能直接从GPIO取电。舵机电源要外接5V稳压电源，GND要跟树莓派共地，GPIO只接信号线。不共地或者供电不足，舵机就会出现抖动、异响、转不到位。这跟Arduino用5V给舵机供电是一个道理，电力设计是硬件项目最容易翻车的一环。

5.3 平台选型时的错误认知

用树莓派去做需要精确时序的波形采集，比如读取红外遥控信号、模拟DS18B20的单总线时序。Linux系统的调度会让你的GPIO切换抖动几十毫秒，这在逻辑上就是不可接受的。这种活儿老老实实用Arduino或者专门选支持硬件PWM的MCU来做。

用Arduino去跑视觉识别和机器学习推理，那是真不信邪。Arduino的内存都不够装一个OpenCV的分支。如果你要“识别到某个物体后让电机转”，正确方案是：树莓派跑OpenCV识别，算完结果后通过串口或GPIO把“控制信号”发给Arduino，Arduino去转电机。分工明确，各干各擅长的。

不要在Arduino上折腾MicroPython，除非你有非常明确的需求。MicroPython本质上是一个解释器在MCU上跑，它的实时性比原生C差很多，资源占用也大。我见过一些人想在Arduino上“跑Python”，走入这个误区，折腾半天最后发现性能和稳定都不如直接用C写。真有硬需求想跑Python的MCU，直接选ESP32或树莓派Pico这类支持MicroPython的硬件，别在Uno上硬掰。

6. 我的实操体会和一个小建议

项目做多了之后，我最大的感触是：“用Python控制Arduino或树莓派”这个题目的关键不在Python，也不在硬件，而在通信协议和模块边界的设计。

你要始终想清楚一件事：每个模块该干什么？Arduino小车的程序如果写得像面条一样，把控制逻辑和通信解析混在一起，后期加功能就是灾难。我的习惯是，把Arduino代码按“解析指令 → 执行动作 → 反馈状态”三段分离，Python端按“发指令 → 解析反馈 → 数据处理”三段分离。两边各占一层，中间用协议连接，任何一端出问题，替换掉另一边不影响。

最后分享一个小技巧，是我调串口通信时最常用的：不要一开始就写完整业务逻辑，先做一个“回环测试”。Arduino收到什么命令，原样返回什么，也就是echo模式。Python发"PING"，Arduino回"PONG"。两端能稳定收发100个包，说明物理链路是好的，再往上叠加业务逻辑。这样出了bug，你才知道问题出在传输层还是应用层，能省掉大量排查时间。

这些内容，你拿去做一个Python + Arduino的智能小车、Python读取传感器数据并绘图、或者树莓派的远程控制类项目，都已经铺好了路。剩下的就是动手接线、跑代码，遇到问题时回来翻翻这几个常见坑，很多坎就能直接跨过去了。