前言
- \3 Y2 W9 b, m  g6 o7 J6 z3 q最近一段时间都在捣鼓OpenMV和Stm32的通信问题，刚开始不知道哪里出了问题，一直通信失败，明明使用TTL串口接收OpenMv发送的数据是可以在串口调试助手上显示的，但就是无法发给Stm32的USART串口。经过了差不多一周的时间，终于解决了。于是在这里记录学习记录。
, t; G; U4 r3 R; o: c# b
一、OpenMv配置
( W# o. _: N0 O1.第一种发送方法
* d- U, i2 X- J  B4 J& |1 AOpenMv代码如下

1. # Untitled - By: 86188 - 周二 5月 25 2021
   / E" z. P( Y( {8 P
2. 
   
3. import sensor, image, time,pyb
   
4. from pyb import UART,LED
   . H: r3 a3 N" F2 f8 f
5. import json
   
6. import ustruct
   
7. 
   
8. 
   
9. 
   2 ~2 o+ c3 X6 b# Z
10. 
    
11. #white_threshold_01 = ((95, 100, -18, 3, -8, 4));  #白色阈值
    
12. red_threshold_01 = ((2, 51, 11, 127, -128, 127))  #红色阈值
    ) g: n- }* R% x  ]
13. 
    8 \8 \: z& k( G7 a
14. LED_R = pyb.LED(1) # Red LED = 1, Green LED = 2, Blue LED = 3, IR LEDs = 4.
    ; O) _, Q+ ?+ B; V. R: \5 Y, G
15. LED_G = pyb.LED(2)
    ' k1 k2 [2 u7 A  u$ v4 P1 O, ~) ~
16. LED_B = pyb.LED(3)
    % p2 n& k: R3 ?+ B1 y# Z+ d1 U0 U- {% }
17. 
    " b5 l. m0 Y8 c
18. LED_R.on()
    
19. LED_G.on()
    ! Z: \' \- T2 F1 Y0 J* v$ d3 F  f
20. LED_B.on()
    / O( `- D% `2 D7 p( |- f( R
21. 
    & `2 Z: ]( `. [8 C
22. 
    ; E' o& K5 F% ]0 R6 U6 B8 u0 ]) I6 K
23. 
    
24. sensor.reset()
    / C  n9 z* c! R: D! w9 `8 {
25. sensor.set_pixformat(sensor.RGB565)
    
26. sensor.set_framesize(sensor.QVGA)
      m7 h8 }- V' i+ _2 i5 |' d5 }# m
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
    4 k3 W# D( K* C. n. |, s5 ^0 M
30. 
    & w( I$ W% }2 Y& g- Q& ]
31. 
    
32. clock = time.clock()
    
33. 
    
34. LED_R.off()
    2 {! o2 n& j; h! {  O0 k. e6 J
35. LED_G.off()
    " `6 D* A5 n6 c2 n; m
36. LED_B.off()
    
37. 
    
38. uart = UART(3,115200)   #定义串口3变量
    
39. uart.init(115200, bits=8, parity=None, stop=1) # init with given parameters
    9 x. k9 i) F' W* {% y) l
40. 
    
41. 
    8 G" z* W0 P- b
42. 
    0 K' @2 T$ j6 }: a* a+ ^; q8 A  a
43. def find_max(blobs):    #定义寻找色块面积最大的函数
    
44.     max_size=0
    1 e/ l0 O9 O: N9 [6 Z  G3 o5 [0 v% ?
45.     for blob in blobs:
    + e7 {0 O6 a+ w$ X6 k+ I4 @
46.         if blob.pixels() > max_size:
    ' a& o7 {+ R$ V; @
47.             max_blob=blob
    
48.             max_size = blob.pixels()
    . y6 L# j- q: K5 T/ }8 y2 ^; j
49.     return max_blob
    $ `( G) b& R8 Q
50. 
    
51. 
    
52. def send_data_packet(x,y,z,w):
    
53.     temp = ustruct.pack("<bbhhhh",                #格式为俩个字符俩个整型
    % J( a/ J$ ]# v3 u, `
54.                    0x2C,                       #帧头1
    
55.                    0x12,                       #帧头2
    
56.                    int(x), # up sample by 2    #数据1
    2 `& \  a" f8 S" ]7 n4 V1 \
57.                    int(y), # up sample by 2    #数据2
    
58.                    int(z),
    2 K5 O7 A) B. d! X# h! d6 J
59.                    int(w))
    / s; S3 P' O; O4 F+ L
60.                    #0x5B)
    
61.     uart.write(temp);                           #串口发送
    
62. 
    
63. 
    " ]7 i' {% y4 e0 j
64. 
    1 L, j: ?8 S9 B+ p( }! z1 Z4 L* o
65. 
    
66. 
    
67. while(True):
    
68.     img = sensor.snapshot()
    
69.     #time.sleep_ms(1000)
    ; `0 W* V8 k* M4 X
70.     #send_data_packet(x,y)
    
71.     blobs = img.find_blobs([red_threshold_01]);
    
72. 
    * p5 y& P& v7 K/ N# v3 a
73.     cx=0;cy=0;
    
74.     if blobs:
    $ O" U. T1 [" l/ k
75.                 #如果找到了目标颜色
    6 k+ l/ Q# z9 i  }6 P8 F( p( i, b
76.                 max_b = find_max(blobs);
    
77.                 # Draw a rect around the blob.
    4 A" P8 H- @. W2 F& [
78.                 img.draw_rectangle(max_b[0:4]) # rect
    
79.                 #用矩形标记出目标颜色区域
    ; V# E4 X: b5 r3 \$ n
80.                 img.draw_cross(max_b[5], max_b[6]) # cx, cy
    
81.                 #img.draw_cross(160, 120) # 在中心点画标记
    ; r1 L8 j: g+ r% _/ ]) i
82.                 #在目标颜色区域的中心画十字形标记
    
83.                 cx=max_b[5];
    " Q) ^3 f7 l* q3 i
84.                 cy=max_b[6];
    ! j8 [3 T( O! F* m2 q1 K
85.                 cw=max_b[2];
    # c# G8 l& [1 M4 z7 N
86.                 ch=max_b[3];
    2 u/ _0 U/ ~% Z- l
87. 
    
88.     #data = bytearray([x,y])
    
89.                 send_data_packet(cx,cy,cw,ch)
    6 T" ?8 j# x* [5 I0 i$ {0 E. ]) g- l
90.     #time.sleep_ms(1000)
    

复制代码

5 i2 Z- t4 V! ^  g; [/ _# J  Y3 N代码作用：OpenMv使用的是python语言编写，而这段代码的主要目的就是在openmv视野种寻找红色色块，并将其中点坐标发送会Stm32，并在OLED屏幕上显示。
( A, i1 z$ v4 B* B2 e* C% H: Z
: y9 g9 z7 o) C1 F7 O0 ^8 b主要通信函数如下
2 s7 M) s5 M' 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
   
7.                    int(z),
   
8.                    int(w))
   
9.                    #0x5B)
   
10.     uart.write(temp);                           #串口发送

复制代码

这里使用了数据包的形式发送数据，将一帧的数据包装，并发送给Stm32，此数据包中的包头非常重要，也就是0x2C以及0x12，这两个数据便与Stm32接收中断中进行判断，以确保数据的正确性。
5 [, J6 |/ D  {% ~对于数据包格式，此等的使用规划：
6 K( N, V0 }8 e+ `7 d& i' P
( X; A: V, c! i- ~* Q" `

1. #pack各字母对应类型
   & X- G0 j5 D# G9 H
2. #x   pad byte        no value            1
   ; s" J0 S5 X! }  Q  w, T
3. #c   char            string of length 1  1
   
4. #b   signed char     integer             1
   8 e% Y" Q, E6 ?
5. #B   unsigned char   integer             1
   
6. #?   _Bool           bool                1
   
7. #h   short           integer             2
     H4 c, w# F, o! l
8. #H   unsigned short  integer             2
   . P  X  m6 \2 i5 q1 |* T
9. #i   int             integer             4
   : N* U$ T4 F0 G' b& D# |2 g
10. #I   unsigned int    integer or long     4
    
11. #l   long            integer             4
    
12. #L   unsigned long   long                4
    % g6 r* Y1 u9 f' M0 m  u
13. #q   long long       long                8
    
14. #Q   unsilong long   long                8
    
15. #f   float           float               4
    
16. #d   double          float               8
    
17. #s   char[]          string              1
    
18. #p   char[]          string              1
    % a7 _" t. P. `1 g
19. #P   void *          long

复制代码

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


' k) g6 R; B- v% j2 m8 j& T" O- k3 m
2.第二种发送方法
除了以上这种以包（pack）的方式发送给stm32外，还可以使用另外的一种方法发送：

, I1 x5 r% T- R6 O5 p

1. def send_data(cx,cy,w,h):
   4 o; w4 I0 D5 b; C
2.     datalist = [ 0x2C,0x12,cx,cy,w,h]
   
3.     datalist.append(sum_checkout(datalist))
   9 J: ~9 ]. u- B! W
4.     data = bytearray(datalist)
   
5.     return data
   
6. 
   0 h) ~4 R, C9 p+ F: V
7. #检验数据和  
   * {. j/ K- E0 H! ?5 v9 j  }
8. def sum_checkout(data_list):
   ; E6 K) g. u- w, u: t
9.     data_sum = 0
   
10.     for temp in data_list:
    
11.         data_sum =  data_sum + temp
    
12.     return data_sum

复制代码

# j) ^* ?7 _# @这段代码和之前不同的是：我将0x5B 最后一位的数据校验位改成了用sum_checkout() 这段函数求和取余的方法作为该数据的数据校验位。
但是使用这样不封包的方法发送，就必须加上data = bytearray(datalist)，将数据转化，才可以进行通讯。
# ~: I6 K2 x4 I* u: }. X# x
( ]& u% _7 P5 Q2 R. |" H二、Stm32配置
6 S  X' H; f, ]+ I0 ]Stm32的USART1配置如下：

2 R3 g2 b  I$ C$ x

1. 
   # r8 J4 a" u5 P8 _- A$ S* g3 O
2. u16 USART_RX_STA=0;       //接收状态标记         
   / D) |0 D  S; \$ K5 n- r* |
3. 
   
4. void uart1_init(u32 bound){
   
5.   //GPIO端口设置
   ; A6 g8 h6 p" y/ r8 U6 i
6.   GPIO_InitTypeDef GPIO_InitStructure;
   
7.         USART_InitTypeDef USART_InitStructure;
   # x2 K- X# W7 F
8.         NVIC_InitTypeDef NVIC_InitStructure;
   4 C5 x( H5 `/ b/ l
9.          
   1 @4 D4 g# u7 u# s5 q
10.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    ; g; I  A4 \7 ]3 P1 u
11. 
    ; w* ^$ X" d, I" _5 X6 `
12.         //USART1_TX   GPIOA.9
    , A7 R+ r6 J" E8 C
13.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    ( q' _6 p4 @8 A! e2 v
14.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    $ i: U/ p2 b! y( \$ p+ U. N
15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    % L" l9 e- K. a# S; E
16.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
17. 
    ! T% G+ T( t7 S
18.   //USART1_RX          GPIOA.10初始化
    
19.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    7 f( \+ Y% ^, d
20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    * I8 A2 e5 \. p& f( b* S7 I
21.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
22. 
    ; E, ~; r% _) \' T  K' I
23.   //Usart1 NVIC 配置
    4 Q  C2 o: v9 T& y$ _
24.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
25.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
    . \# H$ }% F5 h- H8 _$ e+ R
26.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
27.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    . l4 B4 f( R% b
28.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    4 {, t. e3 g9 U
29. 
    
30.    //USART 初始化设置
    # Q4 f2 d# G6 f' K7 m& e
31. 
    , B. h+ a0 A6 g
32.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    6 [- Z' o& Z3 N+ F: ?: T+ I/ o* E
33.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
34.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
      ^' c/ ]  E. c
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;        //收发模式
    ! C0 [0 v: K+ t& B8 S9 N# G
38. 
    
39.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    1 T4 Z2 I# A% Q' {, e( \8 c6 B
40.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
41.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    & S6 s$ B: R& h8 Y' D" h# U6 N' @
42. 
    
43. }

复制代码

相比于平常配置并未存在较大差别，而实现通信的重要步骤是在USART1的串口接收中断中。
: {0 o3 U: T/ B4 j& g( V7 G

1. void USART1_IRQHandler(void)
   ' n+ Y' `7 a7 B! I
2. {
   
3.                 u8 Res;
   
4. 
   
5.                 static u8 Rebuf[20]={0};
   
6.                 static u8 i = 0;
   , x9 X+ M8 z0 ^$ P2 U$ w4 n
7. 
   
8.                 if( USART_GetITStatus(USART1,USART_IT_RXNE)!=RESET )
   
9.         {
   : g3 y9 L( g( h: v( b
10.                 Rebuf[i++] = USART_ReceiveData(USART1);
    / |3 q' ?$ p9 k2 O. j+ |8 P
11.                 if(Rebuf[0] != 0x2c)
    
12.                                 i = 0;
    
13.                 if((i==2)&&Rebuf[1] != 0x12)
    
14.                           i = 0;
    7 T( K/ J$ A- K! j4 @
15.                         if(i>=10)
    
16.                         {
    
17.                                 memcpy(OpenMV_Rx_BUF,Rebuf,i);
    ( r: L( ~4 m: v5 Y8 e- @+ N( N
18.                                 i = 0;
    , [7 t, L; W$ H! ~. c0 q+ ^
19.                         }
    
20.                         USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清除中断标志
      {" S  k7 a+ l5 j2 V
21.         }
    
22. 
    $ C, \* o! A/ U% ^/ A0 ^2 c
23. }

复制代码

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

$ l: g8 S- O; y3 ^  i主函数的代码如下：

# v2 R( h7 ~5 a% k

1. int main(void)
   
2. {               
   
3.          
   2 ^" W- Q& N) d
4.         delay_init();                     //延时函数初始化         
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
   / U) O' @4 E* T+ ?
6.         uart1_init(115200);         //串口初始化为115200
   
7.          LED_Init();                             //LED端口初始化
   : f& q, f; _0 i7 w5 ^- Y5 T
8.         OLED_Init();
   ( ^1 t* p. k+ X) f* z
9.         
   ) o' @& N1 b. ?1 c3 V$ i
10.         while(1)
    
11.         {
    . a7 Z! S% Q, e6 w5 p
12.                         
    
13.                         LED0=!LED0;
    . u  O7 l, W* E- u: N/ @3 U. L; x* Y
14.                         delay_ms(200);
    ; ?  t+ v" C# G  w( h5 V
15. 
    4 m$ c2 F1 S  ?2 b+ M8 ]5 E4 I
16.                     OLED_Refresh_Gram();
    : @0 J% z# b$ ]( O
17.             
    4 \; c4 s/ b! d; s% ^. ]* j$ f& _3 a
18.                         OLED_ShowNumber(0,20,OpenMV_Rx_BUF[2],3,12);
    2 C- q2 T1 L" E" B- n
19.                         OLED_ShowNumber(20,20,OpenMV_Rx_BUF[4],3,12);
    
20.                         OLED_ShowNumber(40,20,OpenMV_Rx_BUF[6],3,12);
    " X& X" n: O1 Z3 g: F0 N* ?
21.                         OLED_ShowNumber(60,20,OpenMV_Rx_BUF[8],3,12);
    0 P: }9 s# K) I
22.                         
    0 c2 D3 j4 Y& ?% D" F! p( o
23. 
    " S% E' _9 r8 X" b* ~, u
24.         }
    
25. }

复制代码

, ^. q, i! M) p  s2 P1 @! Q前面就提到了，由于我数据包的格式设置问题，存入OpenMV_Rx_BUF[] 数组中的数据，真正有效的是第3、5、7、9位（因为选择了h类型数据格式，一个数据占2位）。
: j; I! h- g8 g9 X0 V) u  W; Z
, \) i. E* p; g5 R( P! t% V, a总结
博主我之前数据一直发送失败的原因是，博主使用了 uart.write() 这个函数，企图通过 uart.write() 这个函数实现数据发送。
* v  N7 r1 O* |9 A  i6 w这个函数在实现OpenMv和PC端的通信上没有问题，可以将数据打在串口调试助手上，但在其与Stm32的通信问题上就存在问题。
# @% w( C' Z/ E# V5 S若要使用 uart.write() 实现与stm32的通信，便要使用bytearray()函数将其转化，才可以进行通信。

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

复制代码