0


基于树莓派4B与STM32的UART串口通信实验(代码开源)

前言:本文为手把手教学树莓派4B与 STM32 的 UART 通讯,本次项目采用树莓派4BSTM32 进行串口通讯,将彼此的数据进行互相传输。本篇博客同时提供了基于 YOLOv5-Lite 的目标检测数据联动,即将树莓派4B检测到的信息发送至 STM32,后续可以通过这些信息进行各种需求上的控制。树莓派4BSTM32 的联动是很常见的嵌入式架构体系,通常树莓派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通信追踪

六、项目代码

代码地址:基于树莓派4B与STM32的UART串口通信实验代码资源-CSDN文库

如果积分不够的朋友,点波关注,评论区留下邮箱,作者无偿提供源码和后续问题解答。求求啦关注一波吧 !!!


本文转载自: https://blog.csdn.net/black_sneak/article/details/131484958
版权归原作者 混分巨兽龙某某 所有, 如有侵权,请联系我们删除。

“基于树莓派4B与STM32的UART串口通信实验(代码开源)”的评论:

还没有评论