标题: 基于arduino2560的循线小车制作 附程序 [打印本页]

---

作者: 1178472501    时间: 2020-2-26 01:00
标题: 基于arduino2560的循线小车制作 附程序
基于arduino2560的循线小车的整体图


部分代码如下

1. /*
   
2. 
   
3. * 电机：
   
4. *      10 -> 左侧：前进( > 90 ) ; 后退( < 90 ) ; 停止( 82 - 92)
   
5. *      12 -> 右侧：前进( < 90 ) ; 后退( > 90 ) ; 停止( 93 - 103);
   
6. * F表示前B为后，D是在双线上，S表示单线上
   
7. *
   
8. */
   
9. /****************************整体实验例程****************************/
   
10. #include <Arduino.h>
    
11. #include <Wire.h>
    
12. #include <MultiLCD.h>
    
13. #include <ServoTimer2.h>
    
14. 
    
15. //定义车行进方向
    
16. enum Dir{
    
17.   FORWARD = 1, BACK, LEFT, RIGHT, STOP
    
18. };
    
19. 
    
20. 
    
21. enum Trackingmode{
    
22.   FD= 1, BD, FS, BS       //举例FD就表示在双线上前进循迹，主要前传感器
    
23. };//
    
24. 
    
25. enum Turnmode{
    
26.   RFD= 1, LFD, RBD, LBD, RFS, LFS, RBS, LBS  
    
27. //举例RFD表示 R向右转弯，F转完后要前进，D表示在双线上
    
28. };
    
29. 
    
30. 
    
31. //Motor
    
32. int left_motor_port = 4; //定义左侧电机引脚
    
33. int right_motor_port = 7; //定义右侧电机引脚
    
34. int motor_speed = 135; //定义电机停止速度
    
35. 
    
36. 
    
37. void setup() {
    
38.   Serial.begin(9600);
    
39.   SensorInit();
    
40.   MotorInit();
    
41. 
    
42. }
    
43. 
    
44. 
    
45. /******************************设备初始化部分********************************/
    
46. //传感器引脚初始化
    
47. void SensorInit(){
    
48.   //pinMode(f[3], INPUT);
    
49.   //pinMode(rf_s, INPUT);
    
50.   for(int i=0;i<8;i++){pinMode(f[i], INPUT);}    //前传感器数组
    
51.   //pinMode(b[3], INPUT);
    
52.   //pinMode(b[6], INPUT);
    
53.   for(int i=0;i<8;i++){pinMode(b[i], INPUT);}    //后传感器数组
    
54.   //pinMode(l_s, INPUT);
    
55.   //pinMode(r_s, INPUT);
    
56.   for(int i=0;i<8;i++){pinMode(l[i], INPUT);}    //中间传感器数组
    
57.   pinMode(debug_sensor, INPUT);
    
58.   //digitalWrite(A1,LOW);
    
59.   //digitalWrite(A5,LOW);
    
60.   
    
61. }
    
62. 
    
63. /******************************车行进控制部分********************************/
    
64. int left_speed = 20;
    
65. int right_speed = 20;
    
66. 
    
67. void SpeedSet(int l, int r){
    
68.   left_speed = l; right_speed = r;
    
69. }
    
70. 
    
71. void Forward(){
    
72.   l_Servo.write(Angle2Pwm(motor_speed + left_speed));
    
73.   r_Servo.write(Angle2Pwm(motor_speed - right_speed));
    
74. }
    
75. 
    
76. void Back(){
    
77.   l_Servo.write(Angle2Pwm(motor_speed - left_speed));
    
78.   r_Servo.write(Angle2Pwm(motor_speed + right_speed));
    
79. }
    
80. 
    
81. void Left(){
    
82.   l_Servo.write(Angle2Pwm(motor_speed - 1.5*left_speed));
    
83.   r_Servo.write(Angle2Pwm(motor_speed - 1.5*right_speed));
    
84. }
    
85. 
    
86. void Right(){
    
87.   l_Servo.write(Angle2Pwm(motor_speed + 1.5*left_speed));
    
88.   r_Servo.write(Angle2Pwm(motor_speed + 1.5*right_speed));
    
89. }
    
90. 
    
91. void Stop(){
    
92.   l_Servo.write(Angle2Pwm(motor_speed));
    
93.   r_Servo.write(Angle2Pwm(motor_speed));
    
94.   delay(1000);
    
95. }
    
96. 
    
97. void Move(int dir){
    
98.   switch(dir){
    
99.     case FORWARD: Forward(); break;
    
100.     case BACK: Back(); break;
     
101.     case LEFT: Left(); break;
     
102.     case RIGHT: Right(); break;   
     
103.     case STOP: Stop(); break;
     
104.     default: break;  
     
105.   }
     
106. }
     
107.   //电机速度写入函数，调速的时候使用
     
108. void CorrectLeftF(){
     
109.   l_Servo.write(Angle2Pwm(motor_speed));
     
110.   r_Servo.write(Angle2Pwm(motor_speed - 20));
     
111. }
     
112. 
     
113. void CorrectRightF(){
     
114.   l_Servo.write(Angle2Pwm(motor_speed + 20));
     
115.   r_Servo.write(Angle2Pwm(motor_speed));
     
116. }
     
117. 
     
118. void CorrectRightB(){
     
119.   l_Servo.write(Angle2Pwm(motor_speed - 20));
     
120.   r_Servo.write(Angle2Pwm(motor_speed));
     
121. }
     
122. 
     
123. void CorrectLeftB(){
     
124.   l_Servo.write(Angle2Pwm(motor_speed ));
     
125.   r_Servo.write(Angle2Pwm(motor_speed + 20));
     
126. }  
     
127. 
     
128. 
     
129. 
     
130. 
     
131. 
     
132. 
     
133. /*
     
134. void Turn(int mode){   //转向函数
     
135.   switch(mode){
     
136.    
     
137.     case 1:              //RF_D
     
138.   Move(RIGHT);
     
139.   while(!digitalRead(f[7]));
     
140.   //delay(500);
     
141.   while(!digitalRead(f[5]));
     
142.   SpeedSet(15,15);
     
143.   Move(RIGHT);
     
144.   //delay(dy);
     
145.   while(!digitalRead(f[2]));
     
146.   Move(STOP);
     
147.   SpeedSet(20,20);
     
148.   break;
     
149.   
     
150.     case 2:             //LF_D
     
151.   Move(LEFT);
     
152.   while(!digitalRead(f[0]));
     
153.   //delay(500);
     
154.   while(!digitalRead(f[2]));
     
155.   SpeedSet(15,15);
     
156.   Move(LEFT);
     
157.   //delay(dy);
     
158.   while(!digitalRead(f[5]));
     
159.   Move(STOP);
     
160.   SpeedSet(20,20);
     
161.   break;
     
162.   
     
163.     case 3:               //RB_D
     
164.   Move(RIGHT);
     
165.   while(!digitalRead(b[7]));
     
166.   //delay(500);
     
167.   while(!digitalRead(b[5]));
     
168.   SpeedSet(15,15);
     
169.   Move(RIGHT);
     
170.   //delay(dy);
     
171.   while(!digitalRead(b[2]));
     
172.   Move(STOP);
     
173.   SpeedSet(20,20);
     
174.   break;
     
175.   
     
176.     case 4:               //LB_D
     
177.   Move(LEFT);
     
178.   while(!digitalRead(b[0]));
     
179.   //delay(500);
     
180.   while(!digitalRead(b[2]));
     
181.   SpeedSet(15,15);
     
182.   Move(LEFT);
     
183.   //delay(dy);
     
184.   while(!digitalRead(b[5]));
     
185.   Move(STOP);
     
186.   SpeedSet(20,20);
     
187.   break;
     
188.   
     
189.       case 5:                 //RF_S
     
190.   Move(RIGHT);
     
191.   while(!digitalRead(f[7]));
     
192.   //delay(500);
     
193.   while(!digitalRead(f[6]));
     
194.   SpeedSet(15,15);
     
195.   Move(RIGHT);
     
196.   //delay(dy);
     
197.   while(!digitalRead(f[3]));
     
198.   Move(STOP);
     
199.   SpeedSet(20,20);
     
200.   break;
     
201.   
     
202.     case 6:             //LF_S
     
203.   Move(LEFT);
     
204.   while(!digitalRead(f[0]));
     
205.   //delay(500);
     
206.   while(!digitalRead(f[1]));
     
207.   SpeedSet(15,15);
     
208.   Move(LEFT);
     
209.   //delay(dy);
     
210.   while(!digitalRead(f[4]));
     
211.   Move(STOP);
     
212.   SpeedSet(20,20);
     
213.   break;
     
214.   
     
215.     case 7:            //RB_S
     
216.   Move(RIGHT);
     
217.   while(!digitalRead(b[7]));
     
218.   //delay(500);
     
219.   while(!digitalRead(b[6]));
     
220.   SpeedSet(15,15);
     
221.   Move(RIGHT);
     
222.   //delay(dy);
     
223.   while(!digitalRead(b[3]));
     
224.   Move(STOP);
     
225.   SpeedSet(20,20);
     
226.   break;
     
227.   
     
228.     case 8:            //LB_S
     
229.   Move(LEFT);
     
230.   while(!digitalRead(b[0]));
     
231.   //delay(500);
     
232.   while(!digitalRead(b[1]));
     
233.   SpeedSet(15,15);
     
234.   Move(LEFT);
     
235.   //delay(dy);
     
236.   while(!digitalRead(b[4]));
     
237.   Move(STOP);
     
238.   SpeedSet(20,20);
     
239.   break;
     
240. }
     
241. }
     
242. 
     
243. 
     
244. 
     
245. /******************************路径部分********************************/
     
246. /*
     
247. * 循迹函数
     
248. * 返回值：无
     
249. * 参数：mode：
     
250. *       FD：前进双线循迹
     
251. *       BD：后退双线循迹
     
252. *       FS：前进单线循迹
     
253. *       BS：后退单线循迹
     
254. * 功能：通过车底传感器检测路线进行循迹
     
255. */
     
256. void Tracking(int mode){
     
257. if(mode==1){//FD
     
258.     if(digitalRead(f[2]) && digitalRead(f[5])){
     
259.       Move(FORWARD);
     
260.       delay(20);
     
261.     }
     
262.     else if(digitalRead(f[2])){
     
263.        CorrectLeftF();
     
264.       }
     
265.     else if(digitalRead(f[5])){
     
266.        CorrectRightF();
     
267.       }
     
268.     else
     
269.       Move(FORWARD);
     
270.       delay(20);
     
271.       
     
272. }   
     
273.       
     
274. if(mode==2){    //BD
     
275.     if(digitalRead(b[2]) && digitalRead(b[5])){
     
276.       Move(BACK);
     
277.       delay(20);
     
278.     }
     
279.     else if(digitalRead(b[2])){
     
280.      CorrectRightB();  
     
281.     }
     
282.     else if(digitalRead(b[5])){
     
283.      CorrectLeftB();  
     
284.     }
     
285.     else
     
286.       Move(BACK);
     
287.       delay(20);
     
288.       
     
289. }   
     
290.       
     
291. if(mode==3){   //FS
     
292.     if(digitalRead(f[3]) && digitalRead(f[4])){
     
293.       Move(FORWARD);
     
294.       delay(20);
     
295.     }
     
296.     else if(digitalRead(f[3])){
     
297.        CorrectLeftF();
     
298.       }
     
299.     else if(digitalRead(f[4])){
     
300.        CorrectRightF();
     
301.       }
     
302.     else
     
303.       Move(FORWARD);
     
304.       delay(20);
     
305.    
     
306.     }
     
307.       
     
308. if(mode==4){  //BS
     
309.     if(digitalRead(b[3]) && digitalRead(b[4])){
     
310.       Move(BACK);
     
311.       delay(20);
     
312.     }
     
313.     else if(digitalRead(b[3])){
     
314.      CorrectRightB();  
     
315.     }
     
316.     else if(digitalRead(b[4])){
     
317.      CorrectLeftB();  
     
318.     }
     
319.     else
     
320.       Move(BACK);
     
321.       delay(20);
     
322.   }
     
323. }
     
324. 
     
325. 
     
326. /*
     
327. * 循线计数函数
     
328. * 返回值：无
     
329. * 参数：mode：
     
330. *       FD：前进双线循迹
     
331. *       BD：后退双线循迹
     
332. *       FS：前进单线循迹
     
333. *       BS：后退单线循迹
     
334. * 参数：line：表示准备走几条线
     
335. * 功能：确定走的线数
     
336. */
     
337. 
     
338. void Trackingline(int mode, int line){
     
339.   switch(mode){
     
340.   case 1:
     
341.     for(int i=0;i<20;i++){Tracking(FD);}
     
342.     while(1){
     
343.     if(meridians < line){
     
344.       if(meridians < line-1){
     
345.         if(digitalRead(l[3])){
     
346.           meridians++;
     
347.           while(digitalRead(l[3]));
     
348.           delay(200);
     
349.           }
     
350.         else{
     
351.           Tracking(FD);  
     
352.       }
     
353.       }
     
354.       else{
     
355.         if(digitalRead(l[3])){meridians++;}
     
356.         else{Tracking(FD);}
     
357.       }
     
358.     }
     
359.     else{
     
360.       //Move(BACK);
     
361.       //delay(200);
     
362.       //Move(STOP);
     
363.       meridians = 0;
     
364.       //Move(BACK);
     
365.       //while(!digitalRead(l[3]));
     
366.       Move(STOP);
     
367.       break;
     
368.     }
     
369.    
     
370.     }
     
371.   break;
     
372. 
     
373. 
     
374.   case 2:
     
375.   for(int i=0;i<20;i++){Tracking(BD);}
     
376.     while(1){
     
377.     if(meridians < line){
     
378.       if(meridians < line-1){
     
379.         if(digitalRead(l[4])){
     
380.           meridians++;
     
381.           while(digitalRead(l[4]));
     
382.           delay(200);
     
383.           }
     
384.         else{
     
385.           Tracking(BD);  
     
386.       }
     
387.       }
     
388.       else{
     
389.         if(digitalRead(l[4])){meridians++;}
     
390.         else{Tracking(BD);}
     
391.       }
     
392.     }
     
393.     else{
     
394.       //Move(FORWARD);
     
395.       //delay(200) ;
     
396.       //Move(STOP);
     
397.       meridians = 0;
     
398.       //Move(FORWARD);
     
399.       //while(!digitalRead(l[4]));
     
400.       Move(STOP);
     
401.       break;
     
402.     }
     
403.     }
     
404.     break;
     
405.    
     
406.    
     
407.     case 3:
     
408.   for(int i=0;i<20;i++){Tracking(FS);}
     
409.     while(1){
     
410.     if(meridians < line){
     
411.       if(meridians < line-1){
     
412.         if(digitalRead(l[3])){
     
413.           meridians++;
     
414.           while(digitalRead(l[3]));
     
415.           delay(600);
     
416.           }
     
417.         else{
     
418.           Tracking(FS);  
     
419.       }
     
420.       }
     
421.       else{
     
422.         if(digitalRead(l[3])){meridians++;}
     
423.         else{Tracking(FS);}
     
424.       }
     
425.     }
     
426.     else{
     
427.       //Move(BACK);
     
428.       //delay(200);
     
429.       //Move(STOP);
     
430.       meridians = 0;
     
431.       //Move(BACK);
     
432.       //while(!digitalRead(l[3]));
     
433.       Move(STOP);
     
434.       break;
     
435.     }
     
436.     }
     
437.   break;
     
438. 
     
439.   case 4:
     
440.   for(int i=0;i<20;i++){Tracking(BS);}
     
441.     while(1){
     
442.     if(meridians < line){
     
443.       if(meridians < line-1){
     
444.         if(digitalRead(l[4])){
     
445.           meridians++;
     
446.           while(digitalRead(l[4]));
     
447.           delay(600);
     
448.           }
     
449.         else{
     
450.           Tracking(BS);  
     
451.       }
     
452.       }
     
453.       else{
     
454.         if(digitalRead(l[4])){meridians++;}
     
455.         else{Tracking(BS);}
     
456.       }
     
457.     }
     
458.     else{
     
459.       //Move(FORWARD);
     
460.       //delay(200);
     
461.       //Move(STOP);
     
462.       meridians = 0;
     
463.       //Move(FORWARD);
     
464.       //while(!digitalRead(l[4]));
     
465.       Move(STOP);
     
466.       break;
     
467.     }
     
468.     }
     
469.     break;  
     
470.    
     
471. }
     
472. }
     
473. 
     
474. 
     
475. 
     
476. /******************************路段部分********************************/
     
477. 
     
478. //主函数部分,直接写入要走的路
     
479. void loop (){
     
480.   Turn(LFD);
     
481.   Trackingline(FD,3);
     
482.   Turn(RBS);
     
483.   Trackingline(BS,1);
     
484.   Turn(LBD);
     
485.   Trackingline(BD,2);
     
486.   Turn(RFS);
     
487.   Trackingline(FS,1);
     
488. }
     

复制代码

w.png (935.92 KB, 下载次数: 143)

下载附件

2020-2-26 00:55 上传

使用的八路巡线传感器 前中后各一 全部接在数字口上

e.jpg (55.61 KB, 下载次数: 130)

下载附件

2020-2-26 00:56 上传

小车跑的场地，由单双线交叉构成的网格，本程序让小车沿线跑

sketch_mar30a.zip

2020-2-26 00:58 上传

点击文件名下载附件

下载积分: 黑币 -5

6.61 KB, 下载次数: 27, 下载积分: 黑币 -5

程序的源码

---

作者: 龟龟匪    时间: 2021-11-3 21:26
里面有一些库文件用不了，库文件能分享吗？

---

作者: msmn    时间: 2021-11-28 16:50
小车底盘是自己制作的吗？

---

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

Powered by Discuz! X3.1