前言
# d% z1 _+ a( B% s( M/ H0 L4 [. \最近一段时间都在捣鼓OpenMV和Stm32的通信问题，刚开始不知道哪里出了问题，一直通信失败，明明使用TTL串口接收OpenMv发送的数据是可以在串口调试助手上显示的，但就是无法发给Stm32的USART串口。经过了差不多一周的时间，终于解决了。于是在这里记录学习记录。

一、OpenMv配置
8 K) |: Q: K* r" a  @+ A/ ]1.第一种发送方法
OpenMv代码如下

1. # Untitled - By: 86188 - 周二 5月 25 2021
   / ~' ]* a$ P& E% v* o
2. 
   
3. import sensor, image, time,pyb
   - e) G, u# r7 i( E/ L
4. from pyb import UART,LED
   , y6 c% ~( o" t( U
5. import json
   
6. import ustruct
   - f5 l6 A; m  _6 D* R
7. 
   
8. 
   7 P7 M, }" l# ~- g' g4 J
9. 
   
10. 
    6 e3 D" \& W2 F, @/ S
11. #white_threshold_01 = ((95, 100, -18, 3, -8, 4));  #白色阈值
    
12. red_threshold_01 = ((2, 51, 11, 127, -128, 127))  #红色阈值
    
13. 
    
14. LED_R = pyb.LED(1) # Red LED = 1, Green LED = 2, Blue LED = 3, IR LEDs = 4.
    
15. LED_G = pyb.LED(2)
    
16. LED_B = pyb.LED(3)
    
17. 
    
18. LED_R.on()
    . H5 z1 ?( W/ m& U- p; N6 _
19. LED_G.on()
    , m6 S4 O  n5 A* D0 m# c' U
20. LED_B.on()
    ( [% h, F+ `1 c* z* q* u1 r
21. 
    
22. 
    
23. 
    1 u- m& n0 g3 k- v1 \' x8 g% a/ _
24. sensor.reset()
    1 [+ I/ H; ^6 B9 D; H
25. sensor.set_pixformat(sensor.RGB565)
    
26. sensor.set_framesize(sensor.QVGA)
    * E) d& v3 `- j) O+ b
27. sensor.skip_frames(time = 2000)
    
28. sensor.set_auto_gain(False) # must be turned off for color tracking
    
29. sensor.set_auto_whitebal(False) # must be turned off for color tracking
    * m0 j2 C( Q6 P1 F: B: K. p
30. 
    
31. 
    + I2 W  n# ]& A' a! R
32. clock = time.clock()
    
33. 
    
34. LED_R.off()
    
35. LED_G.off()
    1 Q, |8 f1 T. ^6 r
36. LED_B.off()
    
37. 
    
38. uart = UART(3,115200)   #定义串口3变量
    ' q4 a& g- j- v. E0 i/ V
39. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
    0 ?0 y6 k2 a, G& y+ l  i' ]
40. 
    
41. 
    
42. 
    
43. def find_max(blobs):    #定义寻找色块面积最大的函数
    # ~- r1 b. L# z# B: g4 H
44.     max_size=0
    ) q; ^$ o' ~# _& e) i: ^
45.     for blob in blobs:
    
46.         if blob.pixels() > max_size:
    3 A- h  u  r! X, c* n* l
47.             max_blob=blob
    
48.             max_size = blob.pixels()
    2 p1 E3 o) H% p! o! @$ B0 x
49.     return max_blob
    % J1 _6 ]4 ?5 J5 t* x: d
50. 
    
51. 
    
52. def send_data_packet(x,y,z,w):
    2 L% S- O* ]7 F4 @
53.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
    
54.                    0x2C,                       #帧头1
    
55.                    0x12,                       #帧头2
    / f, e/ L1 y& L, r3 C
56.                    int(x), # up sample by 2    #数据1
    " j6 y+ b* `7 ~" V, l; ~% Q
57.                    int(y), # up sample by 2    #数据2
    
58.                    int(z),
    
59.                    int(w))
    
60.                    #0x5B)
    # F, f# u( x1 @
61.     uart.write(temp);                           #串口发送
    
62. 
    2 {0 w3 h2 R6 ?! G
63. 
      n8 J2 [! K0 l5 s$ g2 s
64. 
    0 v0 M- x8 M# q$ H% @. M# P7 ~
65. 
    ( K! \4 o, M, r7 j
66. 
    ! f, S1 q" p, W6 E: @: ?4 I3 c% Y
67. while(True):
    " F7 M2 O9 C6 [' M( N( I' k) w
68.     img = sensor.snapshot()
    ) A3 W4 p: u1 b" X# x8 ^1 B
69.     #time.sleep_ms(1000)
    
70.     #send_data_packet(x,y)
    , @* q4 O- |. c7 o8 E' ~
71.     blobs = img.find_blobs([red_threshold_01]);
    / Q. K1 W: l9 d" g
72. 
    1 g3 r; @$ V! X: S. c' f( u
73.     cx=0;cy=0;
    
74.     if blobs:
    6 y! U& G1 J  p
75.                 #如果找到了目标颜色
    
76.                 max_b = find_max(blobs);
    
77.                 # Draw a rect around the blob.
    
78.                 img.draw_rectangle(max_b[0:4]) # rect
    " b7 k$ s  G3 h! r6 n% K
79.                 #用矩形标记出目标颜色区域
    . G, O5 j# V; F+ V, R
80.                 img.draw_cross(max_b[5], max_b[6]) # cx, cy
    & M, S# Y) o7 S  g3 M
81.                 #img.draw_cross(160, 120) # 在中心点画标记
    
82.                 #在目标颜色区域的中心画十字形标记
    5 y/ [  F7 P3 _
83.                 cx=max_b[5];
    5 V: q. t; k7 i
84.                 cy=max_b[6];
    ; U; K# [) v% n
85.                 cw=max_b[2];
    
86.                 ch=max_b[3];
    + a: u6 O& D5 `7 [
87. 
    
88.     #data = bytearray([x,y])
    * B) q# c& p# h* Q: J  o9 y
89.                 send_data_packet(cx,cy,cw,ch)
    - [3 p* h5 t; o
90.     #time.sleep_ms(1000)
    ( t0 G+ ]- e+ [- h" b: w, f7 }

复制代码

代码作用：OpenMv使用的是python语言编写，而这段代码的主要目的就是在openmv视野种寻找红色色块，并将其中点坐标发送会Stm32，并在OLED屏幕上显示。
: f$ K/ B" p$ X! D
主要通信函数如下
4 G1 A1 e0 {+ f5 a  m5 n* G

1. def send_data_packet(x,y,z,w):
   * A3 X2 }1 [$ W' e( M$ c( I" Z7 F
2.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
   ( x. w5 C% `5 M6 d
3.                    0x2C,                       #帧头1
   3 o- U6 {0 }( ?, C7 L( b
4.                    0x12,                       #帧头2
   
5.                    int(x), # up sample by 2    #数据1
   
6.                    int(y), # up sample by 2    #数据2
   
7.                    int(z),
   
8.                    int(w))
   
9.                    #0x5B)
   
10.     uart.write(temp);                           #串口发送

复制代码

这里使用了数据包的形式发送数据，将一帧的数据包装，并发送给Stm32，此数据包中的包头非常重要，也就是0x2C以及0x12，这两个数据便与Stm32接收中断中进行判断，以确保数据的正确性。
对于数据包格式，此等的使用规划：

1. #pack各字母对应类型
   - L# i& \/ K& l/ o6 @. y
2. #x   pad byte        no value            1
   ; |2 X7 T& N- ]- ]1 y
3. #c   char            string of length 1  1
   
4. #b   signed char     integer             1
   # C" ]9 ?" q$ [; a7 F) Z1 Z; D, h
5. #B   unsigned char   integer             1
   
6. #?   _Bool           bool                1
   1 g1 l  n$ U9 d' \
7. #h   short           integer             2
   0 G& N2 B$ ]% y& E2 y! {. y/ I/ {' o
8. #H   unsigned short  integer             2
   
9. #i   int             integer             4
   
10. #I   unsigned int    integer or long     4
      o; ?, W9 `. N& {6 [
11. #l   long            integer             4
    
12. #L   unsigned long   long                4
    
13. #q   long long       long                8
    
14. #Q   unsilong long   long                8
    5 k# f$ \* t& P$ r+ A% V
15. #f   float           float               4
    6 _" Y  H' j' Z# v
16. #d   double          float               8
    
17. #s   char[]          string              1
    
18. #p   char[]          string              1
    
19. #P   void *          long

复制代码

对于此处我所使用的"<bbhhhh",
第一个第二个数据为包头，便是b，字符串类型。而后面开始为数据格式，我选择的是h也就是短整型，传输给Stm32的时候，便是两个字节的数据格式。
如图，一串完整的数据便是 2C 12 36 00 80 00 2E 00 9D 00。


2 K1 d, I* d3 t9 l- j" |, c+ i
  Z' K) X7 O$ C  l; k2.第二种发送方法
除了以上这种以包（pack）的方式发送给stm32外，还可以使用另外的一种方法发送：
! |& k# F5 X  x2 u! V6 @

1. def send_data(cx,cy,w,h):
   7 T' X& R2 C2 A
2.     datalist = [ 0x2C,0x12,cx,cy,w,h]
   4 y' S5 s* K, |( }2 `
3.     datalist.append(sum_checkout(datalist))
   
4.     data = bytearray(datalist)
   
5.     return data
   ( D3 f. q! O6 |4 f
6. 
   + ]6 U9 D/ C9 s0 M
7. #检验数据和  
     a/ d. r4 l* k5 i
8. def sum_checkout(data_list):
   
9.     data_sum = 0
   ' B& E/ r- ^; [7 V) ^: `
10.     for temp in data_list:
    
11.         data_sum =  data_sum + temp
    . t5 U3 i+ G; P. f2 Z4 |
12.     return data_sum

复制代码

这段代码和之前不同的是：我将0x5B 最后一位的数据校验位改成了用sum_checkout() 这段函数求和取余的方法作为该数据的数据校验位。
( y4 |* C/ ?/ \  H, f" L但是使用这样不封包的方法发送，就必须加上data = bytearray(datalist)，将数据转化，才可以进行通讯。
4 u. \1 h6 c5 Z7 c
0 x0 N& S" W" n. F二、Stm32配置
Stm32的USART1配置如下：

& Q+ R% J* y2 P1 C5 X

1. 
   * [& H9 P% f$ V( n8 @. o7 U
2. u16 USART_RX_STA=0;       //接收状态标记         
   
3. 
   + {1 I2 }" x2 Q1 Q9 p6 B
4. void uart1_init(u32 bound){
   8 s" }: ~, G  s0 Y6 X6 X
5.   //GPIO端口设置
   / I; G' K" r7 v# S0 J8 z  [$ G
6.   GPIO_InitTypeDef GPIO_InitStructure;
   
7.         USART_InitTypeDef USART_InitStructure;
   
8.         NVIC_InitTypeDef NVIC_InitStructure;
   
9.          
   4 y4 O2 m& E* t
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
11. 
    ( L; C8 I! v# i) w. s, Q$ ?0 Y0 i
12.         //USART1_TX   GPIOA.9
    
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    
14.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    % q/ T7 D( G1 N$ J- W5 v3 ]
16.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
17. 
    3 I( E" X. f$ ~: m+ J' c
18.   //USART1_RX          GPIOA.10初始化
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    8 @. R8 S, N5 d
21.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    ( |, A: o4 Y: E. E" W- L! S+ X
22. 
    
23.   //Usart1 NVIC 配置
    " o, X5 O' V5 F5 s! I
24.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    ' u2 h) p: y" O: H
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    % T2 ~+ @6 |& |9 v- C' c; V  V
27.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
28.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    . `9 J9 H% `' d) f1 t) Q, y
29. 
    
30.    //USART 初始化设置
    
31. 
    
32.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
34.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    , h0 @( P  S; I3 f; @7 f6 F' G
35.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    " \9 ^$ z+ E- l) i/ }8 o
36.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    5 F6 l( r7 t+ c' f4 U; _
37.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    & Q0 M' t3 a) T3 T7 i1 g
38. 
    
39.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    : V- u% a) F" A3 R7 g  B7 W* V7 F! I
40.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    ' ^* Q0 Z  j$ ]6 H+ D2 c/ |
41.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
42. 
    
43. }

复制代码

相比于平常配置并未存在较大差别，而实现通信的重要步骤是在USART1的串口接收中断中。
8 W* E  T% V! G, S/ P% l8 C0 P
' h- X% Q# N5 V  e" `- D6 H

1. void USART1_IRQHandler(void)
   : N7 y$ t7 i: `" M( S
2. {
   $ D. S3 t  C) Z5 x+ N" d; c
3.                 u8 Res;
   
4. 
   4 c$ o. K# k; q5 \: P0 v4 z  p
5.                 static u8 Rebuf[20]={0};
   $ W, V. r' M- N0 O$ \) T& `
6.                 static u8 i = 0;
   
7. 
   4 Z- O; C# h+ U! X; t! s
8.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET )
   
9.         {
   # O. [. V1 `" y; }6 ^3 F3 B
10.                 Rebuf[i++] = USART_ReceiveData(USART1);
    : C- g6 J" v( k2 `: K) ^
11.                 if(Rebuf[0] != 0x2c)
    3 Z6 `' ], {, l: k& G* Z& t. n; ]
12.                                 i = 0;
    
13.                 if((i==2)&&Rebuf[1] != 0x12)
    
14.                           i = 0;
    $ G! G1 F* i1 l  M, j3 C  W
15.                         if(i>=10)
    ) T: l" f- e( {3 y2 k3 ]
16.                         {
    
17.                                 memcpy(OpenMV_Rx_BUF,Rebuf,i);
    
18.                                 i = 0;
    0 `) q& J( |- Y  T
19.                         }
    
20.                         USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除中断标志
    
21.         }
    
22. 
    8 A# z& I5 i6 D
23. }

复制代码

5 b2 W9 p3 T/ M" y- K其中定义了一个OpenMV_Rx_BUF[20]的数组来接收openmv发送过来的数据，需要使用extern修饰这个变量，以便于事项后续操作。
同时memcpy（）函数也是十分重要的一个内置函数，可以实现两个数组的拷贝任务。
- V0 P/ f" m. C1 y" \, k: k
主函数的代码如下：

1. int main(void)
   ! `5 m$ K* A! p) K0 k3 L1 P" V: L
2. {               
   
3.          
   
4.         delay_init();                     //延时函数初始化         
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   % G* `% I" z3 l4 @
6.         uart1_init(115200);         //串口初始化为115200
   
7.          LED_Init();                             //LED端口初始化
   + L4 s  _% y$ p: d& _( [
8.         OLED_Init();
   
9.         
   
10.         while(1)
      ^5 D6 q; P; P
11.         {
    
12.                         
    : f4 q$ G0 I2 y; G# d
13.                         LED0=!LED0;
    - |, X; ?7 ~! Z( H* J5 T
14.                         delay_ms(200);
    
15. 
    
16.                     OLED_Refresh_Gram();
    
17.             
    
18.                         OLED_ShowNumber(0,20,OpenMV_Rx_BUF[2],3,12);
    3 j9 t4 k* V2 B8 i
19.                         OLED_ShowNumber(20,20,OpenMV_Rx_BUF[4],3,12);
    1 `" V- W$ {4 r* `4 b9 M! K" \
20.                         OLED_ShowNumber(40,20,OpenMV_Rx_BUF[6],3,12);
    
21.                         OLED_ShowNumber(60,20,OpenMV_Rx_BUF[8],3,12);
    
22.                         
    
23. 
    
24.         }
    
25. }

复制代码

1 u# H7 I' u+ I前面就提到了，由于我数据包的格式设置问题，存入OpenMV_Rx_BUF[] 数组中的数据，真正有效的是第3、5、7、9位（因为选择了h类型数据格式，一个数据占2位）。

+ u$ U# O1 F- a, L- y( I总结
博主我之前数据一直发送失败的原因是，博主使用了 uart.write() 这个函数，企图通过 uart.write() 这个函数实现数据发送。
+ M, k, M0 C) p6 c这个函数在实现OpenMv和PC端的通信上没有问题，可以将数据打在串口调试助手上，但在其与Stm32的通信问题上就存在问题。
若要使用 uart.write() 实现与stm32的通信，便要使用bytearray()函数将其转化，才可以进行通信。
4 `8 C& v# T+ Z& N2 U

1.     FH = bytearray([0x2C,0x12])
   
2.     uart.write(FH)

复制代码

" @; G  J' v& E6 t9 k9 F