历时两周，总算把小车弄好了，总体上来说做的太慢了。自己在32的学习中还不够仔细深入，只是浅面的学习，当真正做一个项目时，暴露的问题就太多了。这次在小车的制作的过程中，遇到了各种各样的问题，软件，硬件，各式各样的问题迎面而来，真的好几次心态崩了。不过还好小车这个项目不只是我一个人在搞，组里的其他成员也在一直在考虑问题，想办法，不断地解决解决，总归小车终于做好了，下面是小车完成图：

: }2 z8 B2 B2 C% @
: c# @8 `, q& @1 p6 h2 i

是有点灵魂接线（·<·）。

( N6 [" u% y" a2 \7 u' n' l
/ t0 t, k5 \' H% K

模块清单

1 V7 Q5 }. W( k% h

• stm32f103C8T6开发板
  
• HC-SR04超声波测距模块X3
• TB6612FNG 电机驱动模块X2
• HC-05主从一体无线蓝牙模块X1
• 智能小车底盘 4WD小车循迹/避障小车 底盘X1
• LM2596S DC-DC降压电源模块X1
• 电源模块3.3V 5V 12V多路输出 电压转换模块DC-DC 12V转3.3V 5V X1
• 12V电池X1
• 杜邦线 Xn
• 转串口模块X1
• ST-linkX1
• 面包板X1
  
  0 c* O5 T: s0 t3 ~: @

. m, v* H  b! c
. M* B4 K2 `# q! S8 W8 B

完成功能

• 超声波避障
  2 G" J* f4 W( e4 B* W+ D: Y# L
• 蓝牙控制
• 走矩形
  
  $ {! b/ |+ |/ K

9 ]; a1 Z) u% q# A2 Z. m7 G
& R. Z: }8 s" b- |$ w1 K

各个模块就不再介绍了，具体介绍大家可以自行百度或者看一下我的前几篇Arduino智能小车博客，里面有简单的介绍。

5 T& U5 M% u( z; l- A+ F& L! N

那么，开始吧。

- t; T- [; ]" a8 |9 D
$ S0 Z* J$ @6 D# U7 m* @" v3 ?/ R+ D

准备工作

, f  S% H! m- `; |

1.首先配置好keil5 c8t6模板（温馨提示：多看看模板的核心驱动，包括sys.h delay.h usart.h等，这些核心文件一定要保证准确无误！）

2.了解开发板和确保开发板无误
( o5 d- z0 C, w( T  P& U3.熟悉怎么用转串口模块和st-link将驱动下载到开发板上。

" Y6 ]) L% v5 O+ r下图示为c8t6开发板的引脚图

) k; d2 g, Z0 A; {0 k+ z; J
  }8 Z! p, W! f; Z5 P
4 \( d7 x) ?& L% ?# i1.超声波避障功能

我们设计的思路如下，用三个超声波来避障。为什么用三个超声波呢？我们想的是如果用舵机的话，小车在行进过程中并不好判断，只能将车停下，舵机转动来检测哪个方向无障碍物，而用3个超声波不仅可以在行进中判断，也可以让小车没有停下的动作，显得整个过程比较流畅。这就是我们使用三个超声波的原因了。

我们使用的是定时器二的通道一，通道二，通道三来进行输入捕获的，那么，第一个问题就来了。

我们在写超声波代码时，用一个超声波先测试，发现超声波测试的并没有问题 ，串口显示的数据也并没有问题。但是，但是，在用三个超声波同时测试是，却发现数据显示的总有问题，输出的数据总是毫无规律，且数字都非常大，我们就在想是什么问题。

! t% t6 b) ^. r) V7 W3 d下面是三个超声波控制的代码：

1. //main.c
   5 ]- @+ L$ M' a  {+ G7 i  B
2. #include "sys.h"
   
3. #include "usart.h"   
   
4. #include "delay.h"  
   
5. #include "led.h"  
   * q; }. L2 y. {% ~3 q8 \& D; Y
6. #include "dianji.h"
   
7. #include "hcsr.h"
   
8. u32 DIS_Init(u8 STA,u16 VAL)
   3 [% e; E) d+ Q1 r6 E  x
9. {
   9 R( C9 N+ ]" Y1 R! y- O0 S
10.     u32 temp;
    
11.     u32 lenth;
    1 S+ }7 M# W% {) X) V1 s' T
12.     if((*STA)&0X80)//成功捕获到了一次高电平
    
13.     {
    
14.         temp=STA&0X3F;
    : Q8 s; j* m3 Q3 D" a2 e* b: `; e
15.         temp*=65536;               //溢出时间总和
    - i* R8 g" L6 b" P
16.         temp+=VAL; //得到总的高电平时间
    7 d  k9 H9 L9 k$ X4 e& ]$ N
17.         lenth=temp*0.017;           //计算长度
    4 u3 x) l  R( c9 a+ J
18.         STA=0;     //开启下一次捕获
    
19.     }
    & j0 m' `+ P5 U3 n$ }
20.     return lenth;
    & ~; ?, ?% D8 {* e) @$ ^- a
21. }
    
22. 
    
23. extern u8 TIM2CH2_CAPTURE_STA; //输入捕获状态
    ' L/ y/ m9 k' F5 B3 s, B4 X
24. extern u16 TIM2CH2_CAPTURE_VAL;  //输入捕获值
    
25. 
    
26. extern u8 TIM2CH3_CAPTURE_STA; //输入捕获状态
    
27. extern u16 TIM2CH3_CAPTURE_VAL;  //输入捕获值
    2 i$ N: P# C: w9 o+ b! a" M% r9 d) v
28. 
    $ [3 D  R% X7 M0 R
29. extern u8 TIM2CH4_CAPTURE_STA; //输入捕获状态
    
30. extern u16 TIM2CH4_CAPTURE_VAL;  //输入捕获值
    
31. 
    5 t+ T( C# K* k5 H: Q9 o
32. int main(void)
    & `# q- p( u6 ~* ^
33. {   
    3 d- r" [! n$ l  K
34.   u32 temp=0;
    
35.   u32 length1;
    
36.   u32 length2;
    . V- V' ^; T; Z0 G; i; r7 S$ i
37.   u32 length3;   
    ; x5 c; Z) U% d# R! }5 V6 m7 r
38.   Stm32_Clock_Init(9); //系统时钟设置
    
39.   delay_init(72);       //延时初始化
    
40.   uart_init(72,9600);  //串口初始化        //初始化与LED连接的硬件接口
    
41.   TIM_PWM1_Init();//10000-1,36-1);//不分频。PWM频率=72M/(0.036M)=2Khz
    7 M; T. o$ Z5 W# `! H* C6 y+ ~
42.   Echo1=0;
    
43.   Echo2=0;
    & V" i  h4 V, ]+ P8 O: [' s
44.   Echo3=0;
    7 u3 v/ U- M5 E1 M
45.   HCSR04_Init(0XFFFF,72-1);//以1Mhz的频率计数
    
46.   /*while(1)
    
47.   {
    & V* l7 ~6 b- `% n3 [
48.    
    
49.   }*/
    
50.   while(1)
    
51.   {
    ; N7 D- |3 G0 C' o
52.     Echo3=1;
    4 ?3 o( c0 _% }! m: C2 s
53.     delay_us(20);
    
54.     Echo3=0;
    * V2 z9 ~! F& Z) _
55.     length1=DIS_Init(&TIM2CH4_CAPTURE_STA,TIM2CH4_CAPTURE_VAL);
    
56.     delay_ms(1000);
    
57.     Echo1=1;
    
58.     delay_us(20);
    4 D8 F. H! P9 D! t5 u* M
59.     Echo1=0;
    ! e' ^+ i. Q, h
60.     length2=DIS_Init(&TIM2CH2_CAPTURE_STA,TIM2CH2_CAPTURE_VAL);
    
61.     delay_ms(1000);
    
62.     Echo2=1;
    2 X5 }- b* L7 n! t8 F  k; L; M3 q
63.     delay_us(20);
    9 R" r5 J, s! E* M
64.     Echo2=0;
    - D, J, p% I$ X) H% w
65.     length3=DIS_Init(&TIM2CH3_CAPTURE_STA,TIM2CH3_CAPTURE_VAL);
    * n* N3 L; y0 Y( |% {' X
66.     printf("%d %d %d\r\n",length1,length2,length3);
    - }4 u- K, U7 C2 s
67.   //  GO();
    
68.     delay_ms(500);
    
69.   }
    0 A3 ?/ K$ R( I& }  K1 K
70. }
    
71. 
    
72. hcsr.c
    
73. #include "sys.h"
    # p% x- ^$ m" G  s/ E7 J
74. #include "delay.h"
    
75. #include "usart.h"
    
76. #include "hcsr.h"
    
77. void HCSR04_Init(u16 arr,u16 psc)
    
78. {
    
79.     RCC->APB1ENR|=1<<0;    //TIM2时钟使能
    . L/ O' w" t2 F, H
80.     RCC->APB2ENR|=1<<2;    //使能PORTA时钟
    
81.     RCC->APB2ENR|=1<<3;     //使能PORTB时钟
    7 \7 J( B( `; t0 B% z, ^
82.     GPIOA->CRL&=0XFFFF000F;//PA1 清除之前设置
    : ]9 Y0 |6 T  q$ b9 Y/ }
83.     GPIOA->CRL|=0X00008880;//PA1输入
    
84. //    GPIOA->ODR|=0<<0;
      w3 o$ \& K  T
85.     GPIOA->ODR|=0<<1;      //PA1下拉
    
86.     GPIOA->ODR|=0<<2;
      Z7 Z- t, G) i+ }; K2 a% P4 o+ ^
87.     GPIOA->ODR|=0<<3;
    
88.   
    
89.     GPIOB->CRL&=0X000FFFFF;//PB7清除之前设置
    / o& ?  `* `2 K8 S$ c/ P
90.     GPIOB->CRL|=0X33300000;//PB7推挽输出
    ; V+ G) e$ ^* s" z* r
91.     GPIOB->ODR|=1<<7;      //PB7 输出高
    + g9 y- ]9 E: ~* |5 s$ j
92.     GPIOB->ODR|=1<<6;
    
93.     GPIOB->ODR|=1<<5;
    
94.   
    " ?6 Z4 s' F' i1 i' ]2 s6 a
95.     TIM2->ARR=arr;         //设定计数器自动重装值
    6 ]6 ~2 A/ a, }% y& e: S
96.     TIM2->PSC=psc;         //预分频器
    
97.   
    
98.     TIM2->CCMR1|=1<<8;     //CC2S=01 选择输入端IC1映射到TI1
    8 P$ ?* l4 E: {" I2 \
99.     TIM2->CCMR1|=1<<12;     //IC2F=0001 配置滤波器 以Fck_int采样，两个事件后有效
    / |8 ~& j1 o' [, |. j( T3 n' B
100.     TIM2->CCMR1|=0<<10;    //IC2PS=00 配置输入分频，不分频
     $ l. t0 L- H; H8 M' A3 E
101.   
     ' f8 G4 O' x4 M. ]+ X0 w
102.     TIM2->CCER|=0<<5;      //CC2P=0 上升沿捕获
     
103.     TIM2->CCER|=1<<4;      //CC2E=1 允许捕获计数器的值到捕获寄存器中
     
104.    
     
105.     TIM2->CCMR2|=1<<0;     //CC2S=01 选择输入端IC1映射到TI1
     
106.     TIM2->CCMR2|=1<<4;     //IC2F=0001 配置滤波器 以Fck_int采样，两个事件后有效
     6 I2 U4 b) E( I" R* J. S
107.     TIM2->CCMR2|=0<<2;    //IC2PS=00 配置输入分频，不分频
     7 c$ A  _5 W  J" r0 }
108.   
     
109.     TIM2->CCER|=0<<9;      //CC2P=0 上升沿捕获
     
110.     TIM2->CCER|=1<<8;      //CC2E=1 允许捕获计数器的值到捕获寄存器中
     
111.    
     
112.     TIM2->CCMR2|=1<<8;     //CC2S=01 选择输入端IC1映射到TI1
     
113.     TIM2->CCMR2|=1<<12;     //IC2F=0001 配置滤波器 以Fck_int采样，两个事件后有效
     
114.     TIM2->CCMR2|=0<<10;    //IC2PS=00 配置输入分频，不分频
     
115.   
     ' J8 e# s  Q* }! k3 v2 e8 m& f7 \
116.     TIM2->CCER|=0<<13;      //CC2P=0 上升沿捕获
     5 i/ w# l% `/ m, H, m. J
117.     TIM2->CCER|=1<<12;      //CC2E=1 允许捕获计数器的值到捕获寄存器中
     0 ]5 y# J& _7 o* n
118.    
     ( g5 s9 j' s! P% p7 Y
119.     TIM2->DIER|=1<<2;      //允许捕获中断
     ' C' Y. g9 n: l: |: _8 [
120.     TIM2->DIER|=1<<3;      //允许捕获中断
     $ J5 z! W. D' X7 c
121.     TIM2->DIER|=1<<4;      //允许捕获中断
     + q, p: j! P3 I9 y) z; P
122.     TIM2->DIER|=1<<0;      //允许更新中断
     
123.     //TIM2->CR1|=0X01;       //使能定时器2
     
124.     MY_NVIC_Init(2,0,TIM2_IRQn,2);//抢占2，子优先级0，组2
     + Q! y; n! W$ r1 T4 z
125. }
     
126. 
     + i' H/ T. Q4 X4 l
127. u8 TIM2CH1_CAPTURE_STA=0; //输入捕获状态
     
128. u16 TIM2CH1_CAPTURE_VAL;  //输入捕获值
     6 t6 ?9 I: P3 A8 P  v
129. 
     ) t3 i3 P5 {0 S) l8 D' B4 q
130. u8 TIM2CH2_CAPTURE_STA=0; //输入捕获状态
     
131. u16 TIM2CH2_CAPTURE_VAL;  //输入捕获值
     0 \! ^/ s( Q, s( h! m9 }0 T6 d$ y
132. 
     
133. u8 TIM2CH3_CAPTURE_STA=0; //输入捕获状态
     6 S7 T, c* z: Y! c- g& u, J
134. u16 TIM2CH3_CAPTURE_VAL;  //输入捕获值
     ; d4 o4 J  S5 t3 I
135. 
     
136. u8 TIM2CH4_CAPTURE_STA=0; //输入捕获状态
     2 `1 j7 \1 {& R, C* o
137. u16 TIM2CH4_CAPTURE_VAL;  //输入捕获值
     
138. 
     # H  P% ]+ k3 l4 u
139. //定时器2中断服务程序
     
140. void TIM2_IRQHandler(void)
     
141. {
     , d; i, ?9 s6 i+ g" y/ I: z5 S
142.     u16 tsr;
     
143.     tsr=TIM2->SR;
     
144.   
     
145.     if((TIM2CH4_CAPTURE_STA&0X80)==0)//还未成功捕获
     . i- a' z1 S. o$ u
146.     {
     
147.         if(tsr&0X01)//溢出
     
148.         {
     
149.             if(TIM2CH4_CAPTURE_STA&0X40)//已经捕获到高电平了
     7 f- U' J! }6 \& w
150.             {
     
151.                 if((TIM2CH4_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
     ; T3 {: P: Q, J+ ^
152.                 {
     ( z, C! p, L+ P1 F4 T& k4 z6 |+ n
153.                     TIM2CH4_CAPTURE_STA|=0X80;//标记成功捕获了一次
     
154.                     TIM2CH4_CAPTURE_VAL=0XFFFF;
       Z) n& L7 E5 F) R( U
155.                 }else TIM2CH4_CAPTURE_STA++;
     
156.             }
     8 u0 G- R5 X( _
157.         }
     ) O& C. [' V) Q; c* ?
158.         if(tsr&0x10)//捕获1发生捕获事件
     6 u% [% b) _/ d, D9 c+ |
159.         {
     
160.             if(TIM2CH4_CAPTURE_STA&0X40) //捕获到一个下降沿
     0 p- `& g( G9 ^+ F' B
161.             {
     
162.                 TIM2CH4_CAPTURE_STA|=0X80; //标记成功捕获到一次高电平脉宽
     
163.                 TIM2CH4_CAPTURE_VAL=TIM2->CCR4;//获取当前的捕获值
     ( R% c$ v  E' W! [
164.                 TIM2->CCER&=~(1<<13);    //CC1P=0 设置为上升沿捕获
     
165.             }else                       //还未开始，第一次捕获上升沿
       w) B1 n& C9 Q
166.             {
     - U  o  k5 _  t) a& K/ F
167.                 TIM2CH4_CAPTURE_VAL=0;
     
168.                 TIM2CH4_CAPTURE_STA=0X40; //标记捕获到了上升沿
     7 h9 @3 h1 l8 F' M8 d1 _- g
169.                 TIM2->CNT=0;             //计数器清空
     
170.           //    TIM2CH4_CAPTURE_VAL=TIM2->CCR4;
     
171.                 TIM2->CCER|=1<<13;        //CC1P=1 设置为下降沿捕获
     * `) c$ a: i( ^* o
172.               TIM2->CR1|=0x01;
     
173.             }
     
174.         }
     + I' o+ Q7 a# O1 _) a! N6 Z
175.     }
     * u0 E4 ]- B3 j" E% [
176.     if((TIM2CH2_CAPTURE_STA&0X80)==0)//还未成功捕获
     
177.     {
     
178.         if(tsr&0X01)//溢出
     
179.         {
     
180.             if(TIM2CH2_CAPTURE_STA&0X40)//已经捕获到高电平了
     
181.             {
     / G. A. {5 Q! h) \; _7 ~3 [
182.                 if((TIM2CH2_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
     
183.                 {
     6 _# l+ R* m2 F
184.                     TIM2CH2_CAPTURE_STA|=0X80;//标记成功捕获了一次
     6 d* @/ W# p( s3 c
185.                     TIM2CH2_CAPTURE_VAL=0XFFFF;
     
186.                 }else TIM2CH2_CAPTURE_STA++;
     
187.             }
     , |* y3 s5 P% p8 t5 ^
188.         }
     
189.         if(tsr&0x04)//捕获1发生捕获事件
     ; p# U+ |# g1 S4 N. ^
190.         {
     % V9 [* f; y. s% l
191.             if(TIM2CH2_CAPTURE_STA&0X40) //捕获到一个下降沿
     
192.             {
     
193.                 TIM2CH2_CAPTURE_STA|=0X80; //标记成功捕获到一次高电平脉宽
     . s+ T+ ^* |" J2 M: F
194.                 TIM2CH2_CAPTURE_VAL=TIM2->CCR2;//获取当前的捕获值
     
195.                 TIM2->CCER&=~(1<<5);    //CC1P=0 设置为上升沿捕获
     1 b+ N, L  y5 v5 _
196.             }else                       //还未开始，第一次捕获上升沿
     
197.             {
     
198.                 TIM2CH2_CAPTURE_VAL=0;
     
199.                 TIM2CH2_CAPTURE_STA=0X40; //标记捕获到了上升沿
     # B; {0 o5 Y- E
200.                 TIM2->CNT=0;             //计数器清空
     
201.                 TIM2->CCER|=1<<5;        //CC1P=1 设置为下降沿捕获
     
202.               TIM2->CR1|=0x01;
     ' F+ a2 Y- i8 j. @
203.             }
     
204.         }
     ' A0 S9 r' |. t
205.     }
     
206.    
     
207.     if((TIM2CH3_CAPTURE_STA&0X80)==0)//还未成功捕获
     
208.     {
     : f" X  f: W, a
209.         if(tsr&0X01)//溢出
     7 W1 r, E8 x" [& T
210.         {
     " Y! b3 Z" O1 x, m
211.             if(TIM2CH3_CAPTURE_STA&0X40)//已经捕获到高电平了
     
212.             {
     
213.                 if((TIM2CH3_CAPTURE_STA&0X3F)==0X3F)//高电平太长了
     
214.                 {
     
215.                     TIM2CH3_CAPTURE_STA|=0X80;//标记成功捕获了一次
     1 _& R' R# ^( \1 ]1 n
216.                     TIM2CH3_CAPTURE_VAL=0XFFFF;
     2 z0 d1 h6 U# H  V
217.                 }else TIM2CH3_CAPTURE_STA++;
     # x! h, ~% M% v
218.             }
     
219.         }
     + X. @; d! p* p& i
220.         if(tsr&0x08)//捕获1发生捕获事件
     ( r! U4 D. g& w" j% F
221.         {
     
222.             if(TIM2CH3_CAPTURE_STA&0X40) //捕获到一个下降沿
     
223.             {
     $ C3 [7 z5 G7 ]9 W( S$ @
224.                 TIM2CH3_CAPTURE_STA|=0X80; //标记成功捕获到一次高电平脉宽
     ( t2 m9 F% s0 o! t7 G% M
225.                 TIM2CH3_CAPTURE_VAL=TIM2->CCR3;//获取当前的捕获值
     
226.                 TIM2->CCER&=~(1<<9);    //CC1P=0 设置为上升沿捕获
     : J4 n$ ]: V' ~' x+ V
227.             }else                       //还未开始，第一次捕获上升沿
     1 {* j/ Q7 a1 I- m% P% F7 `
228.             {
     
229.                 TIM2CH3_CAPTURE_VAL=0;
     
230.                 TIM2CH3_CAPTURE_STA=0X40; //标记捕获到了上升沿
     
231.                 TIM2->CNT=0;  
     
232.             //    TIM2CH3_CAPTURE_VAL=TIM2->CCR3;              //计数器清空
     
233.                 TIM2->CCER|=1<<9;        //CC1P=1 设置为下降沿捕获
     " j+ U5 ?" F0 e" `' ^% y
234.               TIM2->CR1|=0x01;
     + Z! V; z; w- _$ A1 {9 N6 c; X
235.             }
     9 @3 r! y* y% U5 u9 [& A
236.         }
     % i0 C0 C7 d5 j- ^
237.   }
     
238.    
     
239.         
     
240.     TIM2->SR=0;//清除中断标志位
     
241.    
     
242. }
     ' h- k3 v0 f: H5 w( f2 i! ^$ g, N
243. 
     
244. hcsr.h
     
245. #ifndef __HSCR04_H
     0 L, i. u0 p6 e1 e5 P1 f
246. #define __HSCR04_H
     
247. #include "sys.h"
     % [) J1 E5 `: i0 B( x8 h
248. 
     
249. #define Echo1 PBout(7) // PB7
     
250. #define Echo2 PBout(6) // PB7
     
251. #define Echo3 PBout(5) // PB7
     
252. 
     
253. void HCSR04_Init(u16 arr,u16 psc);
     
254. 
     
255. #endif

复制代码

. ~5 `( _  I& ^6 D

最后发现，输入捕获代码中，中断服务函数中，TIM2->CNT不能清零，因为初始化中，用的是同一个定时器的通道2,3,4。如果每一次中断函数的某个通道函数将TIM2->CNT清0，那么其他通道的记录的TIM2->CNT的值就发生变化，从而导致了各种各样的情况。

问题二就是从串口读取数据，当时挺崩溃的。首先是keil5模板问题，当时串口怎么都显示不出来数据，我们当时都很疑惑。一直反复的看代码，考虑各种情况，但还是显示不出来数据。一开始我们以为是超声波接受的反馈的数据不满足某个条件，所以没有显示。到后面查来查去，又在想是开发板并没有给电压？超声波集体歇B？最终发现，usart.c文件写的串口不是我们接线串口所对应的。当时心态挺炸的，改了之后终于可以测试数据了。

* g0 D# M( p8 b7 x2 |0 a$ s" b4 O3 i

问题三是我们在没接电机驱动之前，超声波接收的数据无论准不准确，最起码能接收到，可是接了电机驱动却发现每次返回的值都是0。我们当时并没有找到原因，又在猜想是不是电机用到的定时器对超声波的定时器有影响？又在想是不是外部电子设备把信号影响了？又在想各种各样的问题？

5 I8 N% b/ U: R. V0 N

最终解决的方法是，串口模块给的电压不够。（我也不知道这样形容的对不对，但感觉就是），为什么这样说呢？

0 |' w. ~, o- s' T/ h

当时一开始我想的是，超声波的模块在用转串口模块给其供电时，是不是超声波模块的VCC和GND引脚并没有电压，从而导致信号发射不出去。于是我用万用表测试两侧电压，发现是5V没错。又在想是不是发出信号并没有发去，于是我让TRIG引脚一直为1，测试TRIG电压发现为2.6v左右。在此之后，我又用12v的电池降压给开发板供电，发现TRIG电压为3.3V左右。我想验证，是不是电压问题而导致的接收数据为零。所以我想用电池给开发板供电，然后打开串口监视器看数据。但是要想启用串口监视器，必须要用串口给开发板供电。最后我们选用了蓝牙模块，从手机的接收器来观察数据。终于，果然是电压的问题，数据成功出现了！！！（哭了）

2.用PWM调控电机速度

这一过程能稍微简单一些，就是一开始还是电压的问题，四个轮子根本带不起来。反复查看代码后并没有太多问题，可是轮子还是不转，但是发现电机嗡嗡响，去掉一个电机后，将速度调大，发现两个轮子缓缓的动了。验证时，我们将轮子速度调小，发现轮子不转，证明了代码并无问题。

  K% y* l  ]" n3 X- x  _

pwm控制部分代码：

1. #include "dianji.h"
   
2. #include "sys.h"
   + a3 x5 |7 {- k
3. #include "delay.h"
   
4. 
   * D% r4 T- t- s
5. void TIM_PWM1_Init(u16 arr,u16 psc)
   5 \. ]/ K2 A8 g) x4 o# C2 }
6. {               
   ; _7 Z5 n1 b; c+ s9 H- L
7.   //此部分需手动修改IO口设置
   
8.   RCC->APB1ENR|=1<<1;   //TIM3时钟使能   
   6 A) c9 p% F* D+ o" ]8 p2 }- |4 `( ]
9.   RCC->APB2ENR|=1<<2;    //GPIOA使能
   $ P3 J. |; f# `0 G0 G
10.   RCC->APB2ENR|=1<<3;   //GPIOB使能
    
11.   RCC->APB2ENR|=1<<4;
    
12.   GPIOA->CRL&=0X00FFFFFF;  //PA（7）PA（6）做复用，PA（3）是BIN1 PA（4）BIN2 PA（5）STBY
    * o. {7 P% C/ L% ]- w$ z( \0 t
13.   GPIOA->CRL|=0XBB000000;
    $ i- p2 K6 }9 V, ?" ~
14.   //GPIOA->ODR|=1<<7;
    
15.   //GPIOA->ODR|=1<<6;
    6 }" |* S0 i0 Q6 C3 d+ n! @/ l7 ?( u" g
16.   GPIOC->CRH&=0X000FFFFF;
    
17.   GPIOC->CRH|=0X33300000;
    
18.   GPIOB->CRL&=0XFFFFF000; //PB(0)是AIN1 PB(1)是AIN2
    3 p9 h8 o8 j7 ~
19.   GPIOB->CRL|=0X00000333;
    ' x4 E) B. `, u* o& |; F1 \
20.   TIM3->ARR=arr;      //设定计数器3自动重装值
    ( i: Q8 Y3 B% B) i5 w
21.   TIM3->PSC=psc;      //预分频器设置
    
22.   
    % v6 f! c; t, l' T+ [
23.   TIM3->CCMR1|=6<<4;    //CH1 PWM2模式     
    5 |1 T4 _$ I' W
24.   TIM3->CCMR1|=1<<3;     //CH1预装载使能   
    
25.   TIM3->CCMR1|=6<<12;    //CH2 PWM2模式     
    
26.   TIM3->CCMR1|=1<<11;     //CH2预装载使能  
    ( W4 D9 d- X8 B. ^8 j: \) N
27.   
    ; ~& _& V* `' `( D9 @! [% E7 L1 U
28.    TIM3->CCER|=1<<0;     //OC1 输出使能
    $ ^4 H% \9 L" }% b6 r: q+ c9 d& P
29.   TIM3->CCER|=1<<4;     //OC1 输出使能  
    
30. //  TIM3->BDTR|=1<<15;     //MOE 主输出使能     
    
31. 
    
32.   TIM3->CR1=0x0080;     //ARPE使能
    7 T* N  P( X+ |5 ^
33.   TIM3->CR1|=0x01;      //使能定时器3
    
34. 
    
35.   RCC->APB2ENR|=1<<11; //TIM1定时器使能
    
36.   GPIOA->CRH&=0XFFFF0FF0;
    
37.   GPIOA->CRH|=0X0000B00B;
      l1 y4 s+ _8 l) k- F# R4 p+ Z
38.   //GPIOA->ODR|=1<<8;
    
39.   //GPIOA->ODR|=1<<11;
    , x. j& z8 o8 A5 e5 a
40.   
    ( L2 Y' K7 w) \9 L7 R: y
41.   GPIOB->CRH&=0X0000FFFF;
    8 B( p. v  M; l1 w5 X7 l
42.   GPIOB->CRH|=0X33330000;
    # P9 _& M" t8 ?" P+ A
43.   
    $ ?9 v/ ]3 `# ~. Q
44.   TIM1->ARR=arr;      //设定计数器自动重装值
    - D( o; z! I7 h/ g
45.   TIM1->PSC=psc;      //预分频器设置
    5 [7 J( B$ W* T3 i9 e
46.   
    ) r: L7 }+ }0 n+ ~8 ?% c0 w7 i: Y- S
47.   TIM1->CCMR1|=6<<4;    //CH1 PWM2模式     
    9 I( z$ k& Y8 ?. \7 B
48.   TIM1->CCMR1|=1<<3;     //CH1预装载使能   
    8 G( j% C8 L' x! u- x: X+ j5 N
49.   TIM1->CCMR2|=6<<12;    //CH4 PWM2模式     
    6 h/ {, m& r! {$ T1 M- ~* D1 ~
50.   TIM1->CCMR2|=1<<11;     //CH4预装载使能  
    9 K# |, S% i# }
51.   
    
52.   TIM1->CCER|=1<<0;     //OC1 输出使能
    
53.   TIM1->CCER|=1<<12;     //OC4 输出使能  
    7 N) Q, j2 j$ L2 t4 g
54.   TIM1->BDTR|=1<<15;     //MOE 主输出使能     
    
55. 
    
56.   TIM1->CR1=0x0080;     //ARPE使能
    
57.   TIM1->CR1|=0x01;      //使能定时器1
    
58.   
    , J# q$ J+ ^! @/ ?( P$ f* e6 ?& H
59.   STBY=1;
    
60.   STBY1=1;
    
61. }
    / ^5 \$ e, }7 t7 E% G8 y- g& |
62. 
    
63. void GO(u16 a,u16 b)
    
64. {
    . K) m# C7 k6 v& k4 j& t8 _7 O: p
65.   AIN1=0;     //AIN1，BIN1，AIN2，BIN2控制轮子方向
    1 T8 u. S3 }% ~) d7 x
66.   AIN2=1;
    $ }( X( Q0 V9 T
67.   BIN1=0;
    
68.   BIN2=1;
    - y& X; ?3 Y6 D: R+ H2 u
69.   AIN3=1;
    
70.   AIN4=0;
    ! @' z- f# P* J0 U
71.   BIN3=1;
    : ]) R: v* U3 {/ v
72.   BIN4=0;  
    
73.   
    
74.   TIM3->CCR1=a;//右上，控制速度
    ( J9 P5 R' l1 q' s2 f
75.   TIM3->CCR2=b;//左上
    
76.   TIM1->CCR1=a;//右下
    9 l! }6 h* Q' F, R3 q
77.   TIM1->CCR4=b;//左下
    
78.   //delay_ms(2000);
    , ^2 t- ^/ T8 r! h2 J  C! V5 F
79. }
    ! g. h8 Y$ x. w) Y0 a# }/ E
80. 
    
81. void STOP(void)
    - o+ a- D# t0 Q. Y. y  h8 Q1 Z2 y
82. {
    % ^; f; G5 |, H3 c
83.   AIN1=0;
      p$ r. r; m4 ?* r! E
84.   AIN2=0;
    
85.   BIN1=0;
    
86.   BIN2=0;
    6 h# B1 D+ u* W1 {
87.   AIN3=0;
    
88.   AIN4=0;
    
89.   BIN3=0;
    ' ?0 W8 r. a' ^1 E
90.   BIN4=0;  
    0 Q/ t, X$ m/ L% B* q, J; u0 ]
91. }
    : A+ f" o/ l2 @/ Z+ h! G
92. 
    / D- N, Y2 D+ o* @/ b
93. void BACK(u16 a,u16 b)
    
94. {
    
95.   AIN1=1;
    
96.   AIN2=0;
    
97.   BIN1=1;
    
98.   BIN2=0;
    1 D7 p; c$ n7 G8 I5 Y
99.   AIN3=0;
    
100.   AIN4=1;
     : \! x& I$ C% |/ J8 {
101.   BIN3=0;
     
102.   BIN4=1;  
     
103.   
     
104.   TIM3->CCR1=a;//右上
     1 g4 T) {2 U: d% b
105.   TIM3->CCR2=b;//左上
     : r6 b9 d: H, b/ m1 H4 z, |$ g, Y
106.   TIM1->CCR1=a;//右下
     + j& z) ?7 {9 u! n4 v
107.   TIM1->CCR4=b;//左下
     
108. //  delay_ms(1000);
     
109. }
     6 r/ T2 B) Q4 h9 j! b
110. 
     8 P1 l' a; ~3 X) G+ P0 G
111. void RIGHT(u16 a,u16 b)
     * I5 y/ t% |  V' S8 d2 b
112. {
     8 K% u3 |2 R7 [( B. B
113.   AIN1=1;
     ) I5 Y7 p2 ?% r8 H
114.   AIN2=0;
     & }6 W! {9 d' [. ~6 z' G7 E& P. i2 L
115.   BIN1=0;
     & C9 p% y5 e* T# h0 N) ^
116.   BIN2=1;
     
117.   AIN3=0;
     6 _. \9 B4 k$ {. x" z, C
118.   AIN4=1;
     
119.   BIN3=1;
     
120.   BIN4=0;  
     6 l9 @5 }4 x8 o: n9 B  b
121.   
     
122.   TIM3->CCR1=a;//右上
     
123.   TIM3->CCR2=b;//左上
     
124.   TIM1->CCR1=a;//右下
     / |$ Y+ R( u& L0 Z) \" y
125.   TIM1->CCR4=b;//左下
     
126. //  delay_ms(1000);
     6 N7 d/ O9 f" s( J$ D
127. }
     
128. 
     
129. void LEFT(u16 a,u16 b)
     
130. {
     
131.   AIN1=0;
     $ _' `6 x+ H, i( f5 c' x% T
132.   AIN2=1;
     
133.   BIN1=1;
     
134.   BIN2=0;
     
135.   AIN3=1;
     5 [+ v/ u( o, E
136.   AIN4=0;
     
137.   BIN3=0;
       C$ h; g+ I! k
138.   BIN4=1;  
     
139.   
     
140.   TIM3->CCR1=a;//右上
     . E9 [6 \# ~( G
141.   TIM3->CCR2=b;//左上
     7 ~$ n) r! G! f1 e9 |# k
142.   TIM1->CCR1=a;//右下
     
143.   TIM1->CCR4=b;//左下
     3 Y4 q4 n# O8 P
144. //  delay_ms(1000);
     / p; D$ Q. C; T, g
145. }

复制代码

: {9 F) q5 }8 G% m. Z3.蓝牙控制

蓝牙控制这一内容是小伙伴写的，大概内容和串口一章内容相似，就是多做出了判断，即没通过蓝牙输入数据来改变小车此时的模式，在蓝牙控制模式下，也可以相对应用蓝牙控制小车的方向。我们用的仍是串口一来控制蓝牙，为什么这样做？一是方便，二是就如前面所说，电机和超声波的分压严重，在电脑上上的串口监视器得出的数据并不准确，所以还不如用蓝牙来看数据，于是我们直接用了串口一来和蓝牙连接。初始化问题并不需要要修改，直接调用uart（）函数即可，在中断控制代码下加入接收数据而触发的各种就好了。

蓝牙控制部分代码：

1. void USART1_IRQHandler(void)
   # V; P7 ^: |3 y& I2 [9 C) f
2. {
   4 D3 z6 ~5 q9 c. _
3.   char res;  
   
4.   if(USART1->SR&(1<<5))
   ! W8 l, M& g# C4 X2 D
5.   {   
   : N9 i: x5 M6 M8 L" _' B/ Z
6.     res=USART1->DR;
   
7.     printf("\r\n%d",res);   
   ; y2 B" L! Y% P& q, q
8.     if(res==50)                                              //输入2为前进
   
9.     {  
   
10.       GO(300,300);
    
11.       printf("\r\nGo Stright");
    3 ?" }1 _& G0 j; E' w
12.     }
    
13.     else if(res==56)                       //输入8为后退
    
14.     {
    
15.       BACK(300,300);
    
16.       printf("\r\nGo Back");
    
17.     }
    
18.     else if(res== 52)                //输入4为左转
    
19.     {
    $ z5 C9 q0 M8 |- z7 u% c) q% @
20.       LEFT(300,300);
    , L# ]/ }$ U# T1 F) \5 c+ Q
21.       printf("\r\nTurn Left");      
    
22.     }
    
23.     else if(res==54)                //输入6为右转
    
24.     {
    
25.       RIGHT(300,300);
    # I* v1 Z, [% N, ]" d6 w0 t- b  x
26.       printf("\r\nTurn Right");
    7 ]- f1 z3 c6 ^$ s9 s& F
27.     }
    + A+ S, |) O. b
28.     else if(res==53)                //输入5为停止
    
29.     {
    1 c0 g* Q* N( g' n
30.       STOP();
    7 E! [) g9 g, Y0 L
31.       printf("\r\nStop");
    
32.     }
    ) T8 l6 y3 z* d% }
33.     else if(res=='9')                //进入超声波避障模式
    
34.     {
    9 U2 U/ N; V6 \0 [
35.       opq=0;
    
36.     }
    
37.   }
    
38. }

复制代码

# B+ {$ A- }/ f. R

总的来说蓝牙控制这块并没有踩多少坑（大概这不是我写的吧^ _ ^，感谢小伙伴）

! q/ v( L! u! c: c4.走矩形
2 x7 S! B: Q& G# K% P0 N( \
$ i3 G5 Z: W' ~- l走矩形功能也是小伙伴写的，设计思路大致是通过蓝牙输入长和宽，小车通过接受的数据进行矩形运动。在这唯一遇到的问题就是小车的速度问题和转向时间。这个是他们弄得，自我感觉还是很不好调的，因为要考虑电池可供电压，小车行驶的惯性，不同地面的摩擦程度等等。考虑的方面比较多，根据不同的情况可能还要修改小车的速度和转向时间。我们就是在光滑地砖上测得，摩擦力应该是比较小的。

走矩形代码：

1. void Juxing()//小车的矩形运动函数
   8 a# `. w/ K) l# T) w* K3 h
2. {
   1 p( f' w7 B0 I9 I. h* F
3.   u8 chang,kuan,x,y;//chang、kuan分别是小车要走矩形的长和宽的值
   
4.   delay_ms(200);
   
5.   printf("Chang:\r\n");
   
6.   while(1)
   
7.   {
   ' H; M' {& B6 z* h* m
8.     printf("Input Chang:\r\n");
   
9.     delay_ms(200);
   ( K/ a* b% m  A9 P& `( V3 l/ {0 b
10.     if(USART1->SR&(1<<5))//当串口接收到消息后跳出循环
    
11.     {
    " t& q) L! k# K% }6 I
12.       chang=USART1->DR-'0';//将字符型的数据转换为整型数据
    
13.       break;
    9 j+ b- v/ n5 v4 k5 V" u
14.     }
    7 T/ V7 K7 _- J! U5 B5 R3 A, n6 L- V$ j. F
15.   }
    
16.   printf("长：%d\r\n",chang);//打印串口接收到的数据
    : X# k  o; |% b0 b
17.   USART1->SR=0;//串口的接收标志位清零，为下一次接收宽度数据做准备
    * G- T9 C& g, o+ k& m
18.   while(1)
    * D- V  m) q8 o$ s: y; x( t# X1 L
19.   {
      _+ ]3 \. _1 ?# Q7 |. _
20.     printf("Input Kuan:\r\n");
    
21.     delay_ms(200);
    4 V7 y  c# t/ D9 j; c6 b
22.     if(USART1->SR&(1<<5))
    
23.     {
    
24.       kuan=USART1->DR-'0';//当串口接收到数据后跳出循环
    $ \9 ^* [, g8 e1 F4 n4 P" j
25.       break;
    % O. c; p: v% D5 V4 L: b$ m
26.     }
    * b: i/ m, H+ f2 W; D! u" c
27.   }
    # u5 |' v' @  T; w) g$ d6 f
28.   printf("宽:%d\r\n",kuan);//打印宽度数据
    ( n5 C% x+ D6 d' i
29.   //当前小车速度为0.25米每秒则小车每走1cm要用40ms所以以1cm为单位每走1cm耗时40ms用for函数驱动小车运动
      u* F7 Q7 L% i; r7 e6 W0 M
30.   for(x=0;x<chang*10;x++)//直走长
    5 y, b4 U8 ]" q* t" d0 N' S. }* E' j: w
31.   {
    
32.     GO(300,300);
    
33.     delay_ms(40);
    
34.   }
    
35.   RIGHT(300,300);//右拐
    
36.   delay_ms(785);
    
37.   for(y=0;y<kuan*10;y++)//直走宽
    
38.   {
    # o; {) A1 x5 P2 ^
39.     GO(300,300);
    
40.     delay_ms(40);
    4 }" N3 D  ?9 v. }5 p) a
41.   }
    6 a+ v% B$ w5 n. L9 H* |  ~
42.   RIGHT(300,300);//右拐
    
43.   delay_ms(785);
    
44.   for(x=0;x<chang*10;x++)//直走长
    ) k: y+ m: v$ t. V4 S: j( u9 L* ^
45.   {
    
46.     GO(300,300);
    & i, o  S, Q. ~- h5 ?5 [* {
47.     delay_ms(40);
    0 Y( k) U& j+ f9 E
48.   }
    
49.   RIGHT(300,300);//右拐
    4 L' v: b/ i0 @2 h, {
50.   delay_ms(785);
    
51.   for(y=0;y<kuan*10;y++)//直走宽
    
52.   {
    8 K, `* ~1 }, Q- P* \( L) C6 w
53.     GO(300,300);
    / o8 V# n% @1 B- y& ]6 a
54.     delay_ms(40);
    8 P2 |- i+ r) M) q+ [
55.   }
    
56.   RIGHT(300,300);//右拐
      G9 S1 Y. W$ G3 V# Q0 r6 ~& P
57.   delay_ms(785);
    ( k( z( Y5 g! i# X1 S& L
58.   STOP();
    5 E, b" V4 S# ^
59.   

复制代码

6 ]9 q: G5 Y! B4 C' }转载自： 古月居
$ H3 q' q' l$ `0 ^' X