前言
' ^5 h9 @' B! t* Z/ _我们使用Openmv中的特征点检测进行数字识别，并通过设置红色阈值实现巡线，最后通过串口通信将数字及红线坐标发送给主控芯片。

& g; t" ^& S& p* ?# x5 t一、Openmv实现数字识别
对于数字识别，一开始我们使用的是模板匹配，后来发现实现过程较为繁琐，且准确率不如特征点检测，故最终采用特征点检测的方法识别

* X  H8 S* Z8 K& J5 n% U$ ^9 q1.这里简单讲一下我们使用模板匹配的思路：
        我们首先采用方框检测，将数字卡片的外边框找到，再对外边框内的图像进行模板匹配，这样做的准确度确实是要比采用整张图像要好得多，但这种方法也有一个非常大的弊端，由于一些外界的干扰，方框大小很容易小于我们采集的模板大小，导致程序不能正常运行，虽然我们适当增加了roi的宽度和长度，但仍会发生这种错误。后来我们经过测试发现，特征点匹配可以达到我们想要的要求。
0 K1 Z. G. D8 |# m8 ^
附上部分代码：
4 J. k$ ^4 o8 q0 S% w, l2 s( J

1.     for r in img.find_rects(threshold = 10000):
   7 D" B8 u7 P( o0 m- E0 |
2.         img.draw_rectangle(r.rect(), color = (255, 0, 0))
   0 Y0 d2 r1 s# i. i' h' ^
3.        # in r.corners(): #img.draw_circle(p[0], p[1], 5, color = (0, 255, 0))
   
4.         if r:
   4 }6 |4 j; @2 b; }- ?1 i
5.             if r[2]<69 or r[3]<75 or r[2]>300 or r[3]>180:#如果小于模板图像的大小，那么ROI设置为整幅图像
   4 c# @( J6 S/ k  X5 O
6.                  template[0]=0
   
7.                  template[1]=0
   
8.                  template[2]=320#宽度要调
   
9.                  template[3]=240#高度要调
   ) X, Q' L1 v/ r) \/ Y
10.             else:
    
11.                 template[0]=r[0]
    4 z( o$ P' d/ ]3 Q9 H! S
12.                 template[1]=r[1]
    
13.                 template[2]=r[2]+5#宽度要调
    
14.                 template[3]=r[3]+5#高度要调
    1 F5 T. B9 z8 F, i. P
15.             print(template)
    
16.         #近端
    " @; c& r8 @6 T  ^% ]/ L1 ?1 Z
17.             for n in templates1:
    # |+ f! F: {, g2 I
18.                 template1 = image.Image(n)
    
19.                 #对每个模板遍历进行模板匹配
    % M* ?) X% F) G8 v3 Z1 d2 i
20.                 r1 = img.find_template(template1, 0.70, step=4, search=SEARCH_EX,roi=(template[0], template[1], template[2], template[3])) #, roi=(10, 0, 60, 60))
    , F2 U& J# X' V3 I* D+ a9 I
21.         #find_template(template, threshold, [roi, step, search]),threshold中
    
22.         #的0.7是相似度阈值,roi是进行匹配的区域（左上顶点为（10，0），长80宽60的矩形），
    
23.         #注意roi的大小要比模板图片大，比frambuffer小。
    7 A; T. p" Q" F
24.         #把匹配到的图像标记出来
    
25.                 if r1:
    
26.                     #img.draw_rectangle(r1)
    ' I; n  L6 q/ o8 l+ ~& D' n0 X
27.                     d="1"
    
28.                     x=r1[0]
    ; F% G% E3 i; U- G; O7 A
29.                     y=r1[1]
    
30. 
    
31.                 else:
    ; F- s+ f* P& W: w0 [5 M7 o
32.                     d="NO NUM"
    : W9 C- k9 L% U3 o, a6 p- L
33. 
    
34.                 img.draw_string(x,y, d, scale = 2, mono_space = False,
    9 l  ^( E; `) E; U4 o  W" b! Z0 r
35.                                 char_rotation = 0, char_hmirror = False, char_vflip = False,
    & F! M3 b& v  T
36.                                 string_rotat

复制代码

8 Y& N3 K6 k5 Q& h( }" N1 v. O5 S2.我们利用特征点检测的思路：
& O$ d; ~/ q3 _  j* u( m        对于特征点检测，我们通过检测图像特征点，并与我们保存在SD卡的模板进行比对，找到满足特征点数最多的那个模板，即为我们要找的数字，然后我们通过比对一定次数，选出比对成功次数最多的那个数字，作为我们最终的识别结果。在小车对于任务的实现中，我们给出以下思路：
- x/ z9 y2 R, C- Q9 Y# A( g$ u
        因为近端病房只采用数字1和2，所以我们便想到了一个策略：当识别到为近端病房时，只对数字1和2的特征点进行比对，当远端病房时，对其余数字进行特征点比对，这样很大程度上增加了我们识别的准确性。

部分代码如下：
( C' r' x, \3 ~4 P4 t2 [- c

1. if describe_Times<15:
   
2.     kpts_run = img.find_keypoints(max_keypoints=220, threshold=1, normalized=False)
   
3.     match1 = image.match_descriptor(kpts1, kpts_run, threshold=85)
   + v+ N( r) \3 j5 d+ D
4.     match2 = image.match_descriptor(kpts2, kpts_run, threshold=85)
   
5. 
   
6.     match3 = image.match_descriptor(kpts3, kpts_run, threshold=85)
   
7.     match4 = image.match_descriptor(kpts4, kpts_run, threshold=85)
   , T1 X3 P5 t0 b5 z/ g( X2 A
8. 
   * X. p: [; g- c0 p! N6 P
9.     match5 = image.match_descriptor(kpts5, kpts_run, threshold=85)
   , b: z! v% p0 q3 U0 Y
10.     match6 = image.match_descriptor(kpts6, kpts_run, threshold=85)
    ' g8 n, ^1 L. x, s$ a8 s
11. 
    ! }1 x" x/ T1 x
12.     match7 = image.match_descriptor(kpts7, kpts_run, threshold=85)
    4 f5 {% i5 H& t. Z1 W
13.     match8 = image.match_descriptor(kpts8, kpts_run, threshold=85)
    % N) p. e  K; V# |
14. 
    
15.     match1_count = match1.count()
    
16.     match2_count = match2.count()
    
17. 
    
18.     match3_count = match3.count()
    
19.     match4_count = match4.count()
    
20. 
    
21.     match5_count = match5.count()
    
22.     match6_count = match6.count()
    
23. 
    + p% g- q# Z" m% o, m7 |5 K  n
24.     match7_count = match7.count()
    
25.     match8_count = match8.count()
    
26. 
    # [/ `: }" p. F0 L
27.     match_count = max(match3.count(),match4.count(),match5.count(),match6.count(),match7.count(),match8.count())#,match3_2.count(),match4_2.count(),match5_2.count(),match6_2.count(),match7_2.count(),match8_2.count())
    
28. 
    2 P& i) c8 i1 F3 Z& X+ K3 J$ Q
29.     if (match1_count == match_count):
    
30.         match1_times=match1_times+1
    
31.         x[0] = match1.cx()
    * h, U. P' ?: c+ K" z
32.         #sending_data(1,x)
    
33.         #print(x1, end = ',')
    & A8 a# V  |  B
34.         print(1,"matched:%d "%(match1.count()))
    
35. 
    , u: l% T4 Y# R: ?
36.     if (match2_count == match_count):
    
37.         match2_times=match2_times+1
    7 v5 s* p0 s: Z: U* _
38.         x[1] = match2.cx()
    9 n2 ^: @0 @( ^3 L- @
39.         #sending_data(2,x)
    ! V) p' Y* a- H! ?  U3 r" u$ M
40.         #print(x2, end = ',')
    
41.         print(2,"matched:%d "%(match2.count()))
    
42. 
    ! e" H7 S, N, H0 H/ W
43.     if (match3_count == match_count):
    
44.         match3_times=match3_times+1
    
45.         t_list[2]=match3_times
    " l# H4 J! a. X7 P; ]
46.         x[2] = match3.cx()
    % l- s8 ?7 M* F4 ^$ |' K1 `+ T
47.         #x3 = match3.cx()
    5 r; W0 u  L- d9 @  ]0 b' _, b* m
48.         #sending_data(3,x)
    ) ^+ l! S( M) E: o. t  `2 w
49.         #print(x3, end = ',')
    
50.         print(3,"matched:%d "%(match2.count()))
    
51. 
    
52.     if (match4_count == match_count):
    3 ?. C/ t1 z8 w# ~/ j0 v
53.         match4_times=match4_times+1
    
54.         t_list[3]=match4_times
    
55.         x[3] = match4.cx()
    
56.         #x4 = match4.cx()
    
57.         #sending_data(4,x)
    
58.         #print(x4, end = ',')
    " G& ]' Y4 k7 `% }
59.         print(4,"matched:%d "%(match4.count()))
    : I: m' X7 h6 L
60. 
    2 m3 t3 x' ?. L/ J
61.     if (match5_count == match_count):
    7 k+ B0 ^6 u9 c+ p3 _
62.         match5_times=match5_times+1
    
63.         t_list[4]=match5_times
    7 O2 W8 U. \+ h; w5 |3 W( c) C3 ^
64.         x[4] = match5.cx()
    + Z6 i+ a# X9 s- _6 r% z6 t7 X7 W
65.         #x5 = match5.cx()
    
66.         #sending_data(5,x)
    4 [! g( M0 t5 v, V8 Y4 b/ L
67.         #print(x5, end = ',')
    
68.         print(5,"matched:%d "%(match5.count()))
    
69. 
    1 i4 i2 u& U; i
70.     if (match6_count == match_count):
    
71.         match6_times=match6_times+1
    $ q8 R2 ?7 o, e! I
72.         t_list[5]=match6_times
    
73.         x[5] = match6.cx()
    5 ]; X8 D9 R! i$ L, V
74.         #x6 = match6.cx()
    
75.         #sending_data(6,x)
    + ^+ q( h$ d/ H, i2 ?) C
76.         #print(x6, end = ',')
    9 V9 S' f0 p3 A4 e3 ~2 a
77.         print(6,"matched:%d "%(match6.count()))
    
78. 
    
79.     if (match7_count == match_count):
    
80.         match7_times=match7_times+1
      y6 v/ P' U" j. P
81.         t_list[6]=match7_times
    
82.         x[6] = match7.cx()
    / D" P1 s, i. H6 v4 ]4 c7 v$ D7 P
83.         #x7 = match7.cx()
    1 O' E$ ]/ a; Y# n' o8 M1 M
84.         #sending_data(7,x)
    
85.         #print(x7, end = ',')
    
86.         print(7,"matched:%d "%(match7.count()))
    
87. 
    5 Y/ g3 D6 }' I' a* t2 C; C7 M$ F! w
88.     if (match8_count == match_count):
    
89.         match8_times=match8_times+1
    
90.         t_list[7]=match3_times
    " h. k5 ?, S$ O, e
91.         x[7] = match8.cx()
    ( R/ w" y  k/ D# }9 g4 c5 y- }
92.         #x8 = match8.cx()
    / q% y0 X7 J& Y0 ~
93.         #sending_data(8,x)
    5 K, U, v& U0 }$ O4 H2 p
94.         print(8,"matched:%d "%(match8.count()))
    
95. 
    
96.     describe_Times=describe_Times+1
    
97. else:
    - @) _' X7 u/ }: H8 R* y& u
98.     turn_num=t_list.index(max(t_list))+1
    
99.     sending_data(turn_num,x[turn_num])#数字和坐标
    # Z7 \; u1 d( \6 _) t7 `! n: W
100.     print(turn_num,x[turn_num])
     + |& ?) T7 q6 k" \& b! L: b5 t' _
101.     break;
     

复制代码

/ p5 X2 A) E( J- N/ C4 U二、巡线
1.基本巡线
8 s+ ~6 d, `. {思路：将摄像头一帧图片的上半部分划分为三个平行的感兴趣区，在三个感兴趣区中分别寻找最大的红色色块，获得三个中心坐标，然后给予其不同的权重后计算平均质心坐标，用此质心坐标计算得到巡线时的偏转角度。

      为什么只将一帧图片的上半部分？因为下半部分容易受到小车的阻挡或者阴影干扰  
7 w* @$ `! ?/ b) G
附上部分代码：

1.     img = sensor.snapshot()
   
2.     for r in ROIS:#在划分的上半图像中找红线
   
3.         blobs = img.find_blobs(RED_THRESHOLD, roi=r[0:4], merge=True) # r[0:4]是感兴趣区域的矩形元组.
   1 R  d* |7 H: Z) s
4.         if blobs:
   
5.             # Find the blob with the most pixels.
   . V. W) R0 a4 |2 R+ r' [
6.             largest_blob = max(blobs, key=lambda b: b.pixels()) # 在blobs中找最大像素值
   
7.             img.draw_rectangle(largest_blob.rect())
   
8.             # 将此区域的像素数最大的颜色块画矩形和十字形标记出来
   9 |% V6 |0 _* e/ k; O/ }, x9 E4 \
9.             img.draw_cross(largest_blob.cx(),largest_blob.cy())
   
10.             Moban_flag=1
    
11.             #print(largest_blob.cx())
    
12.             centroid_sum += (80-largest_blob.cx())*r[4] # 最大值像素点的x坐标*权值 与 图像中心线的偏差值
    
13.             weight_sum = weight_sum + r[4] #权值综合
    : m* Z+ ?, F! E! V+ L) J
14.             #计算centroid_sum，centroid_sum等于每个区域的最大颜色块的中心点的x坐标值乘本区域的权值
    ( ^  N1 Y: w. L8 ]: ^, Y
15.     if weight_sum:
    5 k4 l+ u0 G* @. T6 q' c
16.         center_pos = (centroid_sum / weight_sum)
    ! r/ B. [% M4 k: @$ p5 ]. p) \
17.         weight_sum = 0
      F) I0 V9 s; Y! k4 s0 W
18.     deflection_angle = 0
    % S* s. H' R4 n8 N
19.     ns = center_pos/60  # QQVGA 160x120.
    
20.     deflection_angle = -math.atan(ns)
    $ ?% A& u: T0 j1 r7 p, ]% _
21.     deflection_angle = math.degrees(deflection_angle)
    
22.     deflection_angle = 0 - int(deflection_angle)
    ) Z8 `5 T( ?' w; d* j) l1 r6 M
23.         #print(str(deflection_angle))
    
24.     ##------------------------------------------ 直行 ----------------------------------------------------
    " F2 y! \" b9 I0 M$ T% `
25.     #uart.write(" ")
    . z) h$ q4 X1 Y) G- n; o
26.     #uart.write(str(int(deflection_angle)))
    : A8 O# ?! d" ?! G3 C, c7 `
27.     #uart.write(".")
    , h' x1 K' ?+ u$ M! A* ~0 f$ v
28.     sending_data(0,deflection_angle)#发送偏移角度

复制代码

2.识别十字
: @3 r  k" _% e/ c$ b3 u$ ^我们通过判断图像左上方以及右上方区域是否有红线对十字进行识别，若左上角和右上角都有红色部分，那么我们认为小车到达十字路口处。

部分代码：

4 v( x; N& _/ Y, z# @- w- w

1.     ROI = [(10,0,40,50),(110,0,50,50)]#x分别为10和110，Y为0
   2 t$ R! ], O  J3 P( a
2.     blobs1 = img.find_blobs(RED_THRESHOLD,roi = ROI[0],area_threshold=150,merge=True)#先找左上角红线
   
3.     if blobs1:
     D* w/ E+ o) ?. y6 |. _: \5 W# A4 v
4.         blobs2 = img.find_blobs(RED_THRESHOLD,roi = ROI[1],area_threshold=150,merge=True)
   
5.         if blobs2:
   
6.             print("+")
   ) Q% t7 A  @" I# q* X0 Y
7.             sending_data(10,10)#表示识别到十字

复制代码

三、串口通信
1.数据打包
有些同学可能会问为什么不直接通过串口发送字符串然后使用sscanf来解析呢呢？
9 N: \. Q2 b9 O7 E& c# m
        串口发送字符串（ASCAII编码）的方式比较简单， 用C语言的sscanf()语句解析从语法上是完全可以的， 但是在实际工程上测试，解析不是很稳定，易丢数据。 ASCAII编码易出错，缺乏纠错功能。所以我采用二进制传输的，整数直接发送，浮点数放大去除小数位，然后以C语言的int，short，char的拆分逐8位形式逐位发送。 接收以后先计算校验累加，再重组。这种方式长期使用稳定可靠。
    这样发出来的数据（int,short型）都是低位的字节在前，比如发送整型数9，得到的数据为（0x09 0x00 0x00 0x00）

1 k8 y" ?1 b' }) b附上代码：

% |% F, O& f) |* N- X

1. def sending_data(data1,data2):
   $ b/ D) [! z9 L- ?8 O' W2 m- I
2.     global uart;
   
3.     #frame=[0x2C,18,cx%0xff,int(cx/0xff),cy%0xff,int(cy/0xff),0x5B];
   5 K& t, T6 C4 q- R# Q. k& v
4.     #data = bytearray(frame)
   0 P. E+ h/ s" A  F0 X6 @
5.     data = ustruct.pack("<bbii",#<b,              #格式为俩个字符俩个短整型(2字节)
   
6.                    0xAA,#帧头1
   ! W# D% h! ^. o5 M. Z* g
7.                    0xAE, #帧头2
   
8.                    data1,#用于判断
   0 W' U8 R) l+ a1 F
9.                    data2 #数字
   5 c$ E# |6 y& j2 c  I. M
10.                    )
    + ^( y4 j+ y8 t1 X. d- ~  P, ~
11.     uart.write(data);   #必须要传入一个字节数组
    & x3 R9 ^+ _: ^
12. #接收
    
13. def receive_data():
    
14.     global uart
    9 T1 H$ I; I# N6 P0 i) |9 S5 a5 ~+ N
15.     if uart.any():
    
16.         tmp_data = uart.readline();
    ' x% E+ {% Q8 E0 z6 ]# G5 a* j5 R
17.         return tmp_data;
    
18.         #print(tmp_data)
    9 x- |9 ^, [* o" d0 e

复制代码

1 L; ]5 F. C( I+ F2.Openmv及STM32的串口通信
: t  ~' [3 Y. S/ X& {% k直接附上STM32解码代码：
4 Z# i$ ?# e7 }/ E9 j
, p# M, ^/ r  l

1. void Optical_Flow_Receive_Prepare(u8 data)
   
2. {
   
3.     /* 局部静态变量：接收缓存 */
   
4.     static u8 RxBuffer[10];
   
5.     /* 数据长度 *//* 数据数组下标 */
   & A9 ], h5 s- }0 W& [9 E& J
6.     static u8  _data_cnt = 0;
   " A( f: Q! n, q* R6 t; H7 b
7.     /* 接收状态 */
   
8.     static u8 state = 0;
   
9. 
   , D# @( X3 r8 w5 H. L
10.     /* 帧头1 */
    
11.     if(state==0&&data==TITLE1)
    
12.     {
    . ?7 U. i. M% |' ~. z5 C% H
13.         state=1;
    ' _3 u! W1 m, k# J+ B
14.     }
    # Q/ Z3 s" D1 n* G+ u9 `
15.     /* 帧头2 */
    / V' f7 q8 F4 c3 l- {9 }+ I
16.     else if(state==1&&data==TITLE2)
    % f8 D4 A' h8 p5 v" H
17.     {
    , W7 v. {1 x. \, R
18.         state=2;
    3 r" U/ P, M% X( ^. v5 A
19.         _data_cnt = 0;
    , ~8 L2 Q  r( t
20.     }
    
21.     /* 接收数据租 */
    1 _: b, C. ^, I+ {. U
22.     else if(state==2)
    : X- H; ]9 M9 J" m; v9 {
23.     {
    
24.         RxBuffer[++_data_cnt]=data;
    ( X$ g& O5 [( D' D: v
25.         if(_data_cnt>=8)
    
26.         {
    & Z& ?# N" f1 J2 {! L! F$ B- S
27.             state = 0;
    
28.             Data_Processing(RxBuffer,_data_cnt);
    9 O6 B0 ?/ k6 K* k3 [: ^- q! [6 l# `
29.         }
    # S, x6 {- z& a( ^+ h8 E
30.     }
    
31.     /* 若有错误重新等待接收帧头 */
    ( [5 ]4 F( K# s+ ]7 q, D' i' H3 f* n
32.     else
    
33.         state = 0;
    ! C! a8 |9 U6 z, }
34. }
    
35. 
    
36. 
    
37. void Data_Processing(u8 *data_buf,u8 num)
    1 ~6 ^% r& q1 g2 \- r0 o7 p0 U' Z
38. {
    
39.         int theta_org,rho_org;
    
40.     /* 读取偏移角度原始数据  */
    5 B# P( M/ X: {3 f7 z; ]
41.     theta_org = (int)(*(data_buf+1)<<0) | (int)(*(data_buf+2)<<8) | (int)(*(data_buf+3)<<16) | (int)(*(data_buf+4)<<24) ;
    6 l3 @7 x1 g: f/ M
42.     theta_err = theta_org;
    
43. 
    
44.     /* 读取偏移尺寸原始数据 */
    # M5 y. o  J* p0 r; U
45.     rho_org = (int)(*(data_buf+5)<<0) | (int)(*(data_buf+6)<<8) | (int)(*(data_buf+7)<<16) | (int)(*(data_buf+8)<<24) ;
    * y' J* J/ v6 X4 i6 F7 S1 \5 M# w7 {
46.     rho_err = rho_org;
    
47. }

复制代码

. F) e6 T4 I, m总结
Openmv功能强大，不仅可以用来做图像的识别处理，其他大家可以去星瞳科技官网去学习，里面有例程的讲解以及丰富的资料


3 A* H9 u* D* A7 i