前言
2 y: l: [% z. n+ v% O最近一段时间都在捣鼓OpenMV和Stm32的通信问题，刚开始不知道哪里出了问题，一直通信失败，明明使用TTL串口接收OpenMv发送的数据是可以在串口调试助手上显示的，但就是无法发给Stm32的USART串口。经过了差不多一周的时间，终于解决了。于是在这里记录学习记录。

一、OpenMv配置
: A  K$ q" a( u7 D1.第一种发送方法
OpenMv代码如下

0 }: N+ a/ D0 b8 @, B

1. # Untitled - By: 86188 - 周二 5月 25 2021
   
2. 
   0 ?9 y0 Q. s" L% q+ d9 S
3. import sensor, image, time,pyb
   $ a: {' z, f7 k+ u' R
4. from pyb import UART,LED
   $ g0 S! ]# h  k- o. u  v. I  K, }
5. import json
   
6. import ustruct
   5 e. b" x! N2 e# d6 t
7. 
   
8. 
   ) M! e% L" v. f) c& N# t% b/ b
9. 
   $ f$ {% P9 x/ M1 m$ y( U5 b. s
10. 
    ! X: l- O- P! K3 ^
11. #white_threshold_01 = ((95, 100, -18, 3, -8, 4));  #白色阈值
    6 N7 s- |$ \! J
12. red_threshold_01 = ((2, 51, 11, 127, -128, 127))  #红色阈值
    # d1 m( r& W0 C3 }: T6 Q: {
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)
    & M6 x" G; F' ~7 p" K
17. 
    
18. LED_R.on()
    
19. LED_G.on()
    * v/ T5 i0 Y0 m! Q6 p9 d8 y0 t% R
20. LED_B.on()
    1 r- p# _4 m6 v5 }( t5 \: h; F
21. 
    
22. 
    9 e* @8 I! R8 `0 H# z; ]4 z, e* l
23. 
    ) }. j4 y! G7 |9 O
24. sensor.reset()
    
25. sensor.set_pixformat(sensor.RGB565)
    ; b# e8 q, q" \: [3 L7 R& D
26. sensor.set_framesize(sensor.QVGA)
    
27. sensor.skip_frames(time = 2000)
    
28. sensor.set_auto_gain(False) # must be turned off for color tracking
    7 Z; T; ?5 n( o. b# Z# h
29. sensor.set_auto_whitebal(False) # must be turned off for color tracking
    
30. 
    
31. 
    5 n. ^- A0 [5 D4 r
32. clock = time.clock()
    
33. 
    
34. LED_R.off()
    
35. LED_G.off()
    6 [: W4 M' {8 B
36. LED_B.off()
    8 M5 H0 n' Z3 T/ b
37. 
    9 w* H) l' E) m
38. uart = UART(3,115200)   #定义串口3变量
    
39. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
    & c0 n& u' F; M0 G; H, G. d& S$ l
40. 
    , q+ f& g# O( A8 K$ S# ]. r% P4 ]+ k
41. 
    
42. 
    
43. def find_max(blobs):    #定义寻找色块面积最大的函数
    
44.     max_size=0
    1 `: \' }- U( E9 v7 v3 K
45.     for blob in blobs:
    
46.         if blob.pixels() > max_size:
    ' q6 d+ Q( v! y, y2 w" e
47.             max_blob=blob
    % V  Q9 S& ?/ k, E7 g/ o; Z
48.             max_size = blob.pixels()
    
49.     return max_blob
    0 A2 m( D+ C9 L
50. 
      K/ p0 o% ~2 h$ H# _8 D. r2 A2 m" d, l
51. 
    
52. def send_data_packet(x,y,z,w):
    
53.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
    
54.                    0x2C,                       #帧头1
    
55.                    0x12,                       #帧头2
    
56.                    int(x), # up sample by 2    #数据1
    
57.                    int(y), # up sample by 2    #数据2
    
58.                    int(z),
    
59.                    int(w))
    7 q: _% @$ g( T4 A& S
60.                    #0x5B)
    
61.     uart.write(temp);                           #串口发送
    ; V* r6 X( e4 g
62. 
    
63. 
    ( `1 G( k2 s# K9 \' t$ a
64. 
    " A- J) G/ W0 w" E9 Z$ x% ~) o
65. 
    
66. 
    
67. while(True):
    4 F, z3 p9 H( b% z! i3 R
68.     img = sensor.snapshot()
    ) b5 B4 t1 K1 s8 t4 f
69.     #time.sleep_ms(1000)
    4 w! E" J- w. T  K+ L* {
70.     #send_data_packet(x,y)
    ' J0 R4 d2 P7 [) @( r1 G
71.     blobs = img.find_blobs([red_threshold_01]);
    # i5 n5 V! y/ @- q
72. 
    ! H, w( p- s" F
73.     cx=0;cy=0;
    7 G4 l! n9 B5 y8 y3 O
74.     if blobs:
    
75.                 #如果找到了目标颜色
    : v5 Y9 I( q9 [& g% x$ x. J
76.                 max_b = find_max(blobs);
    
77.                 # Draw a rect around the blob.
    
78.                 img.draw_rectangle(max_b[0:4]) # rect
    $ s' M  O' Q6 S+ }
79.                 #用矩形标记出目标颜色区域
    
80.                 img.draw_cross(max_b[5], max_b[6]) # cx, cy
    # K6 q# y1 J, m
81.                 #img.draw_cross(160, 120) # 在中心点画标记
    ' a& M9 ^4 V; |/ [3 P8 o; L* Q
82.                 #在目标颜色区域的中心画十字形标记
    ' ^0 [& _: H4 `, P& I: ]
83.                 cx=max_b[5];
    
84.                 cy=max_b[6];
    ( T" y3 t& o  U$ N
85.                 cw=max_b[2];
    
86.                 ch=max_b[3];
    ! s: L9 B  k& @5 j! K
87. 
    
88.     #data = bytearray([x,y])
    
89.                 send_data_packet(cx,cy,cw,ch)
    
90.     #time.sleep_ms(1000)
    

复制代码

2 y  o5 C7 \( w  F代码作用：OpenMv使用的是python语言编写，而这段代码的主要目的就是在openmv视野种寻找红色色块，并将其中点坐标发送会Stm32，并在OLED屏幕上显示。

主要通信函数如下

1. def send_data_packet(x,y,z,w):
   , I7 M# G2 W' o+ w2 i
2.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
   8 S) s" k+ @$ Z5 u
3.                    0x2C,                       #帧头1
   . N* E4 S  e9 m8 H! o
4.                    0x12,                       #帧头2
   
5.                    int(x), # up sample by 2    #数据1
   2 X6 m# J( J& R( S$ p
6.                    int(y), # up sample by 2    #数据2
   
7.                    int(z),
   
8.                    int(w))
   % |) n6 |* j' J, F* u& N4 j( J
9.                    #0x5B)
   4 Q+ ^8 u% G3 o$ {- r
10.     uart.write(temp);                           #串口发送

复制代码

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

1. #pack各字母对应类型
   
2. #x   pad byte        no value            1
   7 u( L: D- u/ G8 h0 W  n
3. #c   char            string of length 1  1
   & Y; h0 L8 i+ [! B9 I8 J- M2 j
4. #b   signed char     integer             1
   
5. #B   unsigned char   integer             1
   & W" m7 b/ v! q: [
6. #?   _Bool           bool                1
   5 @5 {% t( ?+ U1 R: \
7. #h   short           integer             2
   
8. #H   unsigned short  integer             2
   3 y2 Y& K! u* I/ s
9. #i   int             integer             4
   & b% X  ~: r- z9 B# u3 R
10. #I   unsigned int    integer or long     4
    
11. #l   long            integer             4
    . T9 `( ?0 d: t% _
12. #L   unsigned long   long                4
    0 p* l0 {+ u( B* w3 `! b
13. #q   long long       long                8
    
14. #Q   unsilong long   long                8
    0 m- Q( z- F8 B2 b
15. #f   float           float               4
    ) g3 {* o1 E/ V8 w6 L1 x8 H, a
16. #d   double          float               8
    . j$ Y- n: G9 T* C* i' j
17. #s   char[]          string              1
    
18. #p   char[]          string              1
    
19. #P   void *          long

复制代码

$ t1 j9 O. U# `6 p; a对于此处我所使用的"<bbhhhh",
第一个第二个数据为包头，便是b，字符串类型。而后面开始为数据格式，我选择的是h也就是短整型，传输给Stm32的时候，便是两个字节的数据格式。
  R8 i4 i! B/ u' R) }  o如图，一串完整的数据便是 2C 12 36 00 80 00 2E 00 9D 00。
9 B1 a+ c+ M3 o
. Z# f7 k0 Z2 v/ S9 n

% E) A, z/ Z) c7 O7 s! D, Z2.第二种发送方法
除了以上这种以包（pack）的方式发送给stm32外，还可以使用另外的一种方法发送：

1. def send_data(cx,cy,w,h):
   ) _% N4 j' p# U! e" t7 D* c+ s/ L
2.     datalist = [ 0x2C,0x12,cx,cy,w,h]
   ! E. Q( T1 Z; T2 Q9 ^
3.     datalist.append(sum_checkout(datalist))
   
4.     data = bytearray(datalist)
   
5.     return data
   
6. 
   
7. #检验数据和  
   
8. def sum_checkout(data_list):
   
9.     data_sum = 0
   
10.     for temp in data_list:
    6 B& N( Y" q1 d( O+ O
11.         data_sum =  data_sum + temp
    1 t* D2 [. r3 o( T& _
12.     return data_sum

复制代码

  i' J; r. q; f& x4 J# N" z这段代码和之前不同的是：我将0x5B 最后一位的数据校验位改成了用sum_checkout() 这段函数求和取余的方法作为该数据的数据校验位。
但是使用这样不封包的方法发送，就必须加上data = bytearray(datalist)，将数据转化，才可以进行通讯。
/ N% e+ n8 L0 e1 e
7 f# v! i( `. g9 R0 _3 [" a7 \二、Stm32配置
Stm32的USART1配置如下：

: V6 [3 E3 b9 r9 a  K3 R

1. 
   
2. u16 USART_RX_STA=0;       //接收状态标记         
   
3. 
   
4. void uart1_init(u32 bound){
   ) ^6 M# ]- G, a, `3 @
5.   //GPIO端口设置
   & q& G& s" m$ _7 y5 o% c- ~
6.   GPIO_InitTypeDef GPIO_InitStructure;
   
7.         USART_InitTypeDef USART_InitStructure;
   
8.         NVIC_InitTypeDef NVIC_InitStructure;
   
9.          
   4 w  @( ?$ V  J+ B. y! L8 O( V
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
11. 
    ; C$ D" j/ b9 S4 N/ l1 e/ \
12.         //USART1_TX   GPIOA.9
    ( ~- V' A' P  v/ ~5 l* I6 ]6 W
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;        //复用推挽输出
    0 t) i$ {' t) X# B. T  F' P( r* s
16.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
17. 
    
18.   //USART1_RX          GPIOA.10初始化
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    2 ^( i$ A# x% G
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    1 k- h2 U5 u/ c& Q9 M" [
21.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
22. 
    
23.   //Usart1 NVIC 配置
    0 {2 H0 k4 a. k" N8 I/ Y: g5 l9 V
24.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    & T0 T% p; m9 @4 k0 G
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    : q( O- \' b! r  h; F4 V
27.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
28.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    7 L, ^3 h* p4 K" {& r% F# `, X
29. 
    
30.    //USART 初始化设置
    9 o$ E; I9 B$ H) J* P" g
31. 
    
32.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    ( B- I( D. l6 p& p
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
34.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
35.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
36.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
37.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    , `( @3 j* u! v% X4 w8 r: z
38. 
    
39.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
40.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    ) s, t+ [) w- r+ ?* K+ M
41.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
42. 
    ( s4 J  V" U  L' x
43. }

复制代码

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

1. void USART1_IRQHandler(void)
     X8 c, @& Y; T) s. t' U: |
2. {
   
3.                 u8 Res;
   / ?  Y* i' `1 M  a  K
4. 
   2 j* ]: [) L5 B, s
5.                 static u8 Rebuf[20]={0};
   
6.                 static u8 i = 0;
   3 {! p$ ^8 M3 E2 w0 y+ Y6 P. n/ _
7. 
   
8.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET )
   * d% N5 ^& W6 I6 r: y
9.         {
   " a) _- p/ {+ ?! W, b0 n/ w; t
10.                 Rebuf[i++] = USART_ReceiveData(USART1);
    + l7 @1 e1 D! R% d/ X! R/ f
11.                 if(Rebuf[0] != 0x2c)
    
12.                                 i = 0;
    
13.                 if((i==2)&&Rebuf[1] != 0x12)
    / S  W+ P. L1 m; `
14.                           i = 0;
    
15.                         if(i>=10)
    3 D1 ], H6 U% ]' Q( [! E
16.                         {
    
17.                                 memcpy(OpenMV_Rx_BUF,Rebuf,i);
    
18.                                 i = 0;
    
19.                         }
    
20.                         USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除中断标志
    3 U2 ?) Q! j2 ]. P7 N' a- s
21.         }
    # q) f+ v  g- @# {
22. 
    & d6 i0 f/ b1 e# F* t$ y
23. }

复制代码

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

, F+ U) u: [" M主函数的代码如下：

1. int main(void)
   4 i* N$ J+ _. \" c- `% Q" S& V
2. {               
   
3.          
   
4.         delay_init();                     //延时函数初始化         
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   4 A* [1 R8 B& m3 b
6.         uart1_init(115200);         //串口初始化为115200
   
7.          LED_Init();                             //LED端口初始化
   8 p. R3 m' W" w9 a
8.         OLED_Init();
   7 w+ l: O# x* D; R  U1 p, _+ P' A: J
9.         
   
10.         while(1)
    
11.         {
    
12.                         
    * y- X' H& V/ x3 o( f, T
13.                         LED0=!LED0;
    1 A& ]) o2 d2 o2 h9 D4 u0 a
14.                         delay_ms(200);
    & r: a9 [* W$ ]  |2 U3 F
15. 
    - j2 D. o/ I! Q5 r" D% K$ H
16.                     OLED_Refresh_Gram();
    * D7 r' Q  v, s; M
17.             
      z6 L6 Q& Z9 y) D+ I
18.                         OLED_ShowNumber(0,20,OpenMV_Rx_BUF[2],3,12);
    
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);
    
22.                         
    
23. 
    
24.         }
    : B" |6 W! t8 B$ o) ~
25. }

复制代码

) {9 X* Y5 k! D# u9 o8 u前面就提到了，由于我数据包的格式设置问题，存入OpenMV_Rx_BUF[] 数组中的数据，真正有效的是第3、5、7、9位（因为选择了h类型数据格式，一个数据占2位）。
3 x/ c3 Z- u- k7 t$ ]4 h+ z8 ~2 O
总结
. Y; ?& t1 A; s7 N博主我之前数据一直发送失败的原因是，博主使用了 uart.write() 这个函数，企图通过 uart.write() 这个函数实现数据发送。
这个函数在实现OpenMv和PC端的通信上没有问题，可以将数据打在串口调试助手上，但在其与Stm32的通信问题上就存在问题。
' Y/ B, e+ D0 g  o+ R若要使用 uart.write() 实现与stm32的通信，便要使用bytearray()函数将其转化，才可以进行通信。

3 Y5 e, P* p1 |( _  A* u

1.     FH = bytearray([0x2C,0x12])
   % O/ t' C+ E3 C, N+ f
2.     uart.write(FH)

复制代码

  W  y8 u0 c0 \& H: m