OpenMV与STM32之间的通讯（附源码）

本篇文章旨在记载我电赛期间使用openmv和stm32单片机之间举行串口通讯，将openmv辨认到的坐标传输给单片机。配景是基于2023年天下大门生电子筹划大赛E题：舵机云台追踪辨认。

单片机的串口通讯原理我便不再详细讲解，下面直接上代码分析。
值得注意的是接线：RX——>TX
                                 TX——>RX
                                 单片机和OPENMV必须共地
非常重要！！！！
一、串口通讯传输两个数据（x坐标和y坐标） 

（一）、 OPENMV串口通讯部分

1. import sensor, image, time,math,pyb
2. from pyb import UART,LED
3. import json
4. import ustruct
6. sensor.reset()
7. sensor.set_pixformat(sensor.RGB565)
8. sensor.set_framesize(sensor.QVGA)
9. sensor.skip_frames(time = 2000)
10. sensor.set_auto_gain(False) # must be turned off for color tracking
11. sensor.set_auto_whitebal(False) # must be turned off for color tracking
12. red_threshold_01=(10, 100, 127, 32, -43, 67)
13. clock = time.clock()
15. uart = UART(3,115200)   #定义串口3变量
16. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
18. def find_max(blobs):    #定义寻找色块面积最大的函数
19.     max_size=0
20.     for blob in blobs:
21.         if blob.pixels() > max_size:
22.             max_blob=blob
23.             max_size = blob.pixels()
24.     return max_blob
27. def sending_data(cx,cy,cw,ch):
28.     global uart;
29.     #frame=[0x2C,18,cx%0xff,int(cx/0xff),cy%0xff,int(cy/0xff),0x5B];
30.     #data = bytearray(frame)
31.     data = ustruct.pack("<bbhhhhb",      #格式为俩个字符俩个短整型(2字节)
32.                    0x2C,                      #帧头1
33.                    0x12,                      #帧头2
34.                    int(cx), # up sample by 4   #数据1
35.                    int(cy), # up sample by 4    #数据2
36.                    int(cw), # up sample by 4    #数据1
37.                    int(ch), # up sample by 4    #数据2
38.                    0x5B)
39.     uart.write(data);   #必须要传入一个字节数组
42. while(True):
43.     clock.tick()
44.     img = sensor.snapshot()
45.     blobs = img.find_blobs([red_threshold_01])
46.     max_b = find_max(blobs)
47.     cx=0;cy=0;
48.     if blobs:
49.             #如果找到了目标颜色
50.             cx=max_b[5]
51.             cy=max_b[6]
52.             cw=max_b[2]
53.             ch=max_b[3]
54.             img.draw_rectangle(max_b[0:4]) # rect
55.             img.draw_cross(max_b[5], max_b[6]) # cx, cy
56.             FH = bytearray([0x2C,0x12,cx,cy,cw,ch,0x5B])
57.             #sending_data(cx,cy,cw,ch)
58.             uart.write(FH)
59.             print(cx,cy,cw,ch)

复制代码

注意观察下图标注的部分，我不做详细讲解，但是很容易明确： 

接下来请看STM32串口通讯部分的代码：

1. #include "uart.h"
2. #include "oled.h"
3. #include "stdio.h"
5. static u8 Cx=0,Cy=0,Cw=0,Ch=0;
7. void USART1_Init(void)
8. {
9.         //USART1_TX:PA 9   
10.         //USART1_RX:PA10
11.         GPIO_InitTypeDef GPIO_InitStructure;     //串口端口配置结构体变量
12.         USART_InitTypeDef USART_InitStructure;   //串口参数配置结构体变量
13.         NVIC_InitTypeDef NVIC_InitStructure;     //串口中断配置结构体变量
15.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);       
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);   //打开PA端口时钟
18.     //USART1_TX   PA9
19.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                           //PA9
20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                   //设定IO口的输出速度为50MHz
21.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                            //复用推挽输出
22.     GPIO_Init(GPIOA, &GPIO_InitStructure);                               //初始化PA9
23.     //USART1_RX          PA10
24.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;             //PA10
25.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //浮空输入
26.     GPIO_Init(GPIOA, &GPIO_InitStructure);                 //初始化PA10
28.     //USART1 NVIC 配置
29.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
30.                 NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;  //抢占优先级0
31.                 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                  //子优先级2
32.                 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                          //IRQ通道使能
33.                 NVIC_Init(&NVIC_InitStructure);                                  //根据指定的参数初始化VIC寄存器
35.     //USART 初始化设置
36.                 USART_InitStructure.USART_BaudRate = 115200;                  //串口波特率为115200
37.                 USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长为8位数据格式
38.                 USART_InitStructure.USART_StopBits = USART_StopBits_1;        //一个停止位
39.                 USART_InitStructure.USART_Parity = USART_Parity_No;           //无奇偶校验位
40.                 USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;   //无硬件数据流控制
41.                 USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;                          //收发模式
42.     USART_Init(USART1, &USART_InitStructure);                     //初始化串口1
44.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //使能中断
45.     USART_Cmd(USART1, ENABLE);                     //使能串口1
47.           //如下语句解决第1个字节无法正确发送出去的问题
48.           USART_ClearFlag(USART1, USART_FLAG_TC);        //清串口1发送标志
49.                
50. }
52. //USART1 全局中断服务函数
53. void USART1_IRQHandler(void)                         
54. {
55.                 u8 com_data;
56.                 u8 i;
57.                 static u8 RxCounter1=0;
58.                 static u16 RxBuffer1[10]={0};
59.                 static u8 RxState = 0;       
60.                 static u8 RxFlag1 = 0;
63.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET)             //接收中断  
64.                 {
65.                                 USART_ClearITPendingBit(USART1,USART_IT_RXNE);   //清除中断标志
66.                                 com_data = USART_ReceiveData(USART1);
67.                        
68.                                 if(RxState==0&&com_data==0x2C)  //0x2c帧头
69.                                 {
70.                                         RxState=1;
71.                                         RxBuffer1[RxCounter1++]=com_data;OLED_Refresh();
72.                                 }
73.                
74.                                 else if(RxState==1&&com_data==0x12)  //0x12帧头
75.                                 {
76.                                         RxState=2;
77.                                         RxBuffer1[RxCounter1++]=com_data;
78.                                 }
79.                
80.                                 else if(RxState==2)
81.                                 {
82.                                         RxBuffer1[RxCounter1++]=com_data;
84.                                         if(RxCounter1>=10||com_data == 0x5B)       //RxBuffer1接受满了,接收数据结束
85.                                         {
86.                                                 RxState=3;
87.                                                 RxFlag1=1;
88.                                                 Cx=RxBuffer1[RxCounter1-5];
89.                                                 Cy=RxBuffer1[RxCounter1-4];
90.                                                 Cw=RxBuffer1[RxCounter1-3];
91.                                                 Ch=RxBuffer1[RxCounter1-2];
92.                                         }
93.                                 }
94.                
95.                                 else if(RxState==3)                //检测是否接受到结束标志
96.                                 {
97.                                                 if(RxBuffer1[RxCounter1-1] == 0x5B)
98.                                                 {
99.                                                                         USART_ITConfig(USART1,USART_IT_RXNE,DISABLE);//关闭DTSABLE中断
100.                                                                         if(RxFlag1)
101.                                                                         {
102.                                                                         OLED_Refresh();
103.                                                                         OLED_ShowNum(0, 0,Cx,3,16,1);
104.                                                                         OLED_ShowNum(0,17,Cy,3,16,1);
105.                                                                         OLED_ShowNum(0,33,Cw,3,16,1);
106.                                                                         OLED_ShowNum(0,49,Ch,3,16,1);
107.                                                                         }
108.                                                                         RxFlag1 = 0;
109.                                                                         RxCounter1 = 0;
110.                                                                         RxState = 0;
111.                                                                         USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
112.                                                 }
113.                                                 else   //接收错误
114.                                                 {
115.                                                                         RxState = 0;
116.                                                                         RxCounter1=0;
117.                                                                         for(i=0;i<10;i++)
118.                                                                         {
119.                                                                                         RxBuffer1[i]=0x00;      //将存放数据数组清零
120.                                                                         }
121.                                                 }
122.                                 }
123.        
124.                                 else   //接收异常
125.                                 {
126.                                                 RxState = 0;
127.                                                 RxCounter1=0;
128.                                                 for(i=0;i<10;i++)
129.                                                 {
130.                                                                 RxBuffer1[i]=0x00;      //将存放数据数组清零
131.                                                 }
132.                                 }
134.                 }
135.                
136. }

复制代码

注意观察下面的图：

二、串口通讯传输多个数据（四个点的x、y坐标同时传输给STM32单片机）

（一）OPENMV串口部分

1. from machine import Pin
2. import sensor, image, time, pyb
3. #import seekfree
4. from pyb import UART
6. # 初始化TFT180屏幕
7. #lcd = seekfree.LCD180(3)
9. # 初始化摄像头
10. sensor.reset()
11. sensor.set_pixformat(sensor.RGB565) # 设置图像色彩格式为RGB565格式
12. sensor.set_framesize(sensor.QQVGA)  # 设置图像大小为160*120
13. sensor.set_auto_whitebal(True)      # 设置自动白平衡
14. sensor.set_brightness(3000)         # 设置亮度为3000
15. sensor.skip_frames(time = 20)       # 跳过帧
16. uart = UART(3, 115200,timeout_char=3000) #配置串口
17. clock = time.clock()
19. def sending_data(cx,cy,cw,ch):
20.     global uart;
21.     data = ustruct.pack("<bbhhb",      #格式为俩个字符俩个短整型(2字节)
22.                    0x2C,                      #帧头1
23.                    0x12,                      #帧头2
24.                    int (cx1), # up sample by 4    #数据26
25.                    int (cy1),
26.                    int (cx2), # up sample by 4    #数据26
27.                    int (cy2),
28.                    int (cx3), # up sample by 4    #数据26
29.                    int (cy3),
30.                    int (cx4), # up sample by 4    #数据26
31.                    int (cy4),
32.                    0x5B)
33.     uart.write(data);   #必须要传入一个字节数组
35. while(True):
36.     clock.tick()
37.     img = sensor.snapshot()
39. # -----矩形框部分-----
40.     # 在图像中寻找矩形
41.     for r in img.find_rects(threshold = 10000):
42.         # 判断矩形边长是否符合要求
43.         if r.w() > 20 and r.h() > 20:
44.             # 在屏幕上框出矩形
45.             img.draw_rectangle(r.rect(), color = (255, 0, 0), scale = 4)
46.             # 获取矩形角点位置
47.             corner = r.corners()
48.             # 在屏幕上圈出矩形角点
49.             img.draw_circle(corner[0][0], corner[0][1], 5, color = (0, 0, 255), thickness = 2, fill = False)
50.             img.draw_circle(corner[1][0], corner[1][1], 5, color = (0, 0, 255), thickness = 2, fill = False)
51.             img.draw_circle(corner[2][0], corner[2][1], 5, color = (0, 0, 255), thickness = 2, fill = False)
52.             img.draw_circle(corner[3][0], corner[3][1], 5, color = (0, 0, 255), thickness = 2, fill = False)
54.         # 打印四个角点坐标, 角点1的数组是corner[0], 坐标就是(corner[0][0],corner[0][1])
55.         # 角点检测输出的角点排序每次不一定一致，矩形左上的角点有可能是corner0,1,2,3其中一个
56.             corner1_str = f"corner1 = ({corner[0][0]},{corner[0][1]})"
57.             corner2_str = f"corner2 = ({corner[1][0]},{corner[1][1]})"
58.             corner3_str = f"corner3 = ({corner[2][0]},{corner[2][1]})"
59.             corner4_str = f"corner4 = ({corner[3][0]},{corner[3][1]})"
60.         print(corner1_str + "\n" + corner2_str + "\n" + corner3_str + "\n" + corner4_str)
61.     # 显示到屏幕上，此部分会降低帧率
62.     #lcd.show_image(img, 160, 120, 0, 0, zoom=0)  #屏幕显示
64.     #串口通信传输的数据
65.         cx1=(int)(corner[0][0]*10)
66.         cy1=(int)(corner[0][1]*10)
68.         cx2=(int)(corner[1][0]*10)
69.         cy2=(int)(corner[1][1]*10)
71.         cx3=(int)(corner[2][0]*10)
72.         cy3=(int)(corner[2][1]*10)
74.         cx4=(int)(corner[3][0]*10)
75.         cy4=(int)(corner[3][1]*10)
77.         FH=bytearray([0x2C,0x12,cx1,cy1,cx2,cy2,cx3,cy3,cx4,cy4,0x5B])
79.         uart.write(FH)
81.         cx1=0
82.         cy1=0
84.         cx2=0
85.         cy2=0
87.         cx3=0
88.         cy3=0
90.         cx4=0
91.         cy4=0
93.     # 打印帧率
94.     print(clock.fps())

复制代码

下面请观察这幅代码截图：

（二）、STM32串口通讯部分

1. #include "stm32f10x.h"                  // Device header
2. #include <stdio.h>
3. #include <stdarg.h>
4. #include "OLED.h"
5. #include "LED.h"
6. #include "Serial.h"
8. uint8_t Serial_RxData;
9. uint8_t Serial_RxFlag;
10. static int16_t Cx1=0,Cy1=0,Cx2=0,Cy2=0,Cx3=0,Cy3=0,Cx4=0,Cy4=0;
12. int Cx5[16];//用于存放分段求的坐标值
13. int Cy5[16];
14. //static u8 RxFlag1 = 0;//串口中断接收标志位
16. extern float Ang1,Ang2,AngFlag;
17. extern float Angle1,Angle2;
19. int avel_X1 ;
20. int avel_X2 ;
21. int avel_X3 ;
22. int avel_X4 ;
24. int avel_Y1 ;
25. int avel_Y2 ;
26. int avel_Y3 ;
27. int avel_Y4 ;
29. void Serial_Init(void)
30. {
31.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
32.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
33.        
34.         //TX
35.         GPIO_InitTypeDef GPIO_InitStructure;
36.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
37.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
38.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
39.         GPIO_Init(GPIOB, &GPIO_InitStructure);
40.        
41.         //RX
42.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
43.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
44.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
45.         GPIO_Init(GPIOB, &GPIO_InitStructure);
46.        
47.         USART_InitTypeDef USART_InitStructure;
48.         USART_InitStructure.USART_BaudRate = 115200;
49.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
50.         USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
51.         USART_InitStructure.USART_Parity = USART_Parity_No;
52.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
53.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
54.         USART_Init(USART3, &USART_InitStructure);
55.        
56.         USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
57.        
58.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
59.        
60.         NVIC_InitTypeDef NVIC_InitStructure;
61.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
62.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
63.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
64.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
65.         NVIC_Init(&NVIC_InitStructure);
66.        
67.         USART_Cmd(USART3, ENABLE);
68. }
70. void Serial_SendByte(uint8_t Byte)
71. {
72.         USART_SendData(USART3, Byte);
73.         while (USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
74. }
76. void Serial_SendArray(uint8_t *Array, uint16_t Length)
77. {
78.         uint16_t i;
79.         for (i = 0; i < Length; i ++)
80.         {
81.                 Serial_SendByte(Array[i]);
82.         }
83. }
85. void Serial_SendString(char *String)
86. {
87.         uint8_t i;
88.         for (i = 0; String[i] != '\0'; i ++)
89.         {
90.                 Serial_SendByte(String[i]);
91.         }
92. }
94. uint32_t Serial_Pow(uint32_t X, uint32_t Y)
95. {
96.         uint32_t Result = 1;
97.         while (Y --)
98.         {
99.                 Result *= X;
100.         }
101.         return Result;
102. }
104. void Serial_SendNumber(uint32_t Number, uint8_t Length)
105. {
106.         uint8_t i;
107.         for (i = 0; i < Length; i ++)
108.         {
109.                 Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
110.         }
111. }
113. int fputc(int ch, FILE *f)
114. {
115.         Serial_SendByte(ch);
116.         return ch;
117. }
119. void Serial_Printf(char *format, ...)
120. {
121.         char String[100];
122.         va_list arg;
123.         va_start(arg, format);
124.         vsprintf(String, format, arg);
125.         va_end(arg);
126.         Serial_SendString(String);
127. }
128. //USART3 全局中断服务函数
129. void USART3_IRQHandler(void)                         
130. {
131.                 int com_data;
132.                 u8 i;
133.                 u8 Jieshou = 1;
134.                
135.                 static u8 RxCounter1=0;
136.                 static int RxBuffer1[16]={0};
137.                 static u8 RxState = 0;       
138.                 static u8 RxFlag1 = 0;//串口中断接收标志位，已被移除至函数体外作为全局变量
140.                 if( USART_GetITStatus(USART3,USART_IT_RXNE)!=RESET && Jieshou == 1)             //接收中断  
141.                 {
142. //                        OLED_ShowSignedNum(1,1,520,4);
143.                                 USART_ClearITPendingBit(USART3,USART_IT_RXNE);   //清除中断标志
144.                                 com_data = USART_ReceiveData(USART3);
145.                         if(Jieshou == 1)
146.                         {
147.                
148.                                 if(RxState==0&&com_data==0x2C)  //0x2c帧头
149.                                 {
150.                                         RxBuffer1[RxCounter1++]=com_data;
151.                                         RxState=1;
152.                                 }
153.                
154.                                 else if(RxState==1&&com_data==0x12)  //0x12帧头
155.                                 {
156.                                         RxBuffer1[RxCounter1++]=com_data;
157.                                         RxState=2;
158.                                 }                       
159.                                 else if(RxState==2)
160.                                 {
161.                                         RxBuffer1[RxCounter1++]=com_data;
163.                                         if(RxCounter1>=14||com_data == 0x5B)       //RxBuffer1接受满了,接收数据结束
164.                                         {
165.                                                 RxState=3;
166.                                                 RxFlag1=1;
167.                                                 Jieshou = 2;
168.                                                
169.                                                 Cx1=RxBuffer1[RxCounter1-9];
170.                                                 Cy1=RxBuffer1[RxCounter1-8];
171.                                                
172.                                                 Cx2=RxBuffer1[RxCounter1-7];
173.                                                 Cy2=RxBuffer1[RxCounter1-6];
174.                                                
175.                                                 Cx3=RxBuffer1[RxCounter1-5];
176.                                                 Cy3=RxBuffer1[RxCounter1-4];
177.                                                
178.                                                 Cx4=RxBuffer1[RxCounter1-3];
179.                                                 Cy4=RxBuffer1[RxCounter1-2];
180.                                                
181.                                                 OLED_ShowSignedNum(1,1,Cx1,4);
182.                                                 OLED_ShowSignedNum(2,1,Cy1,4);
183.                                                 OLED_ShowSignedNum(3,1,Cx2,4);
184.                                                 OLED_ShowSignedNum(4,1,Cy2,4);
185.                                                
186.                                                 OLED_ShowSignedNum(1,7,Cx3,4);
187.                                                 OLED_ShowSignedNum(2,7,Cy3,4);
188.                                                 OLED_ShowSignedNum(3,7,Cx4,4);
189.                                                 OLED_ShowSignedNum(4,7,Cy4,4);
190.                                                
191.                                         }
192.                                 }
193.                         }
194.                                 else if(RxState==3)                //检测是否接受到结束标志
195.                                 {
196.                                         if(RxBuffer1[RxCounter1-1] == 0x5B)
197.                                         {
198.                                                 USART_ITConfig(USART3,USART_IT_RXNE,DISABLE);//关闭DTSABLE中断
199.                                                 if(RxFlag1)
200.                                                 {       
201.                                                        
202.                                                         AngFlag=0;
203.                                                         HuanRaoZuoBiao();
204. //                                                                               
205. //                                                        OLED_ShowSignedNum(1,1,Cx1,4);
207. //                                                        OLED_ShowSignedNum(2,1,Cx2,4);
208. //                                                        OLED_ShowSignedNum(3,1,avel_X1,4);
209. //                                                        OLED_ShowSignedNum(4,1,Cx5[0],4);
211.                                                         AngFlag=1;
212.                                                         RxFlag1 = 0;
213.                                                         RxCounter1 = 0;
214.                                                         RxState = 0;                                                                       
215.                                                 }
216.                                                 USART_ITConfig(USART3,USART_IT_RXNE,ENABLE);                                                                       
217.                                         }
218.                                         else   //接收错误
219.                                         {
220.                                                                 RxState = 0;
221.                                                                 RxCounter1=0;
222.                                                                 for(i=0;i<10;i++)
223.                                                                 {
224.                                                                                 RxBuffer1[i]=0x00;      //将存放数据数组清零
225.                                                                 }
226.                                         }
227.                                 }
228.        
229.                                 else   //接收异常
230.                                 {
231.                                                 RxState = 0;
232.                                                 RxCounter1=0;
233.                                                 for(i=0;i<10;i++)
234.                                                 {
235.                                                                 RxBuffer1[i]=0x00;      //将存放数据数组清零
236.                                                        
237.                                                 }
238.                                 }
239.                        
240.                 }
241.         }

复制代码

 注意观察下面这副代码截图：

以上便是我对电赛期间OPENMV与单片机之间实现串口通讯的代码实现。学者若有疑问或需要代码工程，可以私聊我。收到后我会及时回复。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。