标题: 基于51单片机的智能迷宫小车设计 含PCB原理图 源程序 [打印本页]

---

作者: 51hei学习技术中    时间: 2017-3-4 03:24
标题: 基于51单片机的智能迷宫小车设计 含PCB原理图 源程序

单片机的智能迷宫小车的原理图和pcb，都是用ad画的








51单片机的智能迷宫小车的所有资料下载：
迷宫源程序.zip (112.56 KB, 下载次数: 157)

2017-3-4 03:23 上传

点击文件名下载附件
下载积分: 黑币 -5

小车电路图.zip (2.37 MB, 下载次数: 134)

2017-3-4 03:23 上传

点击文件名下载附件
下载积分: 黑币 -5

下面是部分代码预览：

1. #include<reg52.h>
   
2. #include<stdio.h>
   
3. #include <intrins.h>
   
4. #include<string.h>
   
5. #include<math.h>
   
6. #define uchar unsigned char  //无符号字符型占用一个字节 范围0~255,                          
   
7. #define uint unsigned int  /*无符号整型占用二个字节 范围0~65535*/
   
8. #define dataPort P1
   
9. uchar bianma1;           //编码计数
   
10. uint yejinjishu=0;        //液晶计数
    
11. uchar wang=1;
    
12. uchar guo=1;
    
13. uchar  a1=0,a2=0,a3=0,a4=0;         //小车方向判断
    
14. uchar  b1=0,b2=0,b3=0,b4=0;
    
15. 
    
16. //电机操作初始化
    
17. uchar i=0,j=0; /* 中断计数器 */  
    
18. uchar m1=0; /* 电机1速度值 */  
    
19. uchar m2=0; /* 电机2速度值 */   
    
20. 
    
21. sbit s1=P0^0; /* L298的Input 1 */  
    
22. sbit s2=P0^1; /* L298的Input 2 */  
    
23. sbit s3=P0^2; /* L298的Input 3 */  
    
24. sbit s4=P0^3; /* L298的Input 4 */
    
25. sbit en1=P0^4; /* L298的Enable A */  
    
26. sbit en2=P0^5; /* L298的Enable B */  
    
27. 
    
28. //寻线 红外接收头 初始化
    
29. sbit P2_2=P3^1;
    
30. sbit P2_3=P2^3;
    
31. sbit P2_4=P2^4;
    
32. sbit P2_5=P2^5;
    
33. sbit P2_6=P2^6;
    
34. sbit P2_7=P2^7;
    
35. 
    
36. //按键初始化
    
37. sbit markkey=P2^0;  
    
38. sbit logokey=P2^1;  
    
39. uchar mark=0;  //选线while 标志
    
40. uchar logo=0;  //最佳路线行走标记
    
41. 
    
42. 
    
43. unsigned char idata road[30];         //转向数组
    
44. unsigned char code aa[10][4]={"LBL","LBA","ABL","ABA","ABR","RBA","RBR","RBL","LBR"};//数组无需改变 code
    
45. unsigned char code  a[10][2]={"A","R","R","B","L","L","A","B","B"};
    
46. unsigned char idata *p;   //地址寄存器 用于字符串操作
    
47. //unsigned char idata  cun24c02[15];//ram允许情况可以无限添加 记忆数组
    
48. 
    
49. 
    
50. // 函数初始化
    
51. void KEY();
    
52. void line();
    
53. void stop();
    
54. void youlun();
    
55. void zuolun();
    
56. void zhizou();
    
57. void zhizou1();
    
58. void zhizou2();
    
59. void ISD1420p(uchar t1,uint t2);
    
60. void Run_SNAKE(void);
    
61. 
    
62. 
    
63. /********简易延时函数******/  
    
64. void delay(uint t)
    
65. {  
    
66.     for(t;t>0;t--);  
    
67. }
    
68. 
    
69. void DelayUs(uint us)  //标准延时 us
    
70. {
    
71. unsigned char uscnt;
    
72. uscnt=us>>1;         
    
73. while(--uscnt);
    
74. }
    
75. 
    
76. void DelayMs(uint ms)  //标准延时 ms
    
77. {
    
78. while(--ms)
    
79.    {
    
80.      DelayUs(250);
    
81.      DelayUs(250);
    
82.      DelayUs(250);
    
83.      DelayUs(250);
    
84.    }
    
85. }  
    
86. 
    
87. 
    
88. 
    
89. //595 初始化 串转并
    
90. /*sbit sclk=P3^0;
    
91. sbit dat=P3^1;       
    
92. sbit st = P2^1;
    
93. void write595(uchar wrdat)
    
94. {
    
95.   uchar sum;
    
96.   for(sum=0;sum<8;sum++)
    
97.      {
    
98.                   sclk=0;
    
99.                   dat=wrdat&0x80;
    
100.                   wrdat<<=1;
     
101.                   sclk=1;
     
102.          }
     
103.   st=0;
     
104.   _nop_();
     
105.   _nop_();
     
106.   _nop_();
     
107.   _nop_();
     
108.   _nop_();
     
109.   _nop_();
     
110.   _nop_();
     
111.   st=1;
     
112. } */
     
113. sbit SDA=P0^6;//sbit dat=P3^1;
     
114. sbit SCL=P2^2;//sbit sclk=P3^0;
     
115. sbit jiyibiaozhi=P0^7;//st = P2^1;
     
116. void write595(uchar wrdat)
     
117. {
     
118.   uchar sum;
     
119.   for(sum=0;sum<8;sum++)
     
120.      {
     
121.                   SCL=0;
     
122.                   SDA=wrdat&0x80;
     
123.                   wrdat<<=1;
     
124.                   SCL=1;
     
125.          }
     
126.   jiyibiaozhi=0;
     
127.   _nop_();
     
128.   _nop_();
     
129.   _nop_();
     
130.   _nop_();
     
131.   _nop_();
     
132.   _nop_();
     
133.   _nop_();
     
134.   jiyibiaozhi=1;
     
135. }
     
136. 
     
137. /*******************************************************
     
138. ********************************************************
     
139. ***************24c02部分*********************************
     
140. ********************************************************
     
141. *******************************************************
     
142. #define  _Nop()  _nop_()  //定义空指令                       
     
143. bit ack;                      //应答标志位
     
144. //sbit SDA=P2^1;
     
145. //sbit SCL=P2^0;
     
146. /*------------------------------------------------
     
147.                     启动总线
     
148. ------------------------------------------------
     
149. void Start_I2c()
     
150. {
     
151.   SDA=1;   //发送起始条件的数据信号
     
152.   _Nop();
     
153.   SCL=1;
     
154.   _Nop();    //起始条件建立时间大于4.7us,延时
     
155.   _Nop();
     
156.   _Nop();
     
157.   _Nop();
     
158.   _Nop();   
     
159.   SDA=0;     //发送起始信号
     
160.   _Nop();    //起始条件锁定时间大于4μ
     
161.   _Nop();
     
162.   _Nop();
     
163.   _Nop();
     
164.   _Nop();      
     
165.   SCL=0;    //钳住I2C总线，准备发送或接收数据
     
166.   _Nop();
     
167.   _Nop();
     
168. }
     
169. /*------------------------------------------------
     
170.                     结束总线
     
171. -----------------------------------------------
     
172. void Stop_I2c()
     
173. {
     
174.   SDA=0;    //发送结束条件的数据信号
     
175.   _Nop();   //发送结束条件的时钟信号
     
176.   SCL=1;    //结束条件建立时间大于4μ
     
177.   _Nop();
     
178.   _Nop();
     
179.   _Nop();
     
180.   _Nop();
     
181.   _Nop();
     
182.   SDA=1;    //发送I2C总线结束信号
     
183.   _Nop();
     
184.   _Nop();
     
185.   _Nop();
     
186.   _Nop();
     
187. }
     
188. /*----------------------------------------------------------------
     
189.                  字节数据传送函数               
     
190. 函数原型: void  SendByte(unsigned char c);
     
191. 功能:  将数据c发送出去,可以是地址,也可以是数据,发完后等待应答,并对
     
192.      此状态位进行操作.(不应答或非应答都使ack=0 假)     
     
193.      发送数据正常，ack=1; ack=0表示被控器无应答或损坏。
     
194. ------------------------------------------------------------------
     
195. void  SendByte(unsigned char c)
     
196. {
     
197. unsigned char BitCnt;
     
198. 
     
199. for(BitCnt=0;BitCnt<8;BitCnt++)  //要传送的数据长度为8位
     
200.     {
     
201.      if((c<<BitCnt)&0x80)SDA=1;   //判断发送位
     
202.        else  SDA=0;               
     
203.      _Nop();
     
204.      SCL=1;               //置时钟线为高，通知被控器开始接收数据位
     
205.       _Nop();
     
206.       _Nop();             //保证时钟高电平周期大于4μ
     
207.       _Nop();
     
208.       _Nop();
     
209.       _Nop();         
     
210.      SCL=0;
     
211.     }
     
212.    
     
213.     _Nop();
     
214.     _Nop();
     
215.     SDA=1;               //8位发送完后释放数据线，准备接收应答位
     
216.     _Nop();
     
217.     _Nop();   
     
218.     SCL=1;
     
219.     _Nop();
     
220.     _Nop();
     
221.     _Nop();
     
222.     if(SDA==1)ack=0;     
     
223.        else ack=1;        //判断是否接收到应答信号
     
224.     SCL=0;
     
225.     _Nop();
     
226.     _Nop();
     
227. }
     
228. 
     
229. /*----------------------------------------------------------------
     
230.                  字节数据传送函数               
     
231. 函数原型: unsigned char  RcvByte();
     
232. 功能:  用来接收从器件传来的数据,并判断总线错误(不发应答信号)，
     
233.      发完后请用应答函数。  
     
234. ------------------------------------------------------------------       
     
235. unsigned char  RcvByte()
     
236. {
     
237.   unsigned char retc;
     
238.   unsigned char BitCnt;
     
239.   
     
240.   retc=0;
     
241.   SDA=1;             //置数据线为输入方式
     
242.   for(BitCnt=0;BitCnt<8;BitCnt++)
     
243.       {
     
244.         _Nop();           
     
245.         SCL=0;       //置时钟线为低，准备接收数据位
     
246.         _Nop();
     
247.         _Nop();      //时钟低电平周期大于4.7us
     
248.         _Nop();
     
249.         _Nop();
     
250.         _Nop();
     
251.         SCL=1;       //置时钟线为高使数据线上数据有效
     
252.         _Nop();
     
253.         _Nop();
     
254.         retc=retc<<1;
     
255.         if(SDA==1)retc=retc+1; //读数据位,接收的数据位放入retc中
     
256.         _Nop();
     
257.         _Nop();
     
258.       }
     
259.   SCL=0;   
     
260.   _Nop();
     
261.   _Nop();
     
262.   return(retc);
     
263. }
     
264. 
     
265. /*----------------------------------------------------------------
     
266.                      应答子函数
     
267. 原型:  void Ack_I2c(void);
     
268. 
     
269. ---------------------------------------------------------------
     
270. void Ack_I2c(void)
     
271. {
     
272.   
     
273.   SDA=0;     
     
274.   _Nop();
     
275.   _Nop();
     
276.   _Nop();      
     
277.   SCL=1;
     
278.   _Nop();
     
279.   _Nop();              //时钟低电平周期大于4μ
     
280.   _Nop();
     
281.   _Nop();
     
282.   _Nop();  
     
283.   SCL=0;               //清时钟线，钳住I2C总线以便继续接收
     
284.   _Nop();
     
285.   _Nop();   
     
286. }
     
287. /*----------------------------------------------------------------
     
288.                      非应答子函数
     
289. 原型:  void NoAck_I2c(void);
     
290. 
     
291. ----------------------------------------------------------------
     
292. void NoAck_I2c(void)
     
293. {
     
294.   
     
295.   SDA=1;
     
296.   _Nop();
     
297.   _Nop();
     
298.   _Nop();      
     
299.   SCL=1;
     
300.   _Nop();
     
301.   _Nop();              //时钟低电平周期大于4μ
     
302.   _Nop();
     
303.   _Nop();
     
304.   _Nop();  
     
305.   SCL=0;                //清时钟线，钳住I2C总线以便继续接收
     
306.   _Nop();
     
307.   _Nop();   
     
308. }
     
309. /*----------------------------------------------------------------
     
310.                     向有子地址器件发送多字节数据函数               
     
311. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);  
     
312. 功能:     从启动总线到发送地址，子地址,数据，结束总线的全过程,从器件
     
313.           地址sla，子地址suba，发送内容是s指向的内容，发送no个字节。
     
314.            如果返回1表示操作成功，否则操作有误。
     
315. 注意：    使用前必须已结束总线。
     
316. ----------------------------------------------------------------
     
317. bit ISendStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no)
     
318. {
     
319.    unsigned char i;
     
320. for(i=0;i<no;i++)
     
321.     {
     
322.    Start_I2c();               //启动总线
     
323.    SendByte(sla);             //发送器件地址
     
324.      if(ack==0)return(0);
     
325.    SendByte(suba);            //发送器件子地址
     
326.      if(ack==0)return(0);
     
327. 
     
328.      SendByte(*s);            //发送数据
     
329.        if(ack==0)return(0);
     
330.      Stop_I2c();                  //结束总线
     
331.      DelayMs(1);               //必须延时等待芯片内部自动处理数据完毕
     
332.          s++;
     
333.          suba++;
     
334.     }
     
335.   return(1);
     
336. }
     
337. /*----------------------------------------------------------------
     
338.                     向有子地址器件读取多字节数据函数               
     
339. 函数原型: bit  ISendStr(unsigned char sla,unsigned char suba,ucahr *s,unsigned char no);  
     
340. 功能:     从启动总线到发送地址，子地址,读数据，结束总线的全过程,从器件
     
341.           地址sla，子地址suba，读出的内容放入s指向的存储区，读no个字节。
     
342.            如果返回1表示操作成功，否则操作有误。
     
343. 注意：    使用前必须已结束总线。
     
344. ---------------------------------------------------------------
     
345. bit IRcvStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char no)
     
346. {
     
347.    unsigned char i;
     
348. 
     
349.    Start_I2c();               //启动总线
     
350.    SendByte(sla);             //发送器件地址
     
351.      if(ack==0)return(0);
     
352.    SendByte(suba);            //发送器件子地址
     
353.      if(ack==0)return(0);
     
354. 
     
355.    Start_I2c();
     
356.    SendByte(sla+1);
     
357.       if(ack==0)return(0);
     
358. 
     
359.   for(i=0;i<no-1;i++)
     
360.     {
     
361.      *s=RcvByte();              //发送数据
     
362.       Ack_I2c();                //发送就答位
     
363.      s++;
     
364.     }
     
365.    *s=RcvByte();
     
366.     NoAck_I2c();                 //发送非应位
     
367.     Stop_I2c();                    //结束总线
     
368.   return(1);
     
369. }
     
370. 
     
371. /*------------------------------------------------
     
372.                    主函数
     
373. ------------------------------------------------
     
374. main()
     
375. {
     
376. //bit flag;
     
377. unsigned char i;
     
378. DelayMs(6000);
     
379. ISendStr(0xae,80,dat,5);            //写入24c02
     
380. DelayMs(10);                          //写入后必须延时等待24c02内部
     
381.                                        //烧录数据处理完毕方可继续其他操作
     
382. IRcvStr(0xae,80,dat1,5);             //从24c02读出数据
     
383. while(1)
     
384.      {
     
385. 
     
386.            for(i=0;i<5;i++)              //查表
     
387.              {
     
388.                  DelayMs(2000);
     
389.          P1=dat1[i];
     
390.                  }
     
391.          }
     
392. }  */
     
393. 
     
394. /*****************************************************
     
395. ******************************************************
     
396. **********************12864部分***********************
     
397. ******************************************************
     
398. *****************************************************/
     
399. sbit rs=P3^7;
     
400. sbit rw=P3^6;
     
401. sbit en=P3^5;
     
402. sbit psb=P3^4;
     
403. sbit rst=P3^3;
     
404. 
     
405. uchar key1=1,key2=1,key3=1,key4=1;
     
406. 
     
407. void checkBusy(void)   //判忙
     
408. {
     
409. rs=0;
     
410. rw=1;
     
411. en=1;
     
412. dataPort=0xff;
     
413. while(dataPort & 0x80);
     
414. en=0;
     
415. }
     
416. 
     
417. void writeCommand(unsigned char cmd)   //写命令
     
418. {
     
419. checkBusy();
     
420. rs=0;
     
421. rw=0;
     
422. en=1;
     
423. dataPort=cmd;
     
424. _nop_();
     
425. en=0;
     
426. }
     
427. 
     
428. void writeData(unsigned char adata)          //写数据
     
429. {
     
430. checkBusy();
     
431. rs=1;
     
432. rw=0;
     
433. en=1;
     
434. dataPort=adata;
     
435. _nop_();
     
436. en=0;
     
437. }
     
438. 
     
439. unsigned char readData(void)        //读数据
     
440. {
     
441. unsigned char RData;
     
442. dataPort=0xff;
     
443. checkBusy();
     
444. rs=1;
     
445. rw=1;
     
446. en=0;
     
447. en=1;
     
448. RData=dataPort;
     
449. en=0;
     
450. return RData;
     
451. }       
     
452. 
     
453. void ClrGDRAM(void)          //显示用户自定义字符
     
454. {
     
455.         unsigned char x,y;
     
456.         for(y=0;y<64;y++)
     
457.             for(x=0;x<16;x++)
     
458.             {
     
459.                         writeCommand(0x34);
     
460.             writeCommand(y+0x80);     //行地址  
     
461.             writeCommand(x+0x80);     //列地址  
     
462.             writeCommand(0x30);
     
463.             writeData(0x00);
     
464.             writeData(0x00);
     
465.         }
     
466.         //writeCommand(0x30);
     
467. }
     
468. 
     
469. void LcmInit(void)                        //12864初始化
     
470. {
     
471. writeCommand(0x30);
     
472. DelayMs(50);
     
473. writeCommand(0x01);
     
474. DelayMs(50);
     
475. writeCommand(0x06);
     
476. DelayMs(50);
     
477. writeCommand(0x0c);
     
478. ClrGDRAM();
     
479. psb=1;
     
480. }
     
481. 
     
482. /* 清屏*/
     
483. void ClrScreen()
     
484. {
     
485.    writeCommand(0x01);
     
486.    DelayMs(15);
     
487. }
     
488.           
     
489. /*画点  打点位置(x0,y0);color=1,点亮；color=0,擦除*/
     
490. void drawPoint(unsigned char x,unsigned char y,unsigned char color)
     
491. {
     
492. unsigned char row,collum,cbite;
     
493. unsigned char tempH,tempL;
     
494. writeCommand(0x34);
     
495. writeCommand(0x36);
     
496. collum=x>>4;
     
497. cbite=x&0x0f;
     
498. if(y<32)
     
499.         row=y;
     
500. else
     
501.         {row=y-32;
     
502.         collum+=8;
     
503.         }
     
504. writeCommand(0x80+row);
     
505. writeCommand(0x80+collum);
     
506. readData();
     
507. tempH=readData();
     
508. tempL=readData();
     
509. writeCommand(0x80+row);
     
510. writeCommand(0x80+collum);
     
511. if (color)
     
512. {
     
513.          if(cbite<8)
     
514.          {
     
515.          tempH|=(1<<(7-cbite));
     
516.          }
     
517.          else
     
518.          {
     
519.          tempL|=(1<<(15-cbite));
     
520.          }
     
521. }
     
522. else
     
523. {
     
524.            if(cbite<8)
     
525.          {
     
526.          tempH&=~(1<<(7-cbite));
     
527.          }
     
528.          else
     
529.          {
     
530.          tempL&=~(1<<(15-cbite));
     
531.          }
     
532. }
     
533. writeData(tempH);
     
534. writeData(tempL);
     
535. writeCommand(0x30);
     
536. }
     
537. 
     
538. /**3X3个点合为一个**/
     
539. void drawPoint_3(unsigned char x,unsigned char y, unsigned char color)   
     
540. {
     
541.   drawPoint(x,  y,  color);
     
542.   drawPoint(x+1,y,  color);
     
543.   drawPoint(x-1,y,  color);
     
544.   drawPoint(x+1,y-1,color);
     
545.   drawPoint(x,  y-1,color);
     
546.   drawPoint(x-1,y-1,color);
     
547.   drawPoint(x-1,y+1,color);
     
548.   drawPoint(x,  y+1,color);
     
549.   drawPoint(x+1,y+1,color);
     
550.    
     
551. }
     
552. 
     
553. void QCRAM()  //清楚RAM
     
554. {
     
555.    uchar x,y;
     
556.    uchar color=0;
     
557.    for(x=0;x<=128;x++)
     
558.      for(y=0;y<=80;y++)
     
559.            drawPoint(x,y,color);
     
560.           
     
561. 
     
562. }
     
563. 
     
564. #define SNAKE_Max_Long 20   //最大长度
     
565. struct
     
566. {
     
567.         uchar X[SNAKE_Max_Long];
     
568.         uchar Y[SNAKE_Max_Long];
     
569.         uchar Long;   
     
570. }Snake;        //小车结构体
     
571. 
     
572. void Init_SNAKE(void)   
     
573. {
     
574.         uchar sum;
     
575.         Snake.Long=2;                    //定义初始化小车的长度
     
576.         for(sum=0;sum<Snake.Long;sum++)        //将小车给赋值
     
577.         {
     
578.                 Snake.X[sum]=sum+20;
     
579.                 Snake.Y[sum]=20;
     
580.         }                                                       
     
581.         for(sum=0;sum<Snake.Long;sum++)        //将小车给画出来
     
582.         {
     
583.                 drawPoint_3(Snake.X[sum],Snake.Y[sum],1);
     
584.         }                                                       
     
585. }
     
586. 
     
587. void keyscan()          //转弯检测
     
588. {
     
589.   if(!key1||!key2||!key3||!key4)
     
590.   {
     
591.     Run_SNAKE();
     
592.            if(key1==0)
     
593.                 {
     
594.                           key1=1;
     
595.                           a1=0;
     
596.                           a2=0;
     
597.                           a3=0;
     
598.                   a4=1;                         
     
599.                 }       
     
600.         if(key2==0)
     
601.                 {
     
602.                       key2=1;
     
603.                           a1=1;
     
604.                           a2=0;
     
605.                           a3=0;
     
606.                           a4=0;
     
607.                 }       
     
608.         if(key3==0)
     
609.                 {
     
610.                           key3=1;
     
611.                           a1=0;
     
612.                           a2=1;
     
613.                           a3=0;
     
614.                           a4=0;
     
615.                 }               
     
616.         if(key4==0)
     
617.                 {
     
618.                           key4=1;
     
619.                           a1=0;
     
620.                           a2=0;
     
621.                           a3=1;
     
622.                           a4=0;
     
623.                 }       
     
624.    }       
     
625. }       
     
626. 
     
627. void Run_SNAKE(void)   //小车运动方向
     
628. {
     
629.         uchar sum=0;
     
630.         /***小车的运动方向**/
     
631.                         if(a1==1)
     
632.                         {
     
633.                            if(b1==1)
     
634.                                 {
     
635.                                            for(sum=0;sum<Snake.Long-1;sum++) // 向右 //小车身都是它前一段的小车身的位置
     
636.                                 {
     
637.                                      Snake.X[sum]=Snake.X[sum+1];
     
638.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
639.                             }
     
640.                
     
641.                                 Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
642.                                 Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+1; //小车头向你要求的方向移动
     
643.                                         }
     
644.                                 if(b2==1)
     
645.                                     {
     
646.                                                 for(sum=0;sum<Snake.Long-1;sum++) //向左  //小车身都是它前一段的小车身的位置
     
647.                                {
     
648.                                      Snake.X[sum]=Snake.X[sum+1];
     
649.                                  Snake.Y[sum]=Snake.Y[sum+1];
     
650.                                }
     
651.                
     
652.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
653.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]-1; //小车头向你要求的方向移动       
     
654.                                         }
     
655.                                  if(b3==1)
     
656.                                     {
     
657.                                                         for(sum=0;sum<Snake.Long-1;sum++)  //  向下  //小车身都是它前一段的小车身的位置
     
658.                            {
     
659.                                      Snake.X[sum]=Snake.X[sum+1];
     
660.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
661.                                }
     
662.                
     
663.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]-1;
     
664.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
665.                                         }
     
666.                                  if(b4==1)
     
667.                                     {
     
668.                                                  for(sum=0;sum<Snake.Long-1;sum++)  //  向上  //小车身都是它前一段的小车身的位置
     
669.                                {
     
670.                                       Snake.X[sum]=Snake.X[sum+1];
     
671.                                       Snake.Y[sum]=Snake.Y[sum+1];
     
672.                                }
     
673. 
     
674.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+1;
     
675.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
676.                                         }
     
677.                                        
     
678.                          if(!key1||!key2||!key3||!key4)
     
679.                             {
     
680.                           if(b1==1)
     
681.                            {
     
682.                                      b1=0;
     
683.                                   b2=1;
     
684.                                   b3=0;
     
685.                                   b4=0;
     
686.                            }
     
687.                           else if(b2==1)
     
688.                            {
     
689.                                      b1=1;
     
690.                                   b2=0;
     
691.                                   b3=0;
     
692.                                   b4=0;
     
693.                            }
     
694.                           else if(b3==1)
     
695.                            {
     
696.                                      b1=0;
     
697.                                   b2=0;
     
698.                                   b3=0;
     
699.                                   b4=1;
     
700.                            }
     
701.                           else if(b4==1)
     
702.                            {
     
703.                                      b1=0;
     
704.                                   b2=0;
     
705.                                   b3=1;
     
706.                                   b4=0;
     
707.                            }   
     
708.                             }
     
709.                         }
     
710.        
     
711. 
     
712.                         if(a2==1)
     
713.                         {
     
714.                           if(b1==1)
     
715.                                 {
     
716.                                                  for(sum=0;sum<Snake.Long-1;sum++)  //  向下   //小车身都是它前一段的小车身的位置
     
717.                            {
     
718.                                      Snake.X[sum]=Snake.X[sum+1];
     
719.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
720.                                }
     
721.                
     
722.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]-1;
     
723.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
724.                                         }
     
725.                                 if(b2==1)
     
726.                                     {
     
727.                                                  for(sum=0;sum<Snake.Long-1;sum++)  //  向上  //小车身都是它前一段的小车身的位置
     
728.                                {
     
729.                                       Snake.X[sum]=Snake.X[sum+1];
     
730.                                       Snake.Y[sum]=Snake.Y[sum+1];
     
731.                                }
     
732. 
     
733.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+1;
     
734.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
735.                                         }
     
736.                                  if(b3==1)
     
737.                                     {                          
     
738.                                                 for(sum=0;sum<Snake.Long-1;sum++) //向左   //小车身都是它前一段的小车身的位置
     
739.                                {
     
740.                                      Snake.X[sum]=Snake.X[sum+1];
     
741.                                  Snake.Y[sum]=Snake.Y[sum+1];
     
742.                                }
     
743.                
     
744.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
745.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]-1; //小车头向你要求的方向移动
     
746.                                         }
     
747.                                   if(b4==1)
     
748.                                     {
     
749.                                                 for(sum=0;sum<Snake.Long-1;sum++) // 向右  //小车身都是它前一段的小车身的位置
     
750.                                 {
     
751.                                      Snake.X[sum]=Snake.X[sum+1];
     
752.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
753.                             }
     
754.                
     
755.                                 Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
756.                                 Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+1; //小车头向你要求的方向移动
     
757.                                         }                 
     
758.                       if(!key1||!key2||!key3||!key4)
     
759.                             {
     
760.                                         if(b1==1)
     
761.                            {
     
762.                                      b1=0;
     
763.                                   b2=0;
     
764.                                   b3=0;
     
765.                                   b4=1;
     
766.                            }
     
767.                           else if(b2==1)
     
768.                            {
     
769.                                      b1=0;
     
770.                                   b2=0;
     
771.                                   b3=1;
     
772.                                   b4=0;
     
773.                            }
     
774.                           else if(b3==1)
     
775.                            {
     
776.                                      b1=1;
     
777.                                   b2=0;
     
778.                                   b3=0;
     
779.                                   b4=0;
     
780.                            }
     
781.                           else if(b4==1)
     
782.                            {
     
783.                                      b1=0;
     
784.                                   b2=1;
     
785.                                   b3=0;
     
786.                                   b4=0;
     
787.                            }   
     
788.                             }
     
789.                         }
     
790. 
     
791.                  
     
792.                         if(a3==1)
     
793.                         {
     
794.                           if(b1==1)
     
795.                                 {
     
796.                                             for(sum=0;sum<Snake.Long-1;sum++)  //  向上 //小车身都是它前一段的小车身的位置
     
797.                                {
     
798.                                       Snake.X[sum]=Snake.X[sum+1];
     
799.                                       Snake.Y[sum]=Snake.Y[sum+1];
     
800.                                }
     
801. 
     
802.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+1;
     
803.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
804.                                         }
     
805.                                 if(b2==1)
     
806.                                     {
     
807.                                                         for(sum=0;sum<Snake.Long-1;sum++)  //  向下 //小车身都是它前一段的小车身的位置
     
808.                            {
     
809.                                      Snake.X[sum]=Snake.X[sum+1];
     
810.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
811.                                }
     
812.                
     
813.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]-1;
     
814.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
815.                                         }
     
816.                                  if(b3==1)
     
817.                                     {
     
818.                                            for(sum=0;sum<Snake.Long-1;sum++) // 向右   //小车身都是它前一段的小车身的位置
     
819.                                 {
     
820.                                      Snake.X[sum]=Snake.X[sum+1];
     
821.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
822.                             }
     
823.                
     
824.                                 Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
825.                                 Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+1; //小车头向你要求的方向移动
     
826.                                         }
     
827.                                  if(b4==1)
     
828.                                     {
     
829.                                            for(sum=0;sum<Snake.Long-1;sum++) //向左  //小车身都是它前一段的小车身的位置
     
830.                                {
     
831.                                      Snake.X[sum]=Snake.X[sum+1];
     
832.                                  Snake.Y[sum]=Snake.Y[sum+1];
     
833.                                }
     
834.                
     
835.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
836.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]-1; //小车头向你要求的方向移动
     
837.                                         }                 
     
838.                          if(!key1||!key2||!key3||!key4)
     
839.                             {
     
840.                                         if(b1==1)
     
841.                            {
     
842.                                      b1=0;
     
843.                                   b2=0;
     
844.                                   b3=1;
     
845.                                   b4=0;
     
846.                            }
     
847.                           else if(b2==1)
     
848.                            {
     
849.                                      b1=0;
     
850.                                   b2=0;
     
851.                                   b3=0;
     
852.                                   b4=1;
     
853.                            }
     
854.                           else if(b3==1)
     
855.                            {
     
856.                                      b1=0;
     
857.                                   b2=1;
     
858.                                   b3=0;
     
859.                                   b4=0;
     
860.                            }
     
861.                           else if(b4==1)
     
862.                            {
     
863.                                      b1=1;
     
864.                                   b2=0;
     
865.                                   b3=0;
     
866.                                   b4=0;
     
867.                            }   
     
868.                             }
     
869.                         }
     
870.                
     
871. 
     
872.                         if(a4==1)
     
873.                         {
     
874.                             if(b1==1)
     
875.                                 {
     
876.                                            for(sum=0;sum<Snake.Long-1;sum++) //向左  //小车身都是它前一段的小车身的位置
     
877.                                {
     
878.                                      Snake.X[sum]=Snake.X[sum+1];
     
879.                                  Snake.Y[sum]=Snake.Y[sum+1];
     
880.                                }
     
881.                
     
882.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
883.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]-1; //小车头向你要求的方向移动
     
884.                                         }
     
885.                                 if(b2==1)
     
886.                                     {
     
887.                                             for(sum=0;sum<Snake.Long-1;sum++) // 向右  //小车身都是它前一段的小车身的位置
     
888.                                 {
     
889.                                      Snake.X[sum]=Snake.X[sum+1];
     
890.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
891.                             }
     
892.                
     
893.                                 Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+0;
     
894.                                 Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+1; //小车头向你要求的方向移动
     
895.                                         }
     
896.                                  if(b3==1)
     
897.                                     {
     
898.                                            for(sum=0;sum<Snake.Long-1;sum++)  //  向上 //小车身都是它前一段的小车身的位置
     
899.                                {
     
900.                                       Snake.X[sum]=Snake.X[sum+1];
     
901.                                       Snake.Y[sum]=Snake.Y[sum+1];
     
902.                                }
     
903. 
     
904.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]+1;
     
905.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
906. 
     
907.                                         }
     
908.                                  if(b4==1)
     
909.                                     {
     
910.                                                 for(sum=0;sum<Snake.Long-1;sum++)  //  向下  //小车身都是它前一段的小车身的位置
     
911.                            {
     
912.                                      Snake.X[sum]=Snake.X[sum+1];
     
913.                                      Snake.Y[sum]=Snake.Y[sum+1];
     
914.                                }
     
915.                
     
916.                                Snake.X[Snake.Long-1]=Snake.X[Snake.Long-2]-1;
     
917.                                Snake.Y[Snake.Long-1]=Snake.Y[Snake.Long-2]+0; //小车头向你要求的方向移动
     
918.                                         }
     
919.                          if(!key1||!key2||!key3||!key4)
     
920.                             {
     
921.                                         if(b1==1)
     
922.                            {
     
923.                                      b1=1;
     
924.                                   b2=0;
     
925.                                   b3=0;
     
926.                                   b4=0;
     
927.                            }
     
928.                           else if(b2==1)
     
929.                            {
     
930.                                      b1=0;
     
931.                                   b2=1;
     
932.                                   b3=0;
     
933.                                   b4=0;
     
934.                            }
     
935.                           else if(b3==1)
     
936.                            {
     
937.                                      b1=0;
     
938.                                   b2=0;
     
939.                                   b3=1;
     
940.                                   b4=0;
     
941.                            }
     
942.                           else if(b4==1)
     
943.                            {
     
944.                                      b1=0;
     
945.                                   b2=0;
     
946.                                   b3=0;
     
947.                                   b4=1;
     
948.                            }   
     
949.                             }
     
950.                         }       
     
951.        
     
952. }       
     
953. 
     
954. /*******************************************
     
955. ********************************************
     
956. *************小车部分***********************
     
957. ********************************************
     
958. ********************************************/
     
959. 
     
960. /********外部中断定义*************/
     
961. void ini()
     
962. {
     
963.    //EA=1;          //全局中断开
     
964.    EX0=0;         //外部中断0开
     
965.    IT0=1;         //边缘触发
     
966.    //EX1=0;         //外部中断1开
     
967.    //IT1=1;         //电平触发
     
968. }
     
969. 
     
970. 
     
971. /*****外部中断0函数*****/
     
972. void ini_t0() interrupt 0
     
973. {
     
974.         bianma1--;
     
975. }
     
976. 
     
977. /********pwm中断调速定义*************/
     
978. void pwm()
     
979. {  
     
980.    TMOD=0x01; /* 设定T0的工作模式为2 */  
     
981.    TH0=(65536-100)/256; /* 装入定时器的初值 晶振20MHZ 每100us中断一次10次（即1MS）为1个PWM周期*/  
     
982.    TL0=(65536-100)%256;  
     
983.    EA=1; /* 开总中断 */  
     
984.    ET0=1; /* 定时器0允许中断 */  
     
985.    TR0=1; /* 启动定时器0 */  
     
986.    PT0=1;//高优先级
     
987. }
     
988. 
     
989. 
     
990. /*****定时中断函数2*****/
     
991. void timer0() interrupt 1 /* T0中断服务程序 */  
     
992. {  
     
993.        i++;
     
994.        j++;
     
995.        if(i<=m1) en1=1;
     
996.           else en1=0;
     
997.        if(j<=m2) en2=1;
     
998.           else en2=0;
     
999.            if(i==100)  {i=0;}
     
1000.        if(j==100)  {j=0;}
      
1001.        TH0=(65536-100)/256;
      
1002.        TL0=(65536-100)%256;
      
1003. }  
      
1004. 
      
1005. //岔路口 转向记录
      
1006. void crossing(uchar save)
      
1007. {
      
1008.     if(save=='A'){strcat(road,"A");}
      
1009.     if(save=='B'){strcat(road,"B");}
      
1010.     if(save=='R'){strcat(road,"R");}
      
1011.     if(save=='L'){strcat(road,"L");}
      
1012.         if(save=='D'){strcat(road,"D");}
      
1013.     if(save=='0'){strcat(road,"\0");}
      
1014. }                
      
1015. 
      
1016. //记忆路径播音
      
1017. void boyin(uchar save)
      
1018. {
      
1019.     if(save=='A'){stop();ISD1420p(3,1200);}
      
1020.     if(save=='B'){stop();ISD1420p(2,1200);}
      
1021.     if(save=='R'){stop();ISD1420p(1,1200);}
      
1022.     if(save=='L'){stop();ISD1420p(0,1200);}
      
1023.         if(save=='D'){stop();while(!markkey)  {logokey=0;DelayMs(3000) ;logokey=1;guo=0;}ISD1420p(2,1200);}
      
1024. }
      
1025. 
      
1026. /*// 存入24c02
      
1027. void cunru24c02()
      
1028. {
      
1029.    uchar sum=0;
      
1030.    while(*p)
      
1031.     {
      
1032.            if(*p=='A')  cun24c02[sum]=0x01;
      
1033.        if(*p=='B')  cun24c02[sum]=0x02;
      
1034.        if(*p=='R')        cun24c02[sum]=0x03;
      
1035.        if(*p=='L')        cun24c02[sum]=0x04;
      
1036.            p++;
      
1037.            sum++;
      
1038.         }
      
1039.         cun24c02[sum]=0;
      
1040.         EA=0;//关掉中断       
      
1041.         ISendStr(0xae,80,cun24c02,15);            //写入24c02
      
1042.     DelayMs(10);                          //写入后必须延时等待24c02内部
      
1043.         EA=1;//开启中断
      
1044. }
      
1045. 
      
1046. // 取出24c02
      
1047. void quchu24c02()
      
1048. {
      
1049.    uchar sum=0;
      
1050.    while(cun24c02[sum])
      
1051.     {
      
1052.            if(cun24c02[sum]==0x01)  strcat(p,"A");
      
1053.        if(cun24c02[sum]==0x02)  strcat(p,"B");
      
1054.        if(cun24c02[sum]==0x03)        strcat(p,"R");
      
1055.        if(cun24c02[sum]==0x04)        strcat(p,"L");
      
1056.            sum++;
      
1057.         }
      
1058.     strcat(p,"\0");
      
1059.         EA=0;//关掉中断       
      
1060.         IRcvStr(0xae,80,p,15);             //从24c02读出数据
      
1061.         EA=1;//开启中断
      
1062. }        */
      
1063. 
      
1064. 
      
1065. /******************************************************
      
1066. *******************************************************
      
1067. ************ISD1420p语音播报***************************
      
1068. *******************************************************
      
1069. *******************************************************/
      
1070. sbit playe=P3^0;
      
1071. uchar code temp[8]={0x00,0x10,0x20,0x30,0x40,0x50,0x70,0x90};
      
1072. /* 0x00//左转                     延时400Ms
      
1073.     0x10//右转                             延时400Ms
      
1074.     0x20//掉头                       延时400Ms
      
1075.         0x30//直走                       延时400Ms
      
1076.     0x40//到达终点                    延时800Ms  
      
1077.     0x50//最优路径计算完毕  延时1600Ms
      
1078.     0x70//最优路径行驶             延时1600Ms
      
1079.         0x90//智能迷宫小车            延时1600Ms         */
      
1080. void ISD1420p(uchar t1,uint t2)
      
1081. {                                                                                                                   
      
1082.                 playe=1;
      
1083.         write595(temp[t1]);
      
1084.         playe=0;
      
1085.         DelayMs(t2);
      
1086.             DelayMs(t2);  
      
1087.         playe=1;  
      
1088.         /*        P1=0;
      
1089.         playe=1;
      
1090.         P1=temp[t1];
      
1091.         playe=0;
      
1092.         DelayMs(t2);
      
1093.             DelayMs(t2);
      
1094.         P1=0;
      
1095.         playe=1;   */
      
1096. }
      
1097. 
      
1098.    
      
1099. /********************************************
      
1100. *********************************************
      
1101. *****************最优路线计算****************
      
1102. *********************************************
      
1103. *********************************************/
      
1104. int pq(char s1[],char s2[],char ee)
      
1105. {
      
1106.     int opo=0;
      
1107.     int w=0;
      
1108.     int i;
      
1109.     int k;
      
1110.     int j;
      
1111.     for(i=0;s1[i];i++)
      
1112.     {
      
1113.       j=i;
      
1114.       for(k=0;s2[k];k++)
      
1115.         if(s1[j]&&s1[j]==s2[k])j++;
      
1116.            else break;
      
1117.       if(!s2[k])
      
1118.       {   
      
1119.         opo=i;
      
1120.          w++;
      
1121.         if(ee==1)break;
      
1122.       }
      
1123. }
      
1124. if(w==1)return opo;
      
1125. else return -1;
      
1126. }
      
1127. char* str_text(){
      
1128. 
      
1129. int j,i,k,f=1,f2=1;//i用于计数  f内层标记 f2外层标记     
      
1130. do{
      
1131. for(i=0;i<9;i++,f=1)
      
1132. {
      
1133.   do
      
1134.   {
      
1135.    j=pq(road,aa[i],1);  //选出匹配字符串下标
      
1136.        if(j==-1)break;
      
1137.     else  
      
1138.     {   road[j]=a[i][0];
      
1139.      while(road[j+3]){road[j+1]=road[j+3];j++;}
      
1140.      road[j+1]='\0';
      
1141.     }  
      
1142.   }while(1);//判断本次匹配替换是否结束，如果否 继续匹配并替换
      
1143. 
      
1144. }  //for循环结束
      
1145. 
      
1146. //*******校验
      
1147. for(k=0;k<9;k++)
      
1148. {
      
1149.   j=pq(road,aa[k],1);
      
1150.   if(j!=-1)
      
1151.   {
      
1152.    f2=1;break;  //判断是否仍然有匹配项目，如果有重新执行内层do~while语句
      
1153.         }else{f2=0;}
      
1154. }//校验for结束
      
1155. 
      
1156. }while(f2==1); //外层do while 用于校验
      
1157. 
      
1158. return road;  //road首地址
      
1159.      //printf("%s\n",turn2);scanf("%s",c);
      
1160. }
      
1161. 
      
1162. /******************************************************
      
1163. *******************************************************
      
1164. *************小车路径处理******************************
      
1165. *******************************************************
      
1166. *******************************************************/
      
1167. 
      
1168. /******************路口误差排除函数********************/
      
1169. uchar you=0;
      
1170. 
      
1171. 
      
1172. ………完整代码请下载附件………
      
1173. 
      

复制代码

---

作者: 腾飞的龙    时间: 2017-11-4 13:59
谢谢楼主的分享！学习啦。电路图是用什么软件打开？

---

作者: yuguoyu123456    时间: 2018-4-15 15:26
有最短路径吗

---

作者: 请问同样    时间: 2018-5-20 18:27
一千多行代码，大哥，太六了

---

作者: mslong    时间: 2018-5-20 18:58

一千多行代码，大哥，太六了

---

作者: 862263539    时间: 2018-5-30 18:51
谢谢分享

---

作者: 2089235932    时间: 2018-12-1 17:27
谢谢楼主的分享！学习啦。谢谢！

---

作者: biohazard123    时间: 2019-6-25 21:02

腾飞的龙 发表于 2017-11-4 13:59
谢谢楼主的分享！学习啦。电路图是用什么软件打开？

你是水军吧

---

作者: 13631784213    时间: 2019-11-4 18:43
ad打开不能编辑

---

作者: 呀11    时间: 2019-11-18 22:59
太厉害了

---

作者: youngee    时间: 2019-12-9 11:46

请问同样 发表于 2018-5-20 18:27
一千多行代码，大哥，太六了

他这个有没有遍历和迷宫的算法

---

作者: dingangkeji    时间: 2019-12-9 15:34
这也太专业了些。。。。。。

---

作者: XIE780102636    时间: 2020-1-8 09:56
一千多行代码，大哥，太六了

---

作者: 李春雨    时间: 2020-2-7 21:45

谢谢楼主的分享！学习啦

---

作者: yu霈    时间: 2020-2-17 02:18
谢谢分享

---

作者: hgfyfuy    时间: 2020-12-3 18:08
除了厉害还是厉害

---

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

Powered by Discuz! X3.1