前言：本文为手把手教学树莓派4B与 STM32 的 UART 通讯，本次项目采用树莓派4B与 STM32 进行串口通讯，将彼此的数据进行互相传输。本篇博客同时提供了基于 YOLOv5-Lite 的目标检测数据联动，即将树莓派4B检测到的信息发送至 STM32，
后续可以通过这些信息进行各种需求上的控制。树莓派4B与 STM32 的联动是很常见的嵌入式架构体系，通常树莓派4B负责计算量大的任务（例如：目标检测，激光雷达等），
STM32 则负责进行控制任务，该架构也是目前主流的智能硬件处理框架！（文末有代码开源！）
硬件实物图：
效果图：
一、树莓派4B串口
1.1 树莓派4B的Pin
树莓派4B的引脚图：
树莓派4B作为一款小型电脑，其提供了额外大量的 Pin 引脚适用于嵌入式的日常开发，本次实验我们需要需要实现树莓派4B与STM32F103C8T6之间的UART通讯！
补充说明：
树莓派4B作为上位机负责计算量大的任务（例如：目标检测，激光雷达等），STM32 则负责进行控制为主的任务。该体系框架是目前主流的人工智能嵌入式流派之一，如今多数的智能小车，智能航行器，智能机械臂都有使用该套框架！
该框架的优势：
该框架将控制任务与计算任务隔离，实现了各 CPU 的专门专精，提高了系统的稳定性（方便后期任务的扩展或者检修）。同时，STM32虽然计算能力上是远远弱于树莓派4B的，但是其GPIO的控制能力是强于树莓派的，
也就是它天生根据控制优势。所以，该框架是充分发挥了各自的专长！
树莓派4B与STM32之间常用的通讯方式：
(1)、UART，(2)、SPI，(3)、I2C（该项目使用Serial）
1.2 树莓派4B安装Serial与使用
引脚连接：
根据上图树莓派4B的 Pin 引脚图中 GPIO14(TXD) 和 GPIO15(RXD) 的两个引脚分别与 STM32F103C8T6 的 PA10(RXD) 和 PA10(RXD) 的引脚相连（交叉连接）
1.2.1 安装serial
在终端输入：sudo apt-get install serial
1.2.2 打开树莓派4B串口
在终端输入：sudo raspi-config 打开界面设置
Interfacing Options→serial→否→是
在终端输入：ls -al /dev/查看设备
1.2.3 修改串口映射关系
在终端输入：sudo nano /boot/config.txt
末行添加 dtoverlay=pi3-miniuart-bit
重启树莓派4B，之后终端输入：ls -la /dev/查看设备
1.2.4 修改配置文件
在终端输入：sudo nano /boot/cmdline.txt
修改cmdline.txt文件的内容，内容如下：
dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
二、安装minicom与树莓派4B测试
2.1 minicom安装
minicom 是 Linux/树莓派4B 平台串口调试工具，相当于 windows 上的串口调试助手，此时需要先安装 minicom；
sudo apt-get install minicom
在终端输入：minicom -D /dev/ttyAMA0
如果要退出这个minicom软件的话，先按CTRL+A再按Z就会弹出菜单，按下0回车就退出了，然后就能直接关闭了。
2.2 树莓派4B通信测试
我们使用 XCOM 串口调试助手来测试树莓派4B能否正常进行 UART 通信！
使用USB-TTL模块交叉连接树莓派4B的 UART 的引脚；
★特殊说明：USB-TTL 模块的 VCC 和 GND 一定都要与树莓派4B的相应 Pin 相连，不然可能因为电流的不平衡导致端口疯狂输出乱码！
我们在下图 minicom 红框区域输入 Hi IKUN！字样之后，可以在 XCOM 的端口处看到字符串成功发送到了 PC 端；
同理，在 XCOM 端口发送 Hi My Brother 字样之后，可以在树莓派4B的 minicom 红框区域成功接收到该信息！
当成功完成上述的操作之后，说明我们已经成功的配置好树莓派4B的UART功能！之后就可以尝试与 STM32 进行通信了（发送数据给XCOM不仅可以通过 minicom，也可以通过python等代码）！
三、树莓派4B与STM32通信
STM32 的代码其实就是简单的UART串口通讯代码，但实质上是有很多坑！！！作者发现大部分博主并没有说明出坑所在，这部分作者将会为读者朋友把可能出现的坑给解决掉！
3.1 树莓派4B代码
我们利用 Python 代码写一个循环发送数字的代码程序，具体代码如下：
import serial
import time
ser = serial.Serial('/dev/ttyAMA0',115200) # 串口初始化，根据实际情况修改串口号和波特率
# 定义要输出的数字
num = 196
while True:
ser.write(str(int(num)).encode()) # 发送数字到串口
num += 1
if num > 205:
num = 196
time.sleep(0.2) # 等待1秒钟
可以看出代码是非常简单的，但是这里读者朋友需要注意的是树莓派4B的端口发送至STM32的其实都是字符串流！在STM32端我们对发送过来的字符串流进行解码（很多博主其实都没有说明该点，导致很多朋友解码失败）！
3.2 CubeMX配置
1、RCC配置外部高速晶振（精度更高）——HSE；
2、SYS配置：Debug设置成Serial Wire（否则可能导致芯片自锁）；
3、I2C配置：
4、USART1配置：设置UART1串口；波特率：115200；开启UART串口中断；
5、时钟树配置
6、工程配置
3.3 STM32代码
3.3.1 OLED代码
OLED模块主要是方便显示树莓派4B发送给STM32的数据信息！考虑到实际情况，我们一般需要根据树莓派4B发送过来的数字信息，所以，我们这里利用OLED进行数字显示！
小数显示API函数：
//z_len为整数显示位数，f_len为小数显示位数，size2为字体大小
void OLED_Showdecimal(u8 x,u8 y,float num,u8 z_len,u8 f_len,u8 size2)
{
u8 t,temp;
u8 enshow;
int z_temp,f_temp;
z_temp=(int)num;
//整数部分
for(t=0;t<z_len;t++)
{
temp=(z_temp/oled_pow(10,z_len-t-1))%10;
if(enshow==0 && t<(z_len-1))
{
if(temp==0)
{
OLED_ShowChar(x+(size2/2)*t,y,' ',size2);
continue;
}
else
enshow=1;
}
OLED_ShowChar(x+(size2/2)*t,y,temp+'0',size2);
}
//小数点
OLED_ShowChar(x+(size2/2)*(z_len),y,'.',size2);
f_temp=(int)((num-z_temp)*(oled_pow(10,f_len)));
//小数部分
for(t=0;t<f_len;t++)
{
temp=(f_temp/oled_pow(10,f_len-t-1))%10;
OLED_ShowChar(x+(size2/2)*(t+z_len)+5,y,temp+'0',size2);
}
}
篇幅有限，OLED参考博客：http://t.csdn.cn/kydg4
3.3.2 UART代码
这部分代码是比较核心的，上述博客作者已经说明了，其实树莓派4B发送给STM32的数据都是以字符串流的格式发送来得。所以，即使发送过来的是数字数据也会变成字符，这就需要我们进行解码！
uart.h：
#ifndef __UART_H
#define __UART_H
#include "stm32f1xx_hal.h"
extern UART_HandleTypeDef huart1;
#define USART1_REC_LEN 600
extern int USART1_RX_BUF[USART1_REC_LEN];
extern uint16_t USART1_RX_STA;
extern int USART1_NewData;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
#endif
uart.c：
#include "uart.h"
#include "oled.h"
int USART1_RX_BUF[USART1_REC_LEN]; //目标数据
uint16_t USART1_RX_STA=2;
int USART1_NewData;
extern int num; //百位
extern int num2; //十位
extern int num3; //个位
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart ==&huart1)
{
USART1_RX_BUF[USART1_RX_STA&0X7FFF]=USART1_NewData;
USART1_RX_STA++;
if(USART1_RX_STA>(USART1_REC_LEN-1))USART1_RX_STA=0;
//num = USART1_RX_BUF[USART1_RX_STA];
HAL_UART_Receive_IT(&huart1,(uint8_t *)&USART1_NewData,1);
num = USART1_RX_BUF[USART1_RX_STA-1];
num2 = USART1_RX_BUF[USART1_RX_STA-2];
num3 = USART1_RX_BUF[USART1_RX_STA-3];
}
}
上述UART代码，利用 UART 中断函数进行读取 USART1_NewData 的数值，因为我们最大传输的数字为3位数，所以我们分别读取缓存数组中最近的 3 个字节数据（树莓派4B发送过来的是字符串，也就是被转换成了对应数字的ASCII数值，
例如：发送过来100，则STM32端接收到的为49 49 48 这3个字节）。
3.3.3 数据解码代码
control.c：
#include "control.h"
#include "uart.h"
#include "tim.h"
#include "oled.h"
int num;
int num2;
int num3;
int value;
int flag;
int last;
void TargetTracking()
{
flag = USART1_RX_STA – last;
last = USART1_RX_STA;
value = (num3-48) * 100 + (num2-48) * 10 + (num-48) * 1;
OLED_ShowStr(10,2,"Object Center",2);
OLED_Showdecimal(45,4,value,3,1,16);
if(flag == 2)
{
value = (num2-48) * 10 + (num-48) * 1;
OLED_Showdecimal(40,4,value,3,1,16);
}
}
这里默认都是 3 位数，所以之间按照 UART 数据传输高低位的数据将数据-48变为实际的数字，在×对应的比例即可得到实际值！flag 则是通过 USART1_RX_STA 变量的变化值判断一次传输过来几个字节的数据，可以判断是几位数！
读者朋友可以根据自己实际情况更改上述代码为己所用！
代码运行之后：
四、高级应用
智能小车的目标追踪
树莓派4B通常会出现在基于视觉技术进行规定目标的追踪，这个时候往往需要树莓派4B读取到目标框数据，然后发送给STM32下位机，之后STM32根据这些目标框信息来进行逻辑上的控制。
作者这里以上一篇博客的网络模型检测结果为例，代码如下：
import cv2
import numpy as np
import onnxruntime as ort
import serial
import time
ser = serial.Serial('/dev/ttyAMA0',115200)
def plot_one_box(x, img, color=None, label=None, line_thickness=None):
"""
description: Plots one bounding box on image img,
this function comes from YoLov5 project.
param:
x: a box likes [x1,y1,x2,y2]
img: a opencv image object
color: color to draw rectangle, such as (0,255,0)
label: str
line_thickness: int
return:
no return
"""
tl = (
line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1
) # line/font thickness
color = color or [random.randint(0, 255) for _ in range(3)]
c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
ser.write(str(int((int(x[2])-int(x[0]))/2+int(x[0]))).encode())
print(int((int(x[2])-int(x[0]))/2+int(x[0])))
cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
if label:
tf = max(tl – 1, 1) # font thickness
t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
c2 = c1[0] + t_size[0], c1[1] – t_size[1] – 3
cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA) # filled
cv2.putText(
img,
label,
(c1[0], c1[1] – 2),
0,
tl / 3,
[225, 255, 255],
thickness=tf,
lineType=cv2.LINE_AA,
)
def _make_grid( nx, ny):
xv, yv = np.meshgrid(np.arange(ny), np.arange(nx))
return np.stack((xv, yv), 2).reshape((-1, 2)).astype(np.float32)
def cal_outputs(outs,nl,na,model_w,model_h,anchor_grid,stride):
row_ind = 0
grid = [np.zeros(1)] * nl
for i in range(nl):
h, w = int(model_w/ stride[i]), int(model_h / stride[i])
length = int(na * h * w)
if grid[i].shape[2:4] != (h, w):
grid[i] = _make_grid(w, h)
outs[row_ind:row_ind + length, 0:2] = (outs[row_ind:row_ind + length, 0:2] * 2. – 0.5 + np.tile(
grid[i], (na, 1))) * int(stride[i])
outs[row_ind:row_ind + length, 2:4] = (outs[row_ind:row_ind + length, 2:4] * 2) ** 2 * np.repeat(
anchor_grid[i], h * w, axis=0)
row_ind += length
return outs
def post_process_opencv(outputs,model_h,model_w,img_h,img_w,thred_nms,thred_cond):
conf = outputs[:,4].tolist()
c_x = outputs[:,0]/model_w*img_w
c_y = outputs[:,1]/model_h*img_h
w = outputs[:,2]/model_w*img_w
h = outputs[:,3]/model_h*img_h
p_cls = outputs[:,5:]
if len(p_cls.shape)==1:
p_cls = np.expand_dims(p_cls,1)
cls_id = np.argmax(p_cls,axis=1)
p_x1 = np.expand_dims(c_x-w/2,-1)
p_y1 = np.expand_dims(c_y-h/2,-1)
p_x2 = np.expand_dims(c_x+w/2,-1)
p_y2 = np.expand_dims(c_y+h/2,-1)
areas = np.concatenate((p_x1,p_y1,p_x2,p_y2),axis=-1)
areas = areas.tolist()
ids = cv2.dnn.NMSBoxes(areas,conf,thred_cond,thred_nms)
if len(ids)>0:
return np.array(areas)[ids],np.array(conf)[ids],cls_id[ids]
else:
return [],[],[]
def infer_img(img0,net,model_h,model_w,nl,na,stride,anchor_grid,thred_nms=0.4,thred_cond=0.5):
# 图像预处理
img = cv2.resize(img0, [model_w,model_h], interpolation=cv2.INTER_AREA)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = img.astype(np.float32) / 255.0
blob = np.expand_dims(np.transpose(img, (2, 0, 1)), axis=0)
# 模型推理
outs = net.run(None, {net.get_inputs()[0].name: blob})[0].squeeze(axis=0)
# 输出坐标矫正
outs = cal_outputs(outs,nl,na,model_w,model_h,anchor_grid,stride)
# 检测框计算
img_h,img_w,_ = np.shape(img0)
boxes,confs,ids = post_process_opencv(outs,model_h,model_w,img_h,img_w,thred_nms,thred_cond)
return boxes,confs,ids
if __name__ == "__main__":
# 模型加载
model_pb_path = "best.onnx"
so = ort.SessionOptions()
net = ort.InferenceSession(model_pb_path, so)
# 标签字典
dic_labels= {0:'drug',
1:'glue',
2:'prime'}
# 模型参数
model_h = 320
model_w = 320
nl = 3
na = 3
stride=[8.,16.,32.]
anchors = [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]]
anchor_grid = np.asarray(anchors, dtype=np.float32).reshape(nl, -1, 2)
video = 0
cap = cv2.VideoCapture(video)
flag_det = False
while True:
success, img0 = cap.read()
if success:
if flag_det:
t1 = time.time()
det_boxes,scores,ids = infer_img(img0,net,model_h,model_w,nl,na,stride,anchor_grid,thred_nms=0.4,thred_cond=0.5)
t2 = time.time()
for box,score,id in zip(det_boxes,scores,ids):
label = '%s:%.2f'%(dic_labels[id],score)
plot_one_box(box.astype(np.int16), img0, color=(255,0,0), label=label, line_thickness=None)
str_FPS = "FPS: %.2f"%(1./(t2-t1))
cv2.putText(img0,str_FPS,(50,50),cv2.FONT_HERSHEY_COMPLEX,1,(0,255,0),3)
cv2.imshow("video",img0)
key=cv2.waitKey(1) & 0xFF
if key == ord('q'):
break
elif key & 0xFF == ord('s'):
flag_det = not flag_det
print(flag_det)
cap.release()
作者上述代码仅以目标物体中心的 x 轴坐标为例，控制机理是这样的：当 x 数值大于320（图片为640×640）时候控制小车向便宜右偏移，反之则向左偏移。目标框的w，h则可以根据实际情况设置阈值，
控制小车的前进速度。当目标框的宽度 w 太小时候，加速小车前进，反之则减速！
作者有话：
目前的 YOLOv-Lite 网络模型的 FPS 还是太低了，在该 FPS 下去进行目标追踪的控制是非常困难的。此外，实际情况下搭载在小车亦或是航行器的 Camera 在拍摄过程中避免不了强烈的高斯白噪，需要加卡尔曼滤波进行优化目标框信息！
所以，后续作者将推出可以基于视觉追踪实战的网络模型和目标追踪代码，感兴趣的读者朋友可以期待一下！
五、项目效果
基于树莓派4B与STM32通信追踪
————————————————
版权声明：本文为CSDN博主「混分巨兽龙某某」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/black_sneak/article/details/131484958