前言
最近一段时间都在捣鼓OpenMV和Stm32的通信问题，刚开始不知道哪里出了问题，一直通信失败，明明使用TTL串口接收OpenMv发送的数据是可以在串口调试助手上显示的，但就是无法发给Stm32的USART串口。经过了差不多一周的时间，终于解决了。于是在这里记录学习记录。
" m/ _5 L* q, w
  f, D" y. C4 ?6 \" q一、OpenMv配置
- ?; \. g. y. J- J( _1.第一种发送方法
. n7 w) J: L6 [  l, l8 Y% XOpenMv代码如下
5 c9 s1 [* K6 ]! a7 X; v% V
" B3 @" |! f5 y2 V% @2 K

1. # Untitled - By: 86188 - 周二 5月 25 2021
     L/ }& D- }2 b7 ~
2. 
   1 n+ R; F6 P9 w( y
3. import sensor, image, time,pyb
   
4. from pyb import UART,LED
   
5. import json
   
6. import ustruct
   ( b0 |6 I8 r* ?/ I2 L
7. 
   
8. 
   8 u% c# S1 l* q7 R" B' g
9. 
   9 F' v6 u9 i  B3 s/ d$ H& \6 ]
10. 
    2 p% i5 i# i  [  D- n* d
11. #white_threshold_01 = ((95, 100, -18, 3, -8, 4));  #白色阈值
    + o: V3 V2 t4 D- p$ Z( j
12. red_threshold_01 = ((2, 51, 11, 127, -128, 127))  #红色阈值
    & w5 o; V2 S# g. n3 ]6 x) L# a  u9 v
13. 
    
14. LED_R = pyb.LED(1) # Red LED = 1, Green LED = 2, Blue LED = 3, IR LEDs = 4.
    8 ?9 |  J- q  q! K2 J" _1 `" M& g
15. LED_G = pyb.LED(2)
    ( P, D: x0 v) e% c% h4 L
16. LED_B = pyb.LED(3)
    , B' k1 h- I0 G. W1 q
17. 
    
18. LED_R.on()
    
19. LED_G.on()
    / i4 A9 {- H  I& W3 ~
20. LED_B.on()
    
21. 
    7 {; x2 [( _( u& N% K7 n
22. 
    0 l; ]4 g- @- t! `2 P1 E; l0 ]( o
23. 
    
24. sensor.reset()
    0 ^" s" o% P" x
25. sensor.set_pixformat(sensor.RGB565)
    0 p1 g; K" |8 z9 j7 M( B0 z
26. sensor.set_framesize(sensor.QVGA)
    
27. sensor.skip_frames(time = 2000)
    5 f. H$ P! c4 Z' s
28. sensor.set_auto_gain(False) # must be turned off for color tracking
    & g0 I9 H2 ]- c) }$ V
29. sensor.set_auto_whitebal(False) # must be turned off for color tracking
    
30. 
    
31. 
    
32. clock = time.clock()
    1 I  b+ x0 {/ S! a* A1 P1 B
33. 
    6 j( x* o" s' Z3 w' ~; U
34. LED_R.off()
    - x+ e% }$ y5 r' S  p
35. LED_G.off()
    
36. LED_B.off()
    
37. 
    
38. uart = UART(3,115200)   #定义串口3变量
    + A9 y$ O/ B  S& T; B1 ]/ `
39. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
    9 d9 ~# T0 ~% ~8 t% T9 m
40. 
    & x' W- x" q# M: O! [, K! L
41. 
    
42. 
    
43. def find_max(blobs):    #定义寻找色块面积最大的函数
    ! u9 Z7 f: B  J  @6 F" U' Y: i: I4 l
44.     max_size=0
    . y- {! m, A) n$ A
45.     for blob in blobs:
    - Y6 V3 g$ _) A% U
46.         if blob.pixels() > max_size:
    " I( ?" Q4 a5 X
47.             max_blob=blob
    
48.             max_size = blob.pixels()
    
49.     return max_blob
    3 ?# L& `' M* X& J% P. N
50. 
    
51. 
    
52. def send_data_packet(x,y,z,w):
    % {* E/ X. m" a7 @+ b; D# Z
53.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
    + \2 s. b/ M) s
54.                    0x2C,                       #帧头1
    / T# F) u+ V/ n
55.                    0x12,                       #帧头2
    . ~8 A5 Y( O3 {+ ^' ~9 a
56.                    int(x), # up sample by 2    #数据1
    + G% u! q5 d0 a5 P
57.                    int(y), # up sample by 2    #数据2
    
58.                    int(z),
    9 q& _- f3 E' b9 j! c9 ~
59.                    int(w))
    " j6 V4 y8 V2 l$ C6 j) Y
60.                    #0x5B)
    
61.     uart.write(temp);                           #串口发送
    
62. 
    
63. 
    5 z+ q. h, g8 A+ C
64. 
    ! z: K  @6 {2 Z  i  j& _. s: R. l# t
65. 
    ( V+ F' z- P" g; Q% p; s& ~
66. 
    9 h4 i- L: T+ D6 b4 v! @$ J/ a3 m
67. while(True):
    
68.     img = sensor.snapshot()
    
69.     #time.sleep_ms(1000)
    ( r7 S6 P! o2 v0 Y6 n& u
70.     #send_data_packet(x,y)
    
71.     blobs = img.find_blobs([red_threshold_01]);
    ; K7 i( j, D2 w  K  R' K
72. 
    # r! c1 N1 G# h$ _
73.     cx=0;cy=0;
    
74.     if blobs:
    
75.                 #如果找到了目标颜色
    
76.                 max_b = find_max(blobs);
    $ z+ z3 z, X+ s% |% R8 d
77.                 # Draw a rect around the blob.
    
78.                 img.draw_rectangle(max_b[0:4]) # rect
    
79.                 #用矩形标记出目标颜色区域
    2 U/ }; D; n7 S
80.                 img.draw_cross(max_b[5], max_b[6]) # cx, cy
    " q5 t% B1 \( I2 d5 }/ _% B  _: g
81.                 #img.draw_cross(160, 120) # 在中心点画标记
    
82.                 #在目标颜色区域的中心画十字形标记
    + G6 [; o# T0 x# u% c
83.                 cx=max_b[5];
    * S& S9 d" r( o  q" n, w
84.                 cy=max_b[6];
    
85.                 cw=max_b[2];
    , _9 B7 t* t* P+ r- n1 S
86.                 ch=max_b[3];
    
87. 
    4 I; N8 D. K6 p' X8 |( l, E$ P
88.     #data = bytearray([x,y])
    ; H, p; \- l( a( M
89.                 send_data_packet(cx,cy,cw,ch)
    
90.     #time.sleep_ms(1000)
      d% P; @2 ^. \8 k! z9 U" ~

复制代码

. n; |' J5 ]+ m" [  |代码作用：OpenMv使用的是python语言编写，而这段代码的主要目的就是在openmv视野种寻找红色色块，并将其中点坐标发送会Stm32，并在OLED屏幕上显示。
& o, [" j- k, F: ~4 m8 Z& o& C
: q# l5 Z3 f0 B# I$ M2 t2 j7 j主要通信函数如下
( `7 w! [' I* Y+ o1 M: b4 T6 Y

1. def send_data_packet(x,y,z,w):
   3 N8 U* U) E1 G8 A( A
2.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
   8 a6 `; R. w# u, G- m7 I/ k5 D
3.                    0x2C,                       #帧头1
   
4.                    0x12,                       #帧头2
   
5.                    int(x), # up sample by 2    #数据1
   
6.                    int(y), # up sample by 2    #数据2
   5 A: X2 m# p3 @2 E2 \
7.                    int(z),
   ! X% C8 u  Z. |- v0 ~: a, a/ v
8.                    int(w))
   
9.                    #0x5B)
   , F5 }/ c3 ^+ F: v) L
10.     uart.write(temp);                           #串口发送

复制代码

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

1. #pack各字母对应类型
   $ a7 y1 j# I% X3 x0 O5 J4 Z
2. #x   pad byte        no value            1
   
3. #c   char            string of length 1  1
   
4. #b   signed char     integer             1
   4 W7 n& Z( B4 J7 B4 A2 Y4 q
5. #B   unsigned char   integer             1
   2 I/ ~- O+ s5 o2 n4 A3 [3 F8 U
6. #?   _Bool           bool                1
   . n: Q: q4 U- z$ t8 w" _
7. #h   short           integer             2
   * Y. L" L" v! H
8. #H   unsigned short  integer             2
   
9. #i   int             integer             4
   8 J. \2 [- C  ?# c, |
10. #I   unsigned int    integer or long     4
    ( m9 H- f0 G, D; H% x' u
11. #l   long            integer             4
    0 g# T  o0 q! ?- z, A( Q2 {7 @
12. #L   unsigned long   long                4
    
13. #q   long long       long                8
    0 G  R' @  g- V. G$ h
14. #Q   unsilong long   long                8
    
15. #f   float           float               4
    
16. #d   double          float               8
    , h0 k  r( R% m) ~6 T2 {7 c
17. #s   char[]          string              1
    
18. #p   char[]          string              1
    
19. #P   void *          long

复制代码

/ p9 h: v, w" q' o' C. t! F: e3 e对于此处我所使用的"<bbhhhh",
( F" V* o) c1 o# y# X4 T第一个第二个数据为包头，便是b，字符串类型。而后面开始为数据格式，我选择的是h也就是短整型，传输给Stm32的时候，便是两个字节的数据格式。
如图，一串完整的数据便是 2C 12 36 00 80 00 2E 00 9D 00。
6 u- u% D0 q: W- y* q
7 ~* {7 H8 U- z, }9 b( [; f( @

2.第二种发送方法
除了以上这种以包（pack）的方式发送给stm32外，还可以使用另外的一种方法发送：

1. def send_data(cx,cy,w,h):
   
2.     datalist = [ 0x2C,0x12,cx,cy,w,h]
     R0 c1 c/ D) Z+ d1 G3 u
3.     datalist.append(sum_checkout(datalist))
   * F. H" G% u5 K1 c" {
4.     data = bytearray(datalist)
   7 N& {- s4 h8 g" o& F5 m4 \
5.     return data
   
6. 
   9 `) m3 Q8 {' J% P2 m: `6 I
7. #检验数据和  
   8 U. R1 f* p6 Q& F; @3 T
8. def sum_checkout(data_list):
   7 J$ U) o$ I+ J9 V5 F
9.     data_sum = 0
   
10.     for temp in data_list:
    % e; X' |" m9 l; F4 }6 F7 z3 y
11.         data_sum =  data_sum + temp
    8 L: s6 N2 U6 X4 a" X  i
12.     return data_sum

复制代码

这段代码和之前不同的是：我将0x5B 最后一位的数据校验位改成了用sum_checkout() 这段函数求和取余的方法作为该数据的数据校验位。
但是使用这样不封包的方法发送，就必须加上data = bytearray(datalist)，将数据转化，才可以进行通讯。
. K4 M# ?7 f5 L, O
; C2 `. \) v- ~# b0 |二、Stm32配置
: k: i/ L% ^, C# D/ p5 `Stm32的USART1配置如下：

3 h7 F4 g0 Q0 ]3 I% Q1 g2 L+ G, k; S! k

1. 
   
2. u16 USART_RX_STA=0;       //接收状态标记         
   ) \! G  \3 V& [" I1 B
3. 
   
4. void uart1_init(u32 bound){
   
5.   //GPIO端口设置
   
6.   GPIO_InitTypeDef GPIO_InitStructure;
   
7.         USART_InitTypeDef USART_InitStructure;
   
8.         NVIC_InitTypeDef NVIC_InitStructure;
   
9.          
   2 t9 p* S' I1 J+ i
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    5 u3 l2 I2 ]8 o8 u8 }, t5 L! ]
11. 
    9 f" I4 D7 \: Z
12.         //USART1_TX   GPIOA.9
    
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    6 G* P% ^' P! m/ g5 N, j: w" m+ P
14.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    * a* [5 ^# o4 ^% E3 Z) G
15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    ( X9 y9 R3 D3 [( \" l' M' w+ O
16.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    $ |. E8 U# A5 s! \& K: k
17. 
    
18.   //USART1_RX          GPIOA.10初始化
    , q  N( W; S) L& W! Y" S
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    % h/ Q4 E- K: \
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    : |# X( C( Z. ~3 O1 z' ?6 n
21.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
22. 
    
23.   //Usart1 NVIC 配置
    ) B' h) n9 d0 _2 P$ S4 R; D- z
24.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
      K3 I4 W7 [3 \; c) c
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    ! o7 o) C% }4 I
27.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
28.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
29. 
    & ?9 m) }1 a, |& U5 Y
30.    //USART 初始化设置
    # {9 F2 N- l- R& s
31. 
    
32.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    4 @/ C" p, ~5 j% M! g9 J
34.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
35.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
36.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    1 u/ Y5 E& ^. @$ H
37.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
38. 
    
39.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    8 u% Y! p. O9 @7 q3 j/ b5 R  V
40.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
41.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
42. 
    
43. }

复制代码

相比于平常配置并未存在较大差别，而实现通信的重要步骤是在USART1的串口接收中断中。

1. void USART1_IRQHandler(void)
   
2. {
   ; j( d2 p, ?" i( p
3.                 u8 Res;
   
4. 
   - G! _/ v' |2 n; C# y
5.                 static u8 Rebuf[20]={0};
   " B. Z7 t8 |# F' |
6.                 static u8 i = 0;
   * @& Y  ]- B9 I: z
7. 
   7 `$ L( c$ K2 [8 _3 r  Z9 b) Z+ T
8.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET )
   
9.         {
   , U7 M7 _( z$ r; m% ]% m) z
10.                 Rebuf[i++] = USART_ReceiveData(USART1);
    ; a1 ?! x) K' e. m
11.                 if(Rebuf[0] != 0x2c)
    # E  N+ y5 P& q+ w
12.                                 i = 0;
    
13.                 if((i==2)&&Rebuf[1] != 0x12)
    0 D( u  K+ t: F2 j) R7 f- j5 U
14.                           i = 0;
    
15.                         if(i>=10)
    3 |1 @( w  H5 s9 j4 j4 K
16.                         {
    
17.                                 memcpy(OpenMV_Rx_BUF,Rebuf,i);
    
18.                                 i = 0;
    7 B5 w: \7 }: A  v
19.                         }
    " j5 v# n( f# N
20.                         USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除中断标志
    . l0 |3 D$ c/ x% X0 C9 ]" ?( a
21.         }
    
22. 
    2 C! p. {) N9 t, h
23. }

复制代码

) Z4 X: t. e# {7 d其中定义了一个OpenMV_Rx_BUF[20]的数组来接收openmv发送过来的数据，需要使用extern修饰这个变量，以便于事项后续操作。
同时memcpy（）函数也是十分重要的一个内置函数，可以实现两个数组的拷贝任务。

主函数的代码如下：

. f* D8 ~: x4 @+ I3 g& S

1. int main(void)
   # e! M/ i, V) p: P" W
2. {               
   ; N8 @. S& ?# T3 \4 a8 J4 m' ^( u
3.          
   
4.         delay_init();                     //延时函数初始化         
   4 d0 L% y7 K. W# u9 t
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   
6.         uart1_init(115200);         //串口初始化为115200
   
7.          LED_Init();                             //LED端口初始化
   - e: p( z# X) {
8.         OLED_Init();
   7 C4 g. {$ A- z2 N- @& ]: J+ n
9.         
   2 G8 z: }: R! I. c" L/ ?" z
10.         while(1)
    # {0 J& f! w# H+ x- [, M2 s
11.         {
    2 f4 v' k. W9 ?. ]* s0 B( n
12.                         
    " U  |& ?( o# ~: H* s1 a7 p
13.                         LED0=!LED0;
    - Y) S) A6 e- c" \
14.                         delay_ms(200);
    
15. 
    
16.                     OLED_Refresh_Gram();
    ! G! S$ @3 r" }% Z* C* H% `3 S
17.             
    # f) n; }; q# X+ v/ b* W1 `, I
18.                         OLED_ShowNumber(0,20,OpenMV_Rx_BUF[2],3,12);
    8 e0 ]$ N6 O, B. d! `
19.                         OLED_ShowNumber(20,20,OpenMV_Rx_BUF[4],3,12);
    
20.                         OLED_ShowNumber(40,20,OpenMV_Rx_BUF[6],3,12);
    
21.                         OLED_ShowNumber(60,20,OpenMV_Rx_BUF[8],3,12);
    7 C9 h6 Y& ^- U* b
22.                         
    
23. 
    
24.         }
    2 L  e% q. I5 n; l$ K
25. }

复制代码

前面就提到了，由于我数据包的格式设置问题，存入OpenMV_Rx_BUF[] 数组中的数据，真正有效的是第3、5、7、9位（因为选择了h类型数据格式，一个数据占2位）。
/ O1 x" `2 y8 z3 ^7 o0 m/ |- m
) w6 ^+ V: J! }( y% J8 B总结
% y4 t! [* D, E+ F3 w博主我之前数据一直发送失败的原因是，博主使用了 uart.write() 这个函数，企图通过 uart.write() 这个函数实现数据发送。
) Y5 D' ^6 k4 c9 m$ c' Q' ~* n这个函数在实现OpenMv和PC端的通信上没有问题，可以将数据打在串口调试助手上，但在其与Stm32的通信问题上就存在问题。
若要使用 uart.write() 实现与stm32的通信，便要使用bytearray()函数将其转化，才可以进行通信。

9 ~3 p' z: l6 _

1.     FH = bytearray([0x2C,0x12])
     t( l' u5 \) M0 Q
2.     uart.write(FH)

复制代码