标题: 智能车双车追逐与超车系统设计报告与STM32程序源码 [打印本页]

---

作者: 帅气的昵称    时间: 2018-6-11 16:50
标题: 智能车双车追逐与超车系统设计报告与STM32程序源码

2018年大学第九届TI杯

大学生电子设计竞赛设计报告

参赛序号	B-02
参赛题目	双车追逐与超车系统（B题）
参赛队员	谢*
指导教师	刘*
报告日期

摘要

      本系统以设计题目的要求为目的,采用 STM32F103开发板机作为步进电机的控制核心, 用脉冲精确的控制步进电机, 使之能在要求范围内转动相应的角度。 同时控制光电传感器进行赛道数据的采集，进而对步进电机进行相应的控制。

目录

双车追逐与超车系统（B题）

1系统设计

1.1  设计要求

1.1.1 总体要求

1.1.2 基本部分

1.1.3 发挥部分

2系统方案

2.1 驱动电机的论证与选择

2.2 人机交互与输入模块的论证与选择

3系统总体设计

3.1系统硬件的设计

3.1.1系统总体框图

3.1.2 输入模块与电路原理图

3.1.3 输出模块与电路原理图

3.1.4 人机交互模块与电路原理图

3.2系统软件的设计

3.2.1程序功能描述与设计思路

3.2.2程序流程图

附录1：源程序

附录2：参考文献

双车追逐与超车系统（B题）

【本科组】

1系统设计
1.1  设计要求
1.1.1 总体要求

设计两辆智能小车。甲车车头紧靠起点标志线,乙车车尾紧靠边界,甲、乙两辆小车同时启动，先后通过起点标志线，在行车道内同向而行，实现双车追逐与超车功能，跑道如图1所示。

图1.1  跑道图

1.1.2 基本部分

（1）甲车、乙车分别从起点标志线开始，在行车道各正常行驶一圈(15分)。

（2）甲、乙两辆小车在图1所示位置同时启动，开始双车追逐，在甲车通过超车标志区时视为双车追逐结束。此过程中，两车间距始终小于30cm(20分)。

（3）甲、乙两车在完成基础要求（2）时的行驶时间小于10秒(10分)。

（4）完成基础要求（2）后，乙车通过超车标志线后在超车区内实现超车功能，并先于甲车到达终点标志线，即实现乙车超过甲车，若超车时间小于5秒，得25分。(25分)。

1.1.3 发挥部分

（1）在完成基础要求（4）后，甲，乙两车继续行驶第二圈，要求甲车通过超车标志线后实现超车功能(20分)。

（2）甲，乙两车行驶第二圈总时间不超过10秒(10分)。

2系统方案

本系统主要由输入模块、输出模块、人机交互模块组成，下面分别论证这几个模块的选择。

2.1 驱动电机的论证与选择

方案一：采用直流电机作为系统的主要动力机构，直流电机是日常生活中比较常用 的电机类型，可以采用L298N 芯片对直流电机的控制，但直流电机无法精确控制；本次设计要用到两个电机相互配合来控制小车转弯的角度以及双车追逐之间的距离，要求很高的精度，直流电机较难实现。

方案二：舵机。 舵机体积小, 安装方便,其转动的角度用脉冲来进行控制，能做到精确转动，且转动力矩比同质量的直流电机或步进电机都大，转动的范围有限, 不适合本系统。

方案三：采用步进电机作为系统的主要动力机构，步进电机通过脉冲控制，每次可以走一个很小的角度，这就可以满足本题精确控制小车转弯的角度以及双车追逐之间的距离的要求。

综合以上三种方案，选择方案三。

2.2 人机交互与输入模块的论证与选择

              应题目要求，按键作为人机交互模块，光电传感器对赛道数据进行采集。这两个模块固定。

3系统总体设计3.1系统硬件的设计3.1.1系统总体框图

系统总体框图如图所示

图3.1  系统总体框图

3.1.2 输入模块与电路原理图

              光电传感器作为数据采集端。

图3.2  红外光电传感器实物图

图3.3  红外光电传感器原理图

3.1.3 输出模块与电路原理图

              步进电机空系统的执行端。

图3.4 步进电机实物图

图3.5 步进电机驱动电路图

3.1.4 人机交互模块与电路原理图

              按键KEY用于人机交互。

图3.6 按键电路图

3.2系统软件的设计3.2.1程序功能描述与设计思路

1、程序功能描述

根据题目要求软件部分主要实现按键控制小车按指定距离走完一圈和超车功能。

2、程序设计思路

我们从系统设计出发，根据硬件系统设计，将软件设计分为硬件层、驱动层、应用层。这样设计符合模块化思想，有助于代码调试、阅读、学习。

3.2.2程序流程图

1、主程序流程图

2、转圈与追逐功能流程图

3、超车功能流程图

4、直走子程序流程图

5、转弯子程序流程图

6、超车子程序流程图

附录1：源程序

1. #include "main.h"
   
2. 
   
3. /*
   
4. * 函数名：main
   
5. * 函数功能：功能选择
   
6. * 入口参数：void
   
7. * 返回参数：0
   
8. *
   
9. */
   
10. 
    
11. int main(void)
    
12. {        
    
13.         System_Init();
    
14.         while(1){
    
15.                 delay_ms(10);
    
16.                 switch(KEY_UP()){                //判断按键是否松开
    
17.                         case KEY0_PRES:                        //KEY0松开
    
18.                                 start(20, 50);                //小车起步
    
19.                                 start(20, 20);
    
20.                                 functionOne();                //功能一
    
21.                                 break;
    
22.                         case KEY1_PRES:                //KEY1松开
    
23.                                 break;
    
24.                         case WKUP_PRES:                //WKUP_PRES松开
    
25.                                 start(20, 50);        //小车起步
    
26.                                 start(20, 20);
    
27.                                 functionThree();        //功能三
    
28.                                 count = 0;                //重新计数
    
29.                                 val = 0;
    
30.                                 num = 1;
    
31.                                 functionTwo();        //功能二
    
32.                                 break;
    
33.                 }
    
34.         }
    
35.   
    
36.         return 0;
    
37. }
    
38. 
    
39. void start(int s, int t){                //小车起步程序
    
40.         while(s>0){                //小车走s步
    
41.                 delay_ms(t);                        //延时t毫秒
    
42.                 motor_start10(3-con1%4);                //左轮反转
    
43.                 motor_start11(con2%4);                //右轮正转
    
44.                 if(con1 == 600){        //左轮清零
    
45.                         con1 = 0;
    
46.                 }
    
47.                 con1++;
    
48.                 if(con2 == 600){        //右轮清零
    
49.                         con2 = 0;
    
50.                 }
    
51.                 con2++;
    
52.                 s--;
    
53.         }
    
54.         delay_ms(2);        //延时
    
55. }
    
56. 
    
57. void overCar(void){                //超车程序
    
58.         int i = 0;
    
59.         while(1){                //直走245步
    
60.                 delay_ms(5);
    
61.                 motor_start10(3-con1%4);  //左轮反转
    
62.                 motor_start11(con2%4);                //右轮正转
    
63.                 if(con1 == 600){
    
64.                         con1 = 0;
    
65.                 }
    
66.                 con1++;
    
67.                 if(con2 == 600){
    
68.                         con2 = 0;
    
69.                 }
    
70.                 con2++;
    
71.                 i++;
    
72.                 if(i > 245){        
    
73.                         i = 0;
    
74.                         break;
    
75.                 }
    
76.         }
    
77.         
    
78.         trunLeft(20); //左转
    
79.         trunRight();        //右转
    
80.         
    
81.         while(1){                //直走340步
    
82.                 delay_ms(3);
    
83.                 motor_start10(3-con1%4);
    
84.                 motor_start11(con2%4);
    
85.                 if(con1 == 600){
    
86.                         con1 = 0;
    
87.                 }
    
88.                 con1++;
    
89.                 if(con2 == 600){
    
90.                         con2 = 0;
    
91.                 }
    
92.                 con2++;
    
93.                 i++;
    
94.                 if(i > 340){
    
95.                         i = 0;
    
96.                         break;
    
97.                 }
    
98.         }
    
99.         
    
100.         trunRight();                //右转
     
101.         
     
102.         while(1){                //直走30步
     
103.                 delay_ms(5);
     
104.                 motor_start10(3-con1%4);
     
105.                 motor_start11(con2%4);
     
106.                 if(con1 == 600){
     
107.                         con1 = 0;
     
108.                 }
     
109.                 con1++;
     
110.                 if(con2 == 600){
     
111.                         con2 = 0;
     
112.                 }
     
113.                 con2++;
     
114.                 i++;
     
115.                 if(i > 30){
     
116.                         i = 0;
     
117.                         break;
     
118.                 }
     
119.         }
     
120.         
     
121.         trunLeft(0);                //左转
     
122.         count = 8;                //给标志线计数器重新赋值为8
     
123.         val = 8;
     
124.         num = 8;
     
125. }
     
126. 
     
127. void functionThree(void){                //功能三
     
128.         int i = 0;
     
129.         while(1){               
     
130.                 lineRun();                //直线走
     
131.                 if(num == 10){                //判断是否到达终点
     
132.                         break;
     
133.                 }
     
134.                 trunLeft(0);        //左转
     
135.                 if(num == 8){                //判断是否到达超车区域
     
136.                         while(1){                //直线行驶800步
     
137.                                 delay_ms(5);               
     
138.                                 motor_start10(3-con1%4);
     
139.                                 motor_start11(con2%4);
     
140.                                 if(con1 == 600){
     
141.                                         con1 = 0;
     
142.                                 }
     
143.                                 con1++;
     
144.                                 if(con2 == 600){
     
145.                                         con2 = 0;
     
146.                                 }
     
147.                                 con2++;
     
148.                                 i++;
     
149.                                 if(i == 800){
     
150.                                         i = 0;
     
151.                                         break;
     
152.                                 }
     
153.                         }
     
154.                         while(1){                //减速行驶180步
     
155.                                 delay_ms(50);
     
156.                                 motor_start10(3-con1%4);
     
157.                                 motor_start11(con2%4);
     
158.                                 if(con1 == 600){
     
159.                                         con1 = 0;
     
160.                                 }
     
161.                                 con1++;
     
162.                                 if(con2 == 600){
     
163.                                         con2 = 0;
     
164.                                 }
     
165.                                 con2++;
     
166.                                 i++;
     
167.                                 if(i == 180){
     
168.                                         i = 0;
     
169.                                         break;
     
170.                                 }
     
171.                         }
     
172.                 }
     
173.         }
     
174. }
     
175. 
     
176. void functionTwo(void){                //功能二
     
177.         while(1){
     
178.                 lineRun();                //直走
     
179.                 if(num == 10){                //判断是否到达终点
     
180.                         break;
     
181.                 }
     
182.                 trunLeft(0);                //左转
     
183.                 if(val == 8){                //判断是否进入超车区
     
184.                         overCar();                //超车
     
185.                 }
     
186.         }
     
187. }
     
188. 
     
189. void functionOne(void){                //功能一
     
190.         while(1){
     
191.                 lineRun();                //直线走
     
192.                 if(num == 10){                //判断是否到达终点
     
193.                         break;
     
194.                 }
     
195.                 trunLeft(0);                //左转
     
196.                
     
197.         }
     
198. }
     
199. 
     
200. void trunRight(void){                //右转程序
     
201.         int i = 0;
     
202.         while(1){                //先直走230步
     
203.                 delay_ms(3);
     
204.                 motor_start10(3-con1%4);
     
205.                 motor_start11(con2%4);
     
206.                 if(con1 == 600){
     
207.                         con1 = 0;
     
208.                 }
     
209.                 con1++;
     
210.                 if(con2 == 600){
     
211.                         con2 = 0;
     
212.                 }
     
213.                 con2++;
     
214.                 i++;
     
215.                 if(i == 230){
     
216.                         i = 0;
     
217.                         break;
     
218.                 }
     
219.         }
     
220.         
     
221.         while(1){                //右轮不转左轮转
     
222.                 delay_ms(3);
     
223.                 motor_start10(3-con1%4);
     
224.                 if(con1 == 600){
     
225.                         con1 = 0;
     
226.                 }
     
227.                 con1++;
     
228.                 i++;
     
229.                 if(i == C3){
     
230.                         i = 0;
     
231.                         break;
     
232.                 }
     
233.         }
     
234. }
     
235. 
     
236. 
     
237. void trunLeft(int c){  //左转程序
     
238.         int i = 0;
     
239.         while(1){                //先直走165步
     
240.                 delay_ms(5);
     
241.                 motor_start10(3-con1%4);
     
242.                 motor_start11(con2%4);
     
243.                 if(con1 == 600){
     
244.                         con1 = 0;
     
245.                 }
     
246.                 con1++;
     
247.                 if(con2 == 600){
     
248.                         con2 = 0;
     
249.                 }
     
250.                 con2++;
     
251.                 i++;
     
252.                 if(i == 165){
     
253.                         i = 0;
     
254.                         break;
     
255.                 }
     
256.         }
     
257.         
     
258.         while(1){        //左轮不转右轮转
     
259.                 delay_ms(3);
     
260.                 motor_start11(con2%4);
     
261.                 if(con2 == 600){
     
262.                         con2 = 0;
     
263.                 }
     
264.                 con2++;
     
265.                 i++;
     
266.                 if(i == C3-c){
     
267.                         i = 0;
     
268.                         break;
     
269.                 }
     
270.         }
     
271. }
     
272. 
     
273. void right(void){                //向右调平程序
     
274.         while(1){                //左轮转动直到左边光电传感器扫描到标志线
     
275.                 delay_ms(5);
     
276.                 motor_start10(3-con1%4);  
     
277.                 if(con1 == 600){
     
278.                         con1 = 0;
     
279.                 }
     
280.                 con1++;
     
281.                 if(val==count){
     
282.                                 break;
     
283.                 }
     
284.         }
     
285. }
     
286. 
     
287. void left(void){                //向左调平程序
     
288.         while(1){                //右轮转动直到右边光电传感器扫描到标志线
     
289.                 delay_ms(5);
     
290.                 motor_start11(con2%4);        
     
291.                 con2++;
     
292.                 if(con2 == 600){
     
293.                         con2 = 0;
     
294.                 }
     
295.                
     
296.                 if(count==val){
     
297.                                 break;
     
298.                 }
     
299.         }
     
300. }
     
301. 
     
302. void lineRun(void){                //直线走程序
     
303.   int value1 = 0;
     
304.         int value2 = 0;
     
305.         while(1){
     
306.                
     
307.                 delay_ms(5);
     
308.                 motor_start10(3-con1%4);
     
309.                 motor_start11(con2%4);
     
310.                 if(num == 1&&con1 == 450){                //确保左右光电传感器计数值在经过第一条标志线后一致
     
311.                                 count = num;
     
312.                                 val = num;                                
     
313.                 }
     
314.                 if(con1 == 600){
     
315.                         con1 = 0;
     
316.                 }
     
317.                 con1++;
     
318.                 if(con2 == 600){
     
319.                         con2 = 0;
     
320.                 }
     
321.                 con2++;
     
322.                 if(num == 10){                //判断是否到达终点
     
323.                         break;
     
324.                 }
     
325.                 //在第2、3、4、9、10标志线处调平
     
326.                 if((count-value1==1)&&(count==2||count==3||count==4||count==9||count==10)){
     
327.                         right();
     
328.                         break;
     
329.                 }
     
330.                 if((val-value2==1)&&(val==2||val==3||val==4||val==9||val==10)){
     
331.                         left();
     
332.                         break;
     
333.                 }
     
334.                 value1 = count;
     
335.                 value2 = val;
     
336.         }
     
337. }
     
338. 
     
339. /*
     
340. * 函数名：System_Init
     
341. * 函数功能：系统硬件层初始化
     
342. * 入口参数：无
     
343. * 返回参数：无
     
344. *
     
345. */
     
346. void System_Init(void){
     
347.         
     
348.         Stm32_Clock_Init(9);                                          //初始化系统时钟               
     
349.         delay_init(72);                                                                        //初始化延时
     
350.         MOTOR_Init();                                                                                //初始化电机接口                                                                          
     
351.         uart_init(72,9600);                                                        //初始化串口
     
352.         KEY_Init();                                                                                        //初始化按键
     
353. //        LED_Init();
     
354.          EXTI_Init();                                                                                //初始化中断
     
355. }
     

复制代码

全部资料51hei下载地址（word格式的论文内含清晰图片）：

智能小车追逐超车系统.zip (2.86 MB, 下载次数: 33)

2018-6-11 16:49 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1