（1）甲車、乙車分別從起點標志線開始，在行車道各正常行駛一圈(15分)。

（2）甲、乙兩輛小車在圖1所示位置同時啟動，開始雙車追逐，在甲車通過超車標志區(qū)時視為雙車追逐結束。此過程中，兩車間距始終小于30cm(20分)。

（3）甲、乙兩車在完成基礎要求（2）時的行駛時間小于10秒(10分)。

（4）完成基礎要求（2）后，乙車通過超車標志線后在超車區(qū)內(nèi)實現(xiàn)超車功能，并先于甲車到達終點標志線，即實現(xiàn)乙車超過甲車，若超車時間小于5秒，得25分。(25分)。

（1）在完成基礎要求（4）后，甲，乙兩車繼續(xù)行駛第二圈，要求甲車通過超車標志線后實現(xiàn)超車功能(20分)。

（2）甲，乙兩車行駛第二圈總時間不超過10秒(10分)。

綜合以上三種方案，選擇方案三。

1、程序功能描述

根據(jù)題目要求軟件部分主要實現(xiàn)按鍵控制小車按指定距離走完一圈和超車功能。

2、程序設計思路

我們從系統(tǒng)設計出發(fā)，根據(jù)硬件系統(tǒng)設計，將軟件設計分為硬件層、驅動層、應用層。這樣設計符合模塊化思想，有助于代碼調(diào)試、閱讀、學習。

1、主程序流程圖

2、轉圈與追逐功能流程圖

1. #include "main.h"
   
2. 
   
3. /*
   
4. * 函數(shù)名：main
   
5. * 函數(shù)功能：功能選擇
   
6. * 入口參數(shù)：void
   
7. * 返回參數(shù)：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;                //重新計數(shù)
    
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;                //給標志線計數(shù)器重新賦值為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){                //判斷是否到達超車區(qū)域
     
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){                //判斷是否進入超車區(qū)
     
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){                //向右調(diào)平程序
     
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){                //向左調(diào)平程序
     
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){                //確保左右光電傳感器計數(shù)值在經(jīng)過第一條標志線后一致
     
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標志線處調(diào)平
     
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. * 函數(shù)名：System_Init
     
341. * 函數(shù)功能：系統(tǒng)硬件層初始化
     
342. * 入口參數(shù)：無
     
343. * 返回參數(shù)：無
     
344. *
     
345. */
     
346. void System_Init(void){
     
347.         
     
348.         Stm32_Clock_Init(9);                                          //初始化系統(tǒng)時鐘               
     
349.         delay_init(72);                                                                        //初始化延時
     
350.         MOTOR_Init();                                                                                //初始化電機接口                                                                          
     
351.         uart_init(72,9600);                                                        //初始化串口
     
352.         KEY_Init();                                                                                        //初始化按鍵
     
353. //        LED_Init();
     
354.          EXTI_Init();                                                                                //初始化中斷
     
355. }
     

復制代碼

智能小車追逐超車系統(tǒng).zip (2.86 MB, 下載次數(shù): 33)

2018-6-11 16:49 上傳

點擊文件名下載附件