前言
+ j$ }3 l. x4 b5 `8 H最近一段时间都在捣鼓OpenMV和Stm32的通信问题，刚开始不知道哪里出了问题，一直通信失败，明明使用TTL串口接收OpenMv发送的数据是可以在串口调试助手上显示的，但就是无法发给Stm32的USART串口。经过了差不多一周的时间，终于解决了。于是在这里记录学习记录。
4 j  P. [0 G9 }% _* l* W+ I+ {
一、OpenMv配置
0 ?7 e5 |! J, K4 e: [) I1.第一种发送方法
6 I' Q; ^1 T% E" @% |3 S1 YOpenMv代码如下
5 G4 o2 n4 R2 Z
2 T- T5 a/ G8 M

1. # Untitled - By: 86188 - 周二 5月 25 2021
   
2. 
   ; _4 g" s- d* \1 M% B, S7 m( S
3. import sensor, image, time,pyb
   ; ~/ F( Y# G5 N7 Q: b2 \7 ]
4. from pyb import UART,LED
   
5. import json
   
6. import ustruct
   ' a' \7 H- X2 F9 F& _* Y
7. 
   
8. 
   
9. 
   ( P  P* o4 V8 z+ J) b, H4 |  |0 X
10. 
    8 k8 N+ I0 n( L$ d
11. #white_threshold_01 = ((95, 100, -18, 3, -8, 4));  #白色阈值
    
12. red_threshold_01 = ((2, 51, 11, 127, -128, 127))  #红色阈值
    
13. 
    ' {! B% U( ~/ N0 [) g5 ~- d
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()
    
19. LED_G.on()
    
20. LED_B.on()
      ?5 O+ e2 r$ G' C' F& |" B
21. 
    
22. 
    
23. 
    
24. sensor.reset()
    , v' L# A" M( `  L: s# ~; A" u
25. sensor.set_pixformat(sensor.RGB565)
    
26. sensor.set_framesize(sensor.QVGA)
    
27. sensor.skip_frames(time = 2000)
    1 w' m" R/ \7 Q; \7 O/ ?
28. sensor.set_auto_gain(False) # must be turned off for color tracking
    + |5 }! f" l& I  n" q
29. sensor.set_auto_whitebal(False) # must be turned off for color tracking
    
30. 
    
31. 
    
32. clock = time.clock()
    1 t) t9 k9 B- I  y; j( m
33. 
    
34. LED_R.off()
    8 C; t! p6 V9 D. `: Q% D
35. LED_G.off()
    
36. LED_B.off()
    9 e  A9 l0 L2 A. n. R
37. 
    
38. uart = UART(3,115200)   #定义串口3变量
    6 ~- K: V% l  z2 a
39. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
    
40. 
    
41. 
    : W8 F) i& q5 A% d% Q
42. 
    
43. def find_max(blobs):    #定义寻找色块面积最大的函数
    
44.     max_size=0
    
45.     for blob in blobs:
    
46.         if blob.pixels() > max_size:
    
47.             max_blob=blob
    
48.             max_size = blob.pixels()
    
49.     return max_blob
    
50. 
    8 a' h- s0 ^1 F
51. 
    7 |' s. d7 ^" N2 G7 f' R
52. def send_data_packet(x,y,z,w):
    
53.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
    6 A3 ^0 X( F) E/ B
54.                    0x2C,                       #帧头1
    
55.                    0x12,                       #帧头2
    / Z4 u# O: x* z5 ?& U$ e+ e
56.                    int(x), # up sample by 2    #数据1
    
57.                    int(y), # up sample by 2    #数据2
    1 w9 M8 Y# u3 c9 r2 o+ V$ s: S
58.                    int(z),
    
59.                    int(w))
    
60.                    #0x5B)
    
61.     uart.write(temp);                           #串口发送
    ' T# S  b- j# f  M8 J& t9 g
62. 
    1 y7 k- w5 [3 r
63. 
    
64. 
    8 o, E, G2 Q6 i9 \8 {6 S
65. 
    5 c$ B  H3 C) r
66. 
    " w/ c- E  Y5 ?" P7 |' J0 W
67. while(True):
    
68.     img = sensor.snapshot()
    : n* V6 j  ?) J2 O& {: g& o* u1 Z
69.     #time.sleep_ms(1000)
    
70.     #send_data_packet(x,y)
    
71.     blobs = img.find_blobs([red_threshold_01]);
    
72. 
    2 \; e& F4 \' ^% n
73.     cx=0;cy=0;
    5 j" O* C/ U3 o( d
74.     if blobs:
    
75.                 #如果找到了目标颜色
    
76.                 max_b = find_max(blobs);
    . L7 Z+ T# j8 b5 @- y, F+ t- o" J
77.                 # Draw a rect around the blob.
    6 e- R7 z/ q3 c2 ?$ z
78.                 img.draw_rectangle(max_b[0:4]) # rect
    ' j5 ~5 v  ~3 ?6 A
79.                 #用矩形标记出目标颜色区域
    
80.                 img.draw_cross(max_b[5], max_b[6]) # cx, cy
    1 L8 G& E: H% A1 g8 X  u
81.                 #img.draw_cross(160, 120) # 在中心点画标记
    
82.                 #在目标颜色区域的中心画十字形标记
    + y6 a- f# N* u
83.                 cx=max_b[5];
      z% x* `! n* \) H6 I
84.                 cy=max_b[6];
    2 N6 w% v+ @0 Z6 L1 _. ^; a/ f+ t
85.                 cw=max_b[2];
    2 D+ s, Z  D4 H4 @: Z+ Z9 X% _
86.                 ch=max_b[3];
      n- J  K0 B8 Y" C' ]
87. 
    
88.     #data = bytearray([x,y])
    : Z" P* M, D( r
89.                 send_data_packet(cx,cy,cw,ch)
    
90.     #time.sleep_ms(1000)
    

复制代码

& ?4 R9 d* t/ Q代码作用：OpenMv使用的是python语言编写，而这段代码的主要目的就是在openmv视野种寻找红色色块，并将其中点坐标发送会Stm32，并在OLED屏幕上显示。
- C3 Y- F9 |/ B! o( {( ?; }
主要通信函数如下

1. def send_data_packet(x,y,z,w):
   
2.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
   
3.                    0x2C,                       #帧头1
   
4.                    0x12,                       #帧头2
   
5.                    int(x), # up sample by 2    #数据1
   
6.                    int(y), # up sample by 2    #数据2
   ' Y7 u! p/ Z# e/ Z/ n& v$ r
7.                    int(z),
   3 ~" }  K: `3 g; N3 \% B/ v, k9 ~6 ~
8.                    int(w))
   / `; o2 {8 U9 Y  N, o* w
9.                    #0x5B)
   0 e4 M5 P/ D9 Q/ q; F1 ~! V: E
10.     uart.write(temp);                           #串口发送

复制代码

' \( o" s# W4 m这里使用了数据包的形式发送数据，将一帧的数据包装，并发送给Stm32，此数据包中的包头非常重要，也就是0x2C以及0x12，这两个数据便与Stm32接收中断中进行判断，以确保数据的正确性。
对于数据包格式，此等的使用规划：
; V$ Y& q7 }5 D2 v* Y* ~, C
$ u/ o- v7 c6 {% _

1. #pack各字母对应类型
   
2. #x   pad byte        no value            1
   
3. #c   char            string of length 1  1
   & q* ?7 O7 p% z2 e9 B& B( V
4. #b   signed char     integer             1
   
5. #B   unsigned char   integer             1
   
6. #?   _Bool           bool                1
   
7. #h   short           integer             2
   ) t1 q2 G5 I% V% a
8. #H   unsigned short  integer             2
   
9. #i   int             integer             4
   $ K$ V2 |- h9 d# P- i, g4 L
10. #I   unsigned int    integer or long     4
    
11. #l   long            integer             4
    
12. #L   unsigned long   long                4
    
13. #q   long long       long                8
    " t; B  @) L2 u* q1 P; J7 h
14. #Q   unsilong long   long                8
    
15. #f   float           float               4
    
16. #d   double          float               8
    ; M9 H6 h% c, a
17. #s   char[]          string              1
    ' k! N; |' f. q. `, o5 ~
18. #p   char[]          string              1
    
19. #P   void *          long

复制代码

对于此处我所使用的"<bbhhhh",
( n: a. S5 z% U. b: |- k) u第一个第二个数据为包头，便是b，字符串类型。而后面开始为数据格式，我选择的是h也就是短整型，传输给Stm32的时候，便是两个字节的数据格式。
  X& I: A; s  c1 b5 t: y. T2 E1 Y如图，一串完整的数据便是 2C 12 36 00 80 00 2E 00 9D 00。


) f/ ?. b4 x8 Q3 L1 ~) Z
2.第二种发送方法
除了以上这种以包（pack）的方式发送给stm32外，还可以使用另外的一种方法发送：

0 M) c. O. `/ v- S+ u# o# ?

1. def send_data(cx,cy,w,h):
   5 U+ }, j2 d- }" Y( W* p
2.     datalist = [ 0x2C,0x12,cx,cy,w,h]
   + y4 K( V1 _# m4 Y; K
3.     datalist.append(sum_checkout(datalist))
   
4.     data = bytearray(datalist)
   
5.     return data
   
6. 
   
7. #检验数据和  
   4 c/ ~5 G/ z5 q+ `; q6 p# o* E
8. def sum_checkout(data_list):
   
9.     data_sum = 0
   * c6 r5 g* b2 z) j9 U
10.     for temp in data_list:
    
11.         data_sum =  data_sum + temp
    
12.     return data_sum

复制代码

) Q3 C, ?' P+ J/ ]3 t这段代码和之前不同的是：我将0x5B 最后一位的数据校验位改成了用sum_checkout() 这段函数求和取余的方法作为该数据的数据校验位。
但是使用这样不封包的方法发送，就必须加上data = bytearray(datalist)，将数据转化，才可以进行通讯。
' r0 S4 _3 Q4 \8 f
( D7 C3 m* o0 n二、Stm32配置
: ^+ Q. J3 Y0 F3 J0 TStm32的USART1配置如下：
) @0 |) q  U7 J1 F! I
1 p, _* ]% i# T6 k. f

1. 
   
2. u16 USART_RX_STA=0;       //接收状态标记         
   # [  W+ J$ a8 f/ R
3. 
   - Z( S- g9 v1 s- U5 h7 v+ i
4. void uart1_init(u32 bound){
   
5.   //GPIO端口设置
   
6.   GPIO_InitTypeDef GPIO_InitStructure;
   
7.         USART_InitTypeDef USART_InitStructure;
   7 a2 h$ H. [" u" n" @& i
8.         NVIC_InitTypeDef NVIC_InitStructure;
   : p5 n7 X/ m; M: G; ~' t& b
9.          
   5 f! Y  y1 A" \
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
11. 
    - B' I& N$ }8 x* I# y
12.         //USART1_TX   GPIOA.9
    1 G  o9 a0 a# a" h
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    # A$ Y6 a' O% F& I4 x
14.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    + v5 W' J1 @" W! L' N
15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    . Z$ J" c" D. o( ^3 n8 X* ^
16.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
17. 
    
18.   //USART1_RX          GPIOA.10初始化
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    7 ~9 k% p9 Z( N# W4 J
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    5 }+ j) u; f* n3 \1 a. K
21.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    # a4 B! O: @- R7 t/ K  O& i& i& H8 @
22. 
    + k  s/ C( W: A$ c) ^0 s0 D! v
23.   //Usart1 NVIC 配置
    
24.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    6 h0 Q7 ^, l0 A' N& l8 O) J) t) v
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    : B* f8 Z8 V% n6 g4 {
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
27.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
28.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    ( X+ q- W6 p8 {5 n, ?  s, ~
29. 
    
30.    //USART 初始化设置
    7 j9 h2 a3 B; ?1 G, ]9 S
31. 
    3 G1 Q  u2 H) B' H6 \
32.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    ( k; Q. ~( U$ U  g, X7 m9 o
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    ' A" d  x8 Z( k  T- w7 M
34.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    2 g4 f0 ?, H/ c: O/ G/ N! h* \
35.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    . y( t/ }- z: C" Y1 I5 f
36.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
37.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
38. 
    , H  S$ x  d# x- F0 y
39.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
40.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    ! K9 ]8 n, G' `
41.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
42. 
    ! |: U& d( Q, L7 _9 P4 O
43. }

复制代码

( j" R0 ~5 {$ U5 L, @相比于平常配置并未存在较大差别，而实现通信的重要步骤是在USART1的串口接收中断中。
3 t1 y  C) q) ]: [

1. void USART1_IRQHandler(void)
   ! }0 t+ e0 ~" a7 x6 a
2. {
   
3.                 u8 Res;
   - A0 M# c. g* y
4. 
   0 F5 ?) {) P4 X7 v7 V- U
5.                 static u8 Rebuf[20]={0};
   " L. v. y7 v$ M2 z5 ^8 d5 P; W$ w
6.                 static u8 i = 0;
   
7. 
   ' Z3 E) q' e7 E/ T; z
8.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET )
   & I9 h( b7 l5 W: _/ ~: n
9.         {
   5 d1 {( D4 j/ s; u. w4 o
10.                 Rebuf[i++] = USART_ReceiveData(USART1);
    8 n# U# y2 J7 O0 [! S; y/ B
11.                 if(Rebuf[0] != 0x2c)
    
12.                                 i = 0;
    0 C* D3 f1 {% W
13.                 if((i==2)&&Rebuf[1] != 0x12)
    4 o; v3 l8 m9 b% c0 @5 S6 r, [) \
14.                           i = 0;
    , K6 x. V! o1 f- j: K; w/ @
15.                         if(i>=10)
    ! T9 I" z: X& J% q; A& A
16.                         {
    
17.                                 memcpy(OpenMV_Rx_BUF,Rebuf,i);
    4 R' [) Z2 k0 f3 `) u% d7 A
18.                                 i = 0;
    
19.                         }
    
20.                         USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除中断标志
    $ @! ^5 e9 M/ g) }
21.         }
    
22. 
    , w* s: }( R' B8 G
23. }

复制代码

其中定义了一个OpenMV_Rx_BUF[20]的数组来接收openmv发送过来的数据，需要使用extern修饰这个变量，以便于事项后续操作。
+ l& r! h% ?& v同时memcpy（）函数也是十分重要的一个内置函数，可以实现两个数组的拷贝任务。

& G& A4 U' a9 z- F; ?& c主函数的代码如下：

1. int main(void)
   + z$ `7 n% T. M, z( n3 B4 b
2. {               
   # K1 z, S& C1 T; O( [1 o, o
3.          
   
4.         delay_init();                     //延时函数初始化         
   ; X0 ?9 L, s: _1 x
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   6 ^& _& x) x2 V
6.         uart1_init(115200);         //串口初始化为115200
   2 |% l' e4 e2 [: E3 v
7.          LED_Init();                             //LED端口初始化
     G+ P$ P9 Y  l8 l; a+ C
8.         OLED_Init();
   
9.         
   , ^) ^- Q1 \. z9 p* ~' l
10.         while(1)
    
11.         {
    ) w0 s: W7 N2 ^5 a% C) O6 p* |( y
12.                         
    . u! x" J) f8 a6 Z, ]2 \8 D
13.                         LED0=!LED0;
    
14.                         delay_ms(200);
    ' s7 t0 _; `: T; z; y/ E! X3 ]/ ?
15. 
    , }( j4 D. M2 u7 ^# h% w: v
16.                     OLED_Refresh_Gram();
    
17.             
    
18.                         OLED_ShowNumber(0,20,OpenMV_Rx_BUF[2],3,12);
    
19.                         OLED_ShowNumber(20,20,OpenMV_Rx_BUF[4],3,12);
    ) T2 v' I7 \0 D3 _
20.                         OLED_ShowNumber(40,20,OpenMV_Rx_BUF[6],3,12);
    
21.                         OLED_ShowNumber(60,20,OpenMV_Rx_BUF[8],3,12);
    ) I/ B4 Q0 [& y
22.                         
    # R/ A, S6 z/ j9 ]  ^' X# H, i
23. 
    + ~. q# @6 E. K" K$ q
24.         }
    ; ^; S1 z3 f* [( }# \; e
25. }

复制代码

前面就提到了，由于我数据包的格式设置问题，存入OpenMV_Rx_BUF[] 数组中的数据，真正有效的是第3、5、7、9位（因为选择了h类型数据格式，一个数据占2位）。
3 K0 F# Z; a; F8 z6 F
总结
2 b: y; f% `/ K2 E+ m' @博主我之前数据一直发送失败的原因是，博主使用了 uart.write() 这个函数，企图通过 uart.write() 这个函数实现数据发送。
8 H$ a1 p" x8 O9 K" b这个函数在实现OpenMv和PC端的通信上没有问题，可以将数据打在串口调试助手上，但在其与Stm32的通信问题上就存在问题。
, m7 N: f9 e9 S8 n若要使用 uart.write() 实现与stm32的通信，便要使用bytearray()函数将其转化，才可以进行通信。
, k$ y0 L% G" n" O4 u. `6 L
6 b8 z$ P# |% a: Z# f

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

复制代码

* S9 Y& I* A- B/ ]
9 ]- K% ?4 M, C: n, d) w2 i; ^" n