设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 智能小车/机器人 › 基于8051单片机的循迹小车 带测速程序
返回列表 发新帖
查看: 4510|回复: 1
打印 上一主题 下一主题
收起左侧

基于8051单片机的循迹小车 带测速程序

[复制链接]
跳转到指定楼层
楼主
ID:186600 发表于 2017-7-2 22:50 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
基于8051单片机的循迹小车


单片机源程序如下:
  1. /*
  2.   ！！！！！！！！！
  3.   1.
  4.   使用PWM波写驱动程序时，切记PWM波的周期不要太短
  5. （20ms左右应该是可以的！！此程序就是因为pwm波周期太短，烧坏4个驱动，8个电机，多么痛的领悟~~）
  6.   2.
  7.   因为当时考虑用到超声速壁障，蜂鸣器，红外测速，液晶等多个外设，需要使用多个中断，单个单片机资源不足，
  8.   所以此写了两个程序分别写入两个单片机，如果只是使用测速，液晶的话应该可以用中断嵌套的方法写入一个单片机即可。
  9.   ！！！！！！！！！

  11. */
  12. #include <reg52.h>
  13. #define uchar unsigned char
  14. #define uint unsigned int
  15. uchar b=0xf;
  16. static uint delay=0;//定义接收红外数据变量
  17. static uchar m=0;
  18. //static uint time=1;
  19. uchar signal;
  20. uchar i=0;
  21. uchar persent_l=100;                       
  22. uchar persent_hl=100;
  23. uchar persent_r=100;
  24. uchar persent_hr=100;
  25. sbit left=P1^3;                                          //定义前方左侧1红外探头
  26. sbit Left_zhong=P1^2;                                    //定义前主左侧2红外探头
  27. sbit right=P1^0;                                         //定义右方1红外探头
  28. sbit right_zhong=P1^1;                                   //定义右方2红外探头
  29. sbit pwm_l=P1^1;                                         //定义电机l正向端口
  30. sbit pwm_hl=P1^2;                                        //定义电机l反向端口
  31. sbit pwm_r=P1^4;                                         //定义电机r正向端口
  32. sbit pwm_hr=P1^5;                                        //定义电机r反向端口
  33. sbit ENA=P1^3;
  34. sbit ENB=P1^0;

  36. void delay1(uchar z)
  37. {
  38.         uchar i,j;
  39.         for(i=0;i<=100;i++)
  40.                 for(j=0;j<=z;j++);

  42. }

  44. /*uchar signal()
  45. {
  46.         uchar temp=0x0f;
  47.         temp&=P0;
  48.         return temp;
  49. }*/


  52. void time0_init()
  53. {
  54.         EA=1;
  55.         TH0=(65536-200)/256;
  56.         TL0=(65536-200)%256;
  57.   TMOD=1;
  58.         ET0=1;
  59.         TR0=1;
  60. }

  62. void time0() interrupt 1    //3 为定时器1的中断号  1 定时器0的中断号 0 外部中断1 2 外部中断2  4 串口中断
  63. {
  64. static uchar time=1;
  65.         EA=0;                                                         
  66.         TH0=(65536-200)/256;                                             
  67.         TL0=(65536-200)%256;        //0.2ms
  68.     if(time<10)
  69.         {
  70.             if(time<persent_l)
  71.                 {pwm_l=1;pwm_hl=0;}
  72.             else pwm_l=0;      
  73.                 if(time<persent_r)
  74.                 {pwm_r=1;pwm_hr=1;}
  75.                 else pwm_r=0;
  76.                 if(time<persent_hl)
  77.             {pwm_hl=1;pwm_l=0;}
  78.                 else pwm_hl=0;
  79.                 if(time<persent_hr)
  80.                 {pwm_hr=1;pwm_r=0;}
  81.                 else pwm_hr=0;
  82.                 time++;
  83.         }
  84.         else
  85.         {m++;time=1;if(m==5){delay++;m=0;}}                  //每2ms m加1 每0.01s delay++;
  86.         EA=1;
  87. }

  89. void forward(uchar a)
  90. {
  91.         /*pwm_l=0;
  92.         pwm_r=0;
  93.         pwm_hl=0;
  94.         pwm_hr=0;*/
  95.         persent_l=11;
  96.         persent_r=11;
  97.         persent_hl=0;
  98.         persent_hr=0;       
  99.         while(delay<=a);       
  100.         delay=0;
  101. }

  103. void dun_l(uchar a)
  104. {
  105.         /*pwm_l=1;
  106.         pwm_r=1;
  107.         pwm_hl=0;
  108.         pwm_hr=0;*/
  109.         persent_l=0;
  110.         persent_r=9;       
  111.         persent_hl=0;
  112.         persent_hr=0;
  113.         while(delay<=a);
  114.         delay=0;
  115. }


  118. void dun_r(uchar a)
  119. {
  120. /*        pwm_l=1;
  121.         pwm_r=1;
  122.         pwm_hl=0;
  123.         pwm_hr=0;
  124. */        persent_l=9;
  125.         persent_r=0;       
  126.         persent_hl=0;
  127.         persent_hr=0;
  128.         while(delay<=a);
  129.         delay=0;
  130. }

  132. void zhi_l(uchar a)
  133. {
  134. /*        pwm_l=1;
  135.         pwm_r=1;
  136.         pwm_hl=0;
  137.         pwm_hr=0;
  138. */        persent_l=0;
  139.         persent_hl=4;
  140.         persent_r=8;
  141.         persent_hl=0;
  142.         while(delay<=a);
  143.         delay=0;
  144. }


  147. void zhi_r(uchar a)
  148. {
  149. /*        pwm_l=1;
  150.         pwm_r=1;
  151.         pwm_hl=0;
  152.         pwm_hr=0;
  153. */        persent_l=8;
  154.         persent_hl=0;
  155.     persent_r=0;
  156.         persent_hr=4;
  157.         while(delay<=a);
  158.         delay=0;
  159. }

  161. void rui_l(uchar a)
  162. {
  163.         /*pwm_l=0;
  164.         pwm_r=1;
  165.         pwm_hl=1;
  166.         pwm_hr=0;*/
  167.         persent_l=0;
  168.         persent_hl=0;
  169.         persent_r=8;
  170.         persent_hr=0;
  171.         while(delay<=a);
  172.         delay=0;
  173. }

  175. void rui_r(uchar a)
  176. {
  177. /*        pwm_l=1;
  178.         pwm_r=0;
  179.         pwm_hl=0;
  180.         pwm_hr=1;
  181. */        persent_l=8;
  182.         persent_hl=0;
  183.     persent_r=0;
  184.         persent_hr=3;
  185.         while(delay<=a);
  186.         delay=0;
  187. }

  189. void back(uchar a)
  190. {
  191. /*        pwm_l=0;
  192.         pwm_r=0;
  193.         pwm_hl=1;
  194.         pwm_hr=1;
  195. */        persent_l=0;
  196.         persent_r=0;
  197.         persent_hl=7;
  198.         persent_hr=7;       
  199.         while(delay<=a);
  200.         delay=0;
  201. }

  203.                                     
  204. //全白0000 0x0 全黑1111 0xf                  
  205. //左钝角 0100 0x4 左直角 1100 0xc 左锐角1000 0x8
  206. //右钝角 0010 0x2 右直角 0011 0x3 右锐角0001 0x1
  207. //100是1s
  208. void track()
  209. {  
  210. //        delay1(10);
  211. //        if(i==0)
  212.         signal=0xf;
  213.         signal&=(P2>>4);
  214. //        else signal=b;
  215.         switch(signal)
  216.     {
  217.         case 0x0: {forward(10);break;}
  218.         case 0xf: {forward(10);break;}
  219. ……………………

  221. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
循迹小车.zip (100.77 KB, 下载次数: 38)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:1 发表于 2017-7-3 02:57 | 只看该作者
测速程序：

  2. #include<reg52.h>

  4. //液晶及测速
  5. #define uint unsigned int
  6. #define uchar unsigned char
  7. #define zhouchang 20       //20cm               
  8. unsigned int i=0;                                                               
  9. sbit P36=P3^6;  
  10. sbit beep=P2^0;                                                                  
  11. unsigned char j;                                                                  
  12. unsigned int kop;                                                                 
  13. uchar code table[]="2013 (^_^) 4-17 ";
  14. uchar table1[]="   -I-          ";
  15. uchar table2[3];

  17. uchar code haode[16]=" WE  ^_^  THE   ";
  18. uchar code haode1[16]=" CHAM  ARE  PION";


  21. uchar code hao[16]= "  p_q    ^_^    ";
  22. uchar code hao1[16]="  -I- -- -I-    ";
  23. uchar flag=1;
  24. uchar time1=0;
  25. //液晶端口
  26. sbit rs = P3^1;//Pin4
  27. //sbit rw= P3^5; //Pin5
  28. sbit lcden  = P3^0;//Pin6
  29. uchar time=1;
  30. sbit dula=P2^6; //锁存器控制端定义
  31. sbit wela=P2^7;
  32. uchar num;

  34. void delay(uint z)
  35. {
  36.         uint x,y;
  37.         for(x=z;x>0;x--)
  38.                 for(y=110;y>0;y--);
  39. }

  41. void write_com(uchar com)
  42. {
  43. //        rw=0;
  44.         rs=0;
  45.         P1=com;
  46.         delay(5);
  47.         lcden=1;
  48.         delay(5);
  49.         lcden=0;
  50. }

  52. void write_data(uchar date)
  53. {
  54. //        rw=0;
  55.         rs=1;
  56.         P1=date;
  57.         delay(5);
  58.         lcden=1;
  59.         delay(5);
  60.         lcden=0;
  61. }


  64. void write_sfm(uchar add,uchar date)
  65. {
  66.         write_com(0x80+0x40+add);
  67.         write_data(0x30+date);
  68. }

  70. void init()
  71. {
  72.         dula=0;
  73.         wela=0;
  74.         lcden=0;
  75.         /*write_com(0x38);
  76.         write_com(0x0e);
  77.         write_com(0x06);
  78.         write_com(0x01);
  79.         write_com(0x80+0x10);
  80.         */
  81.         write_com(0x38);
  82.         write_com(0x0c);
  83.         write_com(0x06);
  84.         write_com(0x01);
  85.         write_com(0x80);
  86. }


  89. void zhongduan_init()                                             
  90. {
  91.         EA = 1;                                 
  92.     TH0=0x00;                                                                                                               
  93.         TL0=0x00;                                                                                                               
  94.         ET0=1;
  95.         ET1=1;               
  96.           TMOD = 0x15;// 打开定时器和计数器T0，因此矩形脉冲输入端接P3.4
  97.         TH1=0x3C; //50ms
  98.         TL1=0xB0;               
  99.     TR0 = 1;
  100.         TR1 = 1;
  101. }


  104. void main()
  105. {
  106.         P2=0xff;
  107.         init();
  108. //        flag=0;
  109.         zhongduan_init();                                      
  110.         while(1)
  111.         {
  112.         if(flag==0)
  113.         {
  114.                 EA=0;               //关闭中断
  115.                 write_com(0x80);
  116.                 for(num=0;num<15;num++)
  117.                 {
  118.                 write_data(table[num]);
  119.                 delay(20);
  120.                 }                       
  121. //速度       
  122.                 write_sfm(1,table1[0]);
  123.             write_sfm(2,table1[1]);
  124.             write_sfm(3,table1[2]);
  125. //时间               
  126.             write_sfm(10,table2[0]);
  127.                 write_sfm(11,table2[1]);
  128.                 write_sfm(12,table2[2]);
  129.                
  130. //            write_sfm(8,0x73);
  131.                 flag=1;
  132.                 EA=1;     
  133. //                while(1);          //开启中断
  134.         }
  135.         }
  136. }
  137.                                                                                                                                                                                
  138.                                                                      
  139. timer3() interrupt 3  //定时器中断时间到,就读取计数器值                        //3 为定时器1的中断号  1 定时器0的中断号 0 外部中断1 2 外部中断2  4 串口中断                                           
  140. {
  141. TH1=0X3C;                                                                                                                                       
  142. TL1=0XB0;                                                                                                                                                            
  143. i++;                                                                                                                                                                                                                    
  144. if(i==20) //1s才进行技术脉冲值显示，即每秒更新一次速度    这里一会儿要给！！！！！！！！！1                       
  145. {
  146.    time++;                     //记时间
  147.    time1++;
  148.    kop=TH0;//计数器计入脉冲，每来一个矩形脉冲计数值加1
  149.    kop=kop<<8;
  150.    kop=kop+TL0;                                                //kp单位是cm，周长20cm，20个空隙，一个空隙1cm                                       
  151.    beep=1;
  152.    if(kop>45)
  153.    {
  154.         beep=0;
  155.    }
  156.    table1[0]=kop/100;       //显示计数器的值即实际测得速度
  157.    table1[1]=kop%100/10;
  158.    table1[2]=kop%100%10;
  159.    table2[0]=time/100;       //显示计数器的值即实际测得速度
  160.    table2[1]=time%100/10;
  161.    table2[2]=time%100%10;
  162.    i=0;
  163.    TH0=0;//计数器速度获取后清零，进行下次获取
  164.    TL0=0;
  165.    flag=0;
  166.    if(time1==20)
  167.    {
  168.           
  169.         write_com(01);
  170.                    write_com(0x80);
  171.                    for(num=0;num<15;num++)
  172.                 {
  173.                 write_data(haode[num]);
  174.                 delay(20);
  175.                 }        
  176.                
  177.                 write_com(0x80+0x53);
  178.                 for(num=0;num<15;num++)
  179.                 {
  180.                 write_data(haode1[num]);
  181.                 delay(20);
  182.                 }
  183.     delay(300);
  184.    }
  185.    if(time1==10)
  186.            {
  187.           
  188.         write_com(01);
  189.                    write_com(0x80);
  190.                    for(num=0;num<15;num++)
  191.                 {
  192.                 write_data(hao[num]);
  193.                 delay(20);
  194.                 }        
  195.                
  196.                 write_com(0x80+0x53);
  197.                 for(num=0;num<15;num++)
  198.                 {
  199.                 write_data(hao1[num]);
  200.                 delay(20);
  201.                 }
  202.     delay(400);
  203.    }
  204. }
  205. }
  206.           
复制代码
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表