基于ESPDuino的四路循迹小车实例

linXJ

1，实验材料：
ESPDuino开发板，Doit电机驱动模块，四路循迹模块，T-200 Doit小车，杜邦线若干；
2，实物连接：
电机驱动模块的 DC-MOTOR 端口 A+、A-和 B+、B-分别接电机 A 的正负极和电机 B 的正负极；IN-6-18V 端口的 VM、GND 分别接电源(18650 电池盒)的正负极；
其中：PinPWMA 对应开发板的 IO 口 14---用于控制电机 A 速度；
PinPWMB 对应开发板的 IO 口 12---用于控制电机 B 速度；
PinDirA 对应开发板的 IO 口15---用于控制电机 A 转向；
PinDirB 对应开发板的 IO 口 13---用于控制电机 B 转向；
循迹模块上的vcc与GND分别接电机驱动板上面的5V和GND管脚；IN1、IN2、IN3、IN4分别接电机驱动板的5(D5)、4(D4)、11(D3)、2(D0)，(括号里表示ESPDUINO板上对应的IO口管脚)；
3，实验原理：
原理：在白色地面上画一条宽度适中(1-3cm，最宽不能超过循迹模块最左端与最右端两个探测灯的距离)的黑色路线，让位于小车底盘的循迹模块发射的红外线，根据黑色对红外线的吸收作用，红外光射在白色地面会接收到反射光，相应管脚被置0(低电平)，当循迹探头对准黑色路线上时没有接收到反射光，相应管脚置1(高电平)；根据这个原理就可以控制小车沿着黑色路线前进了。
温馨提示：4路循迹模块排成倒梯形(最左边(IN4)和最右边(IN1)位于稍微靠前的位置，让探测更具有前瞻性，进而反应更灵敏。中间的两个，左边为IN3，右边为IN2，两者距离要与地面的黑色路线等宽，循迹过程中保证两者一直在黑色路线上即可)；
4，示例源码：

1. <div class="blockcode"><blockquote>#include <Ticker.h>
   
2. #define PinPWMA 14    //电机1速度
   
3. #define PinPWMB 12   //电机2速度
   
4. #define PinDirA 15    //电机1转向
   
5. #define PinDirB 13   //电机2转向
   
6. #define left1  0     //左1探头
   
7. #define left2  3     //左2探头
   
8. #define right2 4     //右2探头
   
9. #define right1 5     //右1探头
   
10. 
    
11. extern "C"
    
12. {
    
13. #include "user_interface.h"
    
14. #include "smartconfig.h"
    
15. }
    
16. /************** PWM Driver *************************/
    
17. #define MAXPIN  17                        
    
18. Ticker pwmTickersSetHigh[MAXPIN];         
    
19. Ticker pwmTickersSetLow[MAXPIN];         
    
20. const int pwmExponent = 3;   
    
21. const int pwmFactor = 8;                  
    
22. const int pwmRoundoff = pwmFactor/2;      
    
23. const int pwmDutyCycle = 256/pwmFactor;   
    
24. 
    
25. // 类似analogWrite()
    
26. void pwmWrite(int pin, int value)
    
27. {
    
28.   if (pin < 0  ||  pin >= MAXPIN  || value < 0  ||  value > 255)
    
29.     return;         
    
30.   pwmTickersSetHigh[pin].detach();                     
    
31.   pwmTickersSetLow[pin].detach();
    
32. 
    
33.   int highTime = (value+pwmRoundoff)/pwmFactor;      
    
34.   if (highTime <= 0)                                 
    
35.     pwmSetLow(pin);
    
36.   else if (highTime >= pwmDutyCycle)
    
37.     pwmSetHigh(pin);
    
38.   else
    
39.   {               
    
40.     pwmSetHigh(pin);
    
41.     pwmTickersSetHigh[pin].attach_ms(pwmDutyCycle, pwmSetHigh, pin);  
    
42.     pwmTickersSetLow[pin].once_ms(highTime, pwmStartLow, pin);
    
43.   }
    
44. }
    
45. void pwmSetHigh(int pin)
    
46. {
    
47.    digitalWrite(pin, HIGH);
    
48. }
    
49. void pwmSetLow(int pin)
    
50. {
    
51.   digitalWrite(pin, LOW);
    
52. }
    
53. void pwmStartLow(int pin)      
    
54. {
    
55.   pwmSetLow(pin);
    
56.   pwmTickersSetLow[pin].attach_ms(pwmDutyCycle, pwmSetLow, pin);   
    
57. }
    
58. /********************** PWM Driver *********************/
    
59. 
    
60. Ticker timer;
    
61. unsigned char val_L1 =1;//左1
    
62. unsigned char val_L2 =1;//左2
    
63. unsigned char val_R2 =1;//右2
    
64. unsigned char val_R1 =1;//右1
    
65. unsigned char temp=0;
    
66. unsigned char bb=0;
    
67. unsigned char flag=0;
    
68. int value = 0;
    
69. 
    
70. //定时每0.1秒红外自动扫描
    
71. void tick_Infrared_control()
    
72. {
    
73.   val_L1=digitalRead(left1);
    
74.   val_L2=digitalRead(left2);
    
75.   val_R2=digitalRead(right2);
    
76.   val_R1=digitalRead(right1);
    
77.   temp=0;
    
78.   temp=temp|(val_L1);
    
79.   temp=(temp<<1)|(val_L2);
    
80.   temp=(temp<<1)|(val_R2);
    
81.   temp=(temp<<1)|(val_R1);
    
82.   bb=0x0f&temp;
    
83. }
    
84. 
    
85. void initParseData()
    
86. {
    
87. //电机控制初始化
    
88.   pinMode(PinPWMA, OUTPUT);
    
89.   pinMode(PinPWMB, OUTPUT);
    
90.   pinMode(PinDirA, OUTPUT);
    
91.   pinMode(PinDirB, OUTPUT);
    
92.   digitalWrite(PinDirA, HIGH);
    
93.   digitalWrite(PinDirB, HIGH);
    
94.   pwmWrite(PinPWMA, 100);
    
95.   pwmWrite(PinPWMB, 100);
    
96. //红外扫描初始化  
    
97.   pinMode(left1, INPUT);
    
98.   pinMode(left2, INPUT);
    
99.   pinMode(right2, INPUT);
    
100.   pinMode(right1, INPUT);
     
101. //启动定时器
     
102.   timer.attach(0.1, tick_Infrared_control);//红外扫描
     
103. }
     
104. 
     
105. //小车控制
     
106. void go_stopp()//暂停
     
107. {
     
108.   pwmWrite(PinPWMA, 0);
     
109.   pwmWrite(PinPWMB, 0);
     
110.   delay(100);
     
111. }
     
112. void go_advance(int value)// 前进
     
113. {
     
114.   int aa;
     
115.   aa=value;
     
116.   digitalWrite(PinDirA, HIGH);
     
117.   digitalWrite(PinDirB, HIGH);
     
118.   pwmWrite(PinPWMA, aa);
     
119.   pwmWrite(PinPWMB, aa);
     
120.   delay(100);
     
121. }
     
122. void go_advance1(int value)// 前进 偏向左
     
123. {
     
124.   int aa;
     
125.   aa=value;
     
126.   digitalWrite(PinDirA, HIGH);
     
127.   digitalWrite(PinDirB, HIGH);
     
128.   pwmWrite(PinPWMA, aa);
     
129.   pwmWrite(PinPWMB, aa+20);
     
130.   delay(100);
     
131. }
     
132. void go_advance2(int value)// 前进 偏向右
     
133. {
     
134.   int aa;
     
135.   aa=value;
     
136.   digitalWrite(PinDirA, HIGH);
     
137.   digitalWrite(PinDirB, HIGH);
     
138.   pwmWrite(PinPWMA, aa+20);
     
139.   pwmWrite(PinPWMB, aa);
     
140.   delay(100);
     
141. }
     
142. void go_back(int value)//后退
     
143. {
     
144.   int aa;
     
145.   aa=value;
     
146.   digitalWrite(PinDirA, LOW);
     
147.   digitalWrite(PinDirB, LOW);   
     
148.   pwmWrite(PinPWMA, aa);
     
149.   pwmWrite(PinPWMB, aa);
     
150.   delay(100);
     
151. }
     
152. void go_left_1(int value)//原地左转  
     
153. {
     
154.   int aa;
     
155.   aa=value;
     
156.   digitalWrite(PinDirA, LOW);
     
157.   digitalWrite(PinDirB, HIGH);
     
158.   pwmWrite(PinPWMA, 0);
     
159.   pwmWrite(PinPWMB, aa);
     
160.   delay(100);
     
161. }
     
162. void go_left_2(int value)//大左转(双轮)
     
163. {
     
164.   int aa;
     
165.   aa=value;
     
166.   digitalWrite(PinDirA, LOW);
     
167.   digitalWrite(PinDirB, HIGH);
     
168.   pwmWrite(PinPWMA, aa);
     
169.   pwmWrite(PinPWMB, aa);
     
170.   delay(100);
     
171. }
     
172. void go_right_1(int value)//原地右转
     
173. {
     
174.   int aa;
     
175.   aa=value;
     
176.   digitalWrite(PinDirA, HIGH);
     
177.   digitalWrite(PinDirB, LOW);
     
178.   pwmWrite(PinPWMA, aa);
     
179.   pwmWrite(PinPWMB, 0);
     
180.   delay(100);
     
181. }
     
182. void go_right_2(int value)//大右转(双轮)
     
183. {
     
184.   int aa;
     
185.   aa=value;
     
186.   digitalWrite(PinDirA, HIGH);
     
187.   digitalWrite(PinDirB, LOW);
     
188.   pwmWrite(PinPWMA, aa);
     
189.   pwmWrite(PinPWMB, aa);
     
190.   delay(100);
     
191. }
     
192. 
     
193. //循迹程序
     
194. 
     
195. void setup()
     
196. {
     
197.   initParseData();
     
198.   delay(10);
     
199.   go_advance(100);
     
200. }
     
201. 
     
202. void loop()
     
203. {
     
204.   switch(bb)
     
205.   {
     
206.     case 0x00:  //0000   0
     
207.     {
     
208.       go_advance(50);
     
209.       break;
     
210.     }
     
211.     case 0x08:   //1000  8
     
212.     {
     
213.       go_left_2(90);
     
214.       flag=1;
     
215.       break;
     
216.     }
     
217.     case 0x0c:   //1100  12
     
218.     {
     
219.       go_left_1(140);
     
220.       flag=1;
     
221.       break;
     
222.     }
     
223.     case 0x04:   //0100  4
     
224.     {
     
225.       go_left_1(80);
     
226.       delay(100);
     
227.       go_advance(100);
     
228.       break;
     
229.     }
     
230.     case 0x0e:   //1110  14
     
231.     {
     
232.       go_advance1(100);
     
233.       break;
     
234.     }
     
235.     case 0x06:   //0110  6
     
236.     {
     
237.       go_advance(100);
     
238.       flag=0;
     
239.       break;
     
240.     }
     
241.     case 0x07:   //0111  7
     
242.     {
     
243.       go_advance2(90);
     
244.       break;
     
245.     }
     
246.     case 0x02:   //0010  2
     
247.     {
     
248.       go_right_1(80);
     
249.       delay(100);
     
250.       go_advance(100);
     
251.       break;
     
252.     }
     
253.     case 0x03:   //0011  3
     
254.     {
     
255.       go_right_1(100);
     
256.       flag=2;
     
257.       break;
     
258.     }
     
259.     case 0x01:   //0001  1
     
260.     {
     
261.       go_right_1(120);
     
262.       flag=2;
     
263.       break;
     
264.     }
     
265.     case 0x0f:   //1111  15
     
266.     {
     
267.       go_left_2(100);
     
268.       flag=2;
     
269.       break;
     
270.     }
     
271.     default :
     
272.     {
     
273.       switch(flag)   
     
274.       {
     
275.         case 0:go_advance(100);break;
     
276.         case 1:go_left_1(120);break;
     
277.         case 2:go_right_1(110);break;
     
278.         case 3:go_stopp();break;      
     
279.       }
     
280.     }
     
281.   }
     
282. }

复制代码

5，实物连接与效果图：