手把手教你做蓝牙小车

前些日子一直在看鸿哥的程序感觉光看也只是纸上谈兵，所以想通过做小车的方式深入的体会一下鸿哥的程序。想学习鸿哥的程序的可点击下面的连接
（连载中...）从业将近十年！手把手教你单片机程序框架。废话少说先上零件图

小车底盘

电机驱动

蓝牙模块HC-06

12V锂电池

烧写器

安卓app蓝牙小车

单片机最小系统
本来想自己画板子做模块的，但是老师给了我一大堆模块，没办法就用老师的模块吧
嘿嘿

模块都上了怎么连接?
那我就简单的说一下，

电机驱动：8个控制端接51单片机P0口，驱动PWM使能端接P2.0-P2.3。
因为电机驱动上有5V输出电压所以可以恰好给单片机供电，所以很好的解决了单片机要与驱动共地的问题。

蓝牙模块：蓝牙模块的RXD接单片机的P3.1，蓝牙模块的TXD接单片机的P3.0.蓝牙模块的电源接单片机的电源。

哈哈简单吧

接下来上源代码

1. #include "reg51.h"
   
2. 
   
3. 
   
4. 
   
5. sbit PWM1 = P2^0;//右后轮电机驱动使能
   
6. sbit PWM2 = P2^1;//左后轮电机驱动使能
   
7. sbit PWM3 = P2^2;//右前轮电机驱动使能
   
8. sbit PWM4 = P2^3;//左前轮电机驱动使能
   
9. 
   
10. sbit motor_control_1 = P0^0;//右后轮后退
    
11. sbit motor_control_2 = P0^1;//右后轮前进
    
12. sbit motor_control_3 = P0^2;//左后轮后退
    
13. sbit motor_control_4 = P0^3;//左后轮前进
    
14. sbit motor_control_5 = P0^4;//右前轮后退
    
15. sbit motor_control_6 = P0^5;//右前轮前进
    
16. sbit motor_control_7 = P0^6;//左前轮后退
    
17. sbit motor_control_8 = P0^7;//左前轮前进
    
18. unsigned char ucBluetoothData = 230;//设置初始速度最大值为255最小为125
    
19. 
    
20. unsigned char ucLock = 0;//互斥量，俗称原子锁
    
21. 
    
22. 
    
23. unsigned int uiPWMCnt1 = 0;
    
24. unsigned int uiPWM1 = 230;
    
25. unsigned int uiPWMCnt2 = 0;
    
26. unsigned int uiPWM2 = 230;
    
27. unsigned int uiPWMCnt3 = 0;
    
28. unsigned int uiPWM3 = 230;
    
29. unsigned int uiPWMCnt4 = 0;
    
30. unsigned int uiPWM4 = 230;
    
31. 
    
32. unsigned char ucTempPWM;//设置中间变量
    
33. 
    
34. 
    
35. 
    
36. void initial_myself();
    
37. void initial_peripheral();
    
38. void T0_time();
    
39. void usart_service(void);
    
40. //void usart_send(unsigned char ucSendData);
    
41. void delay_long(unsigned int uiDelayLong);
    
42. void go_forward(void);//前进
    
43. void fall_back(void);//后退
    
44. void turn_left(void);//左转
    
45. void turn_right(void);//右转
    
46. void stop();//刹车
    
47. 
    
48. void main()
    
49. {
    
50.         initial_myself();
    
51.         delay_long(100);
    
52.         initial_peripheral();
    
53.         while(1)
    
54.         {
    
55.                 usart_service();
    
56.                
    
57. //                delay_long(500);
    
58.                
    
59.        
    
60.         }
    
61. 
    
62. }
    
63. //串口服务函数
    
64. void usart_service()
    
65. {
    
66.                
    
67.                 switch(ucBluetoothData)
    
68.                 {
    
69.                         case 0x04://前进
    
70.                                 ucBluetoothData = 0x02;//避免一直触发
    
71.                                 go_forward();
    
72.                                 ucLock = 1;
    
73.                                 uiPWM1 = uiPWM2 = uiPWM3 = uiPWM4 = ucTempPWM;
    
74.                                 ucLock = 0;
    
75.                                 break;
    
76.                         case 0x05://左转
    
77.                             ucBluetoothData = 0x02;//避免一直触发
    
78.                                 turn_left();
    
79.                                 ucLock = 1;
    
80.                                 uiPWM2 = uiPWM4= ucTempPWM / 4;
    
81.                                 uiPWM3 =uiPWM1 = ucTempPWM;
    
82.                                 ucLock = 0;
    
83.                                 break;
    
84.                         case 0x06://右转
    
85.                                 ucBluetoothData = 0x02;//避免一直触发
    
86.                                 turn_right();
    
87.                                 ucLock = 1;
    
88.                                 uiPWM2 = uiPWM4 = ucTempPWM;
    
89.                                 uiPWM3 =uiPWM1 = ucTempPWM / 4;
    
90.                                 ucLock = 0;
    
91.                                 break;
    
92.                         case 0x07://后退
    
93.                                 ucBluetoothData = 0x02;//避免一直触发
    
94.                                 fall_back();
    
95.                                 ucLock = 1;
    
96.                                 uiPWM1 = uiPWM2 = uiPWM3 = uiPWM4 = ucTempPWM;
    
97.                                 ucLock = 0;
    
98.                                 break;
    
99.                         case 0x01:
    
100.                                 ucBluetoothData = 0x02;//避免一直触发
     
101.                                 stop();       
     
102.                                 ucLock = 1;
     
103.                                 uiPWM1 = uiPWM2 = uiPWM3 = uiPWM4 = ucTempPWM;
     
104.                                 ucLock = 0;
     
105.                                 break;
     
106.                         case 0x00:
     
107.                                 ucBluetoothData = 0x02;//避免一直触发
     
108.                                 stop();
     
109.                                 ucLock = 1;
     
110.                                 uiPWM1 = uiPWM2 = uiPWM3 = uiPWM4 = ucTempPWM;
     
111.                                 ucLock = 0;
     
112.                                 break;
     
113.                         default :
     
114.                                 break;
     
115.        
     
116.                 }
     
117.                 delay_long(100);
     
118. //                usart_send(ucBluetoothData);
     
119.                 //速度调节的数据
     
120.                 if(ucBluetoothData！=0x00&&ucBluetoothData！=0x01 && ucBluetoothData！=0x02 &&  ucBluetoothData！=0x04 && ucBluetoothData！=0x05 && ucBluetoothData！=0x06 && ucBluetoothData！=0x07)
     
121.                 {
     
122.                         ucLock = 1;
     
123.                         ucTempPWM = uiPWM1 = uiPWM2 = uiPWM3 = uiPWM4 = ucBluetoothData;
     
124.                         ucLock = 0;
     
125.                 }
     
126. 
     
127. }
     
128. void T0_time() interrupt 1
     
129. {
     
130.         TF0 = 0;//清除中断标志
     
131.         TR0 = 0;//关定时器
     
132.         uiPWMCnt1 ++;
     
133.         uiPWMCnt2 ++;
     
134.         uiPWMCnt3 ++;
     
135.         uiPWMCnt4 ++;
     
136.         if(ucLock == 0)
     
137.         {
     
138.                 if(uiPWMCnt1 > 255)
     
139.                 {
     
140.                         uiPWMCnt1 = 0;
     
141.                 }
     
142.                 if(uiPWMCnt1 < uiPWM1)
     
143.                 {
     
144.                         PWM1 = 1;
     
145.                        
     
146.                 }
     
147.                 else
     
148.                 {
     
149.                         PWM1 = 0;
     
150.                 }
     
151.        
     
152.                 if(uiPWMCnt2 > 255)
     
153.                 {
     
154.                         uiPWMCnt2 = 0;
     
155.                 }
     
156.                 if(uiPWMCnt2 < uiPWM2)
     
157.                 {
     
158.                         PWM2 = 1;
     
159.                        
     
160.                 }
     
161.                 else
     
162.                 {
     
163.                         PWM2 = 0;
     
164.                 }
     
165.        
     
166.                 if(uiPWMCnt3 > 255)
     
167.                 {
     
168.                         uiPWMCnt3 = 0;
     
169.                 }
     
170.                 if(uiPWMCnt3 < uiPWM3)
     
171.                 {
     
172.                         PWM3 = 1;
     
173.                        
     
174.                 }
     
175.                 else
     
176.                 {
     
177.                         PWM3 = 0;
     
178.                 }
     
179.        
     
180.                 if(uiPWMCnt4 > 255)
     
181.                 {
     
182.                         uiPWMCnt4 = 0;
     
183.                 }
     
184.                 if(uiPWMCnt4 < uiPWM4)
     
185.                 {
     
186.                         PWM4 = 1;
     
187.                        
     
188.                 }
     
189.                 else
     
190.                 {
     
191.                         PWM4 = 0;
     
192.                 }
     
193.        
     
194.        
     
195.         }
     
196. 
     
197.         TH0 = 0xff;
     
198.         TL0 = 0x28;
     
199.         TR0 = 1;///开定时器
     
200. 
     
201. }
     
202. 
     
203. void initial_myself()
     
204. {
     
205.         TMOD = 0x01;//设置定时器0为工作方式1
     
206.         TH0 = 0xff;
     
207.         TL0 = 0x28;
     
208. 
     
209.         //配置串口
     
210.         SCON = 0x50;
     
211.         TMOD = 0x21;
     
212.         TH1 = TL1 = -(11095200L/12/32/9600);
     
213.         IP = 0x10;
     
214.         stop();
     
215.         PWM1 = 1;
     
216.         PWM2 = 1;
     
217.         PWM3 = 1;
     
218.         PWM4 = 1;
     
219. 
     
220. }
     
221. 
     
222. void initial_peripheral()
     
223. {
     
224.         EA = 1;//开总中断
     
225.         ES = 1;//允许串口中断
     
226.         ET0 = 1;//允许定时器中断
     
227.         TR0 = 1;//启动定时器
     
228.         TR1 = 1;//
     
229. }
     
230. void usart_receive(void) interrupt 4
     
231. {
     
232. 
     
233.         if(RI == 1)
     
234.         {
     
235.                 RI = 0;
     
236.                 ucBluetoothData = SBUF;
     
237. //                uiSendCnt = 0;
     
238.         }
     
239. 
     
240.         else
     
241.         {
     
242.                 TI = 0;
     
243.         }
     
244. 
     
245. }
     
246. //void usart_send(unsigned char ucSendData)
     
247. //{
     
248. //        ES = 0;
     
249. //        TI = 0;
     
250. //        SBUF = ucSendData;
     
251. //        TI = 0;
     
252. //        ES = 1;
     
253. //
     
254. //}
     
255. void delay_long(unsigned int uiDelayLong)
     
256. {
     
257.         unsigned int i;
     
258.         unsigned int j;
     
259.         for(i = 0 ; i < uiDelayLong ; i++)
     
260.         {
     
261.                 for(j = 0; j < 500; j++);
     
262.        
     
263.         }
     
264. 
     
265. }
     
266. void stop()//停止
     
267. {
     
268.         motor_control_1 = 0;
     
269.         motor_control_2 = 0;
     
270.         motor_control_3 = 0;
     
271.         motor_control_4 = 0;
     
272.         motor_control_5 = 0;
     
273.         motor_control_6 = 0;
     
274.         motor_control_7 = 0;
     
275.         motor_control_8 = 0;
     
276. }
     
277. void fall_back()
     
278. {
     
279.         motor_control_1 = 1;
     
280.         motor_control_2 = 0;
     
281.         motor_control_3 = 1;
     
282.         motor_control_4 = 0;
     
283.         motor_control_5 = 1;
     
284.         motor_control_6 = 0;
     
285.         motor_control_7 = 1;
     
286.         motor_control_8 = 0;
     
287. }
     
288. void go_forward()
     
289. {
     
290.         motor_control_1 = 0;
     
291.         motor_control_2 = 1;
     
292.         motor_control_3 = 0;
     
293.         motor_control_4 = 1;
     
294.         motor_control_5 = 0;
     
295.         motor_control_6 = 1;
     
296.         motor_control_7 = 0;
     
297.         motor_control_8 = 1;
     
298. }
     
299. void turn_left()//左转
     
300. {
     
301.         motor_control_1 = 0;
     
302.         motor_control_2 = 1;
     
303.         motor_control_3 = 0;
     
304.         motor_control_4 = 1;
     
305.         motor_control_5 = 0;
     
306.         motor_control_6 = 1;
     
307.         motor_control_7 = 0;
     
308.         motor_control_8 = 1;
     
309.        
     
310. }
     
311. void turn_right()//右转
     
312. {
     
313.         motor_control_1 = 0;
     
314.         motor_control_2 = 1;
     
315.         motor_control_3 = 0;
     
316.         motor_control_4 = 1;
     
317.         motor_control_5 = 0;
     
318.         motor_control_6 = 1;
     
319.         motor_control_7 = 0;
     
320.         motor_control_8 = 1;
     
321. }

复制代码

哈哈看着是不是似曾相识的赶脚

接下来上软件

连接上皆可以玩了
密码是1234哦。
软件在这里：http://pan.baidu.com/s/1eQnEHoA

以上只是安装过程。
细心的朋友会发现这个软件发出来的数据怎么得到的呢?
接下来教大家怎么获得手机发出来的数据：

用PL2303烧写器和蓝牙相连，
接法和单片机相连的接法一样。
TXD-RXD
RXD-TXD
注意电源别接反哦！如果不行就再反过来接！总有一个顺序可以
没有PL2303也可以用学习板哦！

看看眼熟不烧写软件上面有串口助手哦！功能强大吧！
打开串口
配置如上
端口怎么找?这个就不要问了嘛?
右键计算机-设备管理器-端口

手机连接上蓝牙发数据，数据出来了吧！
哈哈就这么简单！
晒张总图

玩小车去喽！

小结：之前做过小车本以为做个蓝牙小车手到擒来，但是还是遇到了几个问题
1.一开始不知道最小系统的晶振是12Mhz的导致系统不正常，所以一定要使用11。0592的晶振呀！
2.调小车轮子转动的方向一定要一个一个调，切记！切记！
3.最后就是程序，调的时候一个功能一个功能的实现，没有一下子都把程序写出来的，因为涉及到串口，有必要还要编写一个发送串口数据的子函数，这样在电脑上可以随时看到你发送的数据！
后续还有小车pid算法，寻光，循迹的研究希望大家继续关注！
有不懂的加我qq727142092

                                                                            河北科技师范学院
                                                                            电子爱好者协会
                                                                            邱增顺
                                       

小编,app是自己写的吗?

谢小编分享

赞一个

不错。值得学习！

要不要这么全面啊

收藏了，我也想做一个蓝牙小车。

牛b啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊

必须给赞啊

学习学习，谢谢分享！

好厉害。

好东西，先收藏了，谢谢小编的分享！

好东西，先收藏了，谢谢小编的分享！

不错不错啊                           

有时间我也做一个，还请小编帮忙啊

真牛掰~有时间我也做一个，还请小编帮忙啊

>我*，大婶啊                        

APP有源码吗