欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 智能車雙車追逐與超車系統設計報告與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.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影