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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 智能小车/机器人 › 单片机智能小车 功能 循迹,红外遥控,超声波避障,舵机,PW ...
返回列表 发新帖
查看: 11607|回复: 15
打印 上一主题 下一主题
收起左侧

单片机智能小车 功能 循迹,红外遥控,超声波避障,舵机,PWM,跟踪

  [复制链接]
跳转到指定楼层
楼主
ID:140725 发表于 2017-3-6 03:07 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式


下载：
智能小车资料.zip (89.07 KB, 下载次数: 231)

一些问题：

问：
   大神请教个问题，我用keil给51单片机写的程序能运行在其中设备上吗？因为我是有一个打算就是用我的单片机作试验，再把程序写到自己设计的电路中去，我需要用到什么芯片才能执行这个程序

答：
我就是用的KEIL+51单片机，你可以在自己的开发板上做实验，只要单品机是一样的就完全可以，即使不完全一样，也仅仅需要改改IO口等

是用的两个红外，两个红外之间距离远点，另外我这个直走和转弯是两个不同的PWM速度，转弯大概是直走的2倍左右，效果好点.
下面是智能小车外形图：


小车是用的慧静4WD小车，程序是自己写的.





遥控子程序：
  1. #include <reg52.h>
  2. #include "SmartCar.h"
  3. //#include "Dianji.h"
  4. #include "RTX51TNY.H"


  7. #define Imax 14000    //此处为晶振为11.0592时的取值,
  8. #define Imin 8000    //如用其它频率的晶振时,
  9. #define Inum1 1450    //要改变相应的取值。
  10. #define Inum2 700
  11. #define Inum3 3000

  13. unsigned char f=0;                                                        //找到起始码时置1
  14. unsigned char Im[4]={0x00,0x00,0x00,0x00};  //分别存储，客户码1，客户码2，操作码，操作码反码
  15. unsigned int  Tc = 0;                                                //Tc时间间隔
  16. unsigned char m = 0;                                                //m往Im存数时计数用
  17. unsigned char IrOK = 0;                                                //提取成功后置1

  19. unsigned char ImOld=0;                                                //储存旧命令，用于加减速控制

  21. //unsigned char const discode[] ={ 0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xBF,0xff/*-*/};
  22. //unsigned char const positon[3]={ 0xfe,0xfd,0xfb};
  23. //sbit FM  = P2^6;                                                        //test

  25. /************************************************************************/        
  26. //遥控
  27. void YaoKong (void)
  28. {
  29.         if(IrOK==1)
  30.         {
  31. //                                FM=0;
  32.                 switch(Im[2])
  33.                 {
  34.                         case 0x18:                                        //前进
  35.                         {
  36.                                 ucFlagControl=FLAG_GO;                        
  37.                         }                             
  38.                              break;
  39.                     case 0x52:                                  //后退
  40.                         {
  41.                                 ucFlagControl=FLAG_BACK;                        
  42.                         }                                    
  43.                             break;
  44.                     case 0x1C:                                  //停止
  45.                         {
  46.                                 ucFlagControl=FLAG_STOP;                        
  47.                         }                                    
  48.                             break;                                       
  49.                         case 0x08:                                        //左转
  50.                         {
  51.                                 ucFlagControl=FLAG_TURNLEFT;                        
  52.                         }
  53.                                 break;
  54.                         case 0x5A:                                    //右转
  55.                         {
  56.                                 ucFlagControl=FLAG_TURNRIGHT;                        
  57.                         }
  58.                                 break;
  59.                         case 0x15:                                    //加速
  60.                         {
  61.                                 if(++ucPwm>10)
  62.                                 {
  63.                                         ucPwm=10;
  64.                                 }                        
  65.                         }
  66.                                 break;
  67.                         case 0x07:                                    //减速
  68.                         {
  69.                                 if(--ucPwm==0)
  70.                                 {
  71.                                         ucPwm=1;                        //Pwm至少为1
  72.                                 }                        
  73.                         }
  74.                                 break;
  75.                         case 0x0C:                                    //遥控模式
  76.                         {
  77.                             ucFlagState = FLAG_YAOKONG;
  78.                         }
  79.                                 break;
  80.                         case 0x5E:                                    //循迹模式
  81.                         {
  82.                             ucFlagState = FLAG_XUNJI;
  83.                         }
  84.                                 break;
  85.                         case 0x42:                                    //跟随模式
  86.                         {
  87.                             ucFlagState = FLAG_GENSUI;
  88.                         }
  89.                                 break;
  90.                         case 0x4A:                                    //避障模式
  91.                         {
  92.                             ucFlagState = FLAG_BIZHANG;
  93.                                 ucFlagChangeState=YES;
  94.                         }
  95.                                 break;
  96.                         default:
  97.                                 break;
  98.                 }
  99.                 IrOK=0;                                                        //将成功标记位置位
  100.         }
  101. }


  104. //外部中断解码程序
  105. void intersvr1() interrupt 2
  106. {
  107.         Tc=TH1*256+TL1;     //提取中断时间间隔时长，两次下降沿之间的时间间隔
  108.     TH1=0;
  109.     TL1=0;              //定时中断重新置零

  111.         if((Tc>Imin)&&(Tc<Imax))
  112.     {
  113.                   m=0;
  114.             f=1;
  115.             return;
  116.     }
  117.     if(f==1)          //找到启始码
  118.     {
  119.                 if(Tc>Inum1&&Tc<Inum3)                                         
  120.                    {
  121.                     Im[m/8]=Im[m/8]>>1|0x80; m++;
  122.             }
  123.               if(Tc>Inum2&&Tc<Inum1)
  124.         {
  125.                 Im[m/8]=Im[m/8]>>1; m++; //取码
  126.                 }
  127.                   if(m==32)
  128.                    {
  129.                     m=0;  
  130.                 f=0;
  131.                 if(Im[2]==~Im[3])
  132.                 {
  133.                         IrOK=1;
  134.                            }
  135.                 else IrOK=0;   //取码完成后判断读码是否正确
  136.             }
  137.     }
  138. }
  139.                
复制代码

电机子程序：
  1. #include <reg52.h>
  2. #include <INTRINS.H>
  3. #include "SmartCar.h"
  4. #include "Yaokong.h"

  6. sbit IN1 = P1^0;           //  左1电机           高电平前进
  7. sbit IN2 = P1^1;           //  左1电机     高电平后退        可以改接成PWM输出
  8. sbit IN3 = P1^2;           //  左2电机     高电平前进
  9. sbit IN4 = P1^3;           //  左2电机     高电平后退        可以改接成PWM输出
  10. sbit IN5 = P1^4;           //  右1电机     高电平前进
  11. sbit IN6 = P1^5;           //  右1电机     高电平后退        可以改接成PWM输出
  12. sbit IN7 = P1^6;           //  右2电机     高电平前进
  13. sbit IN8 = P1^7;           //  右2电机     高电平后退        可以改接成PWM输出

  15. unsigned char ucFlagDirection = 0;                                            //方向，0为前进，1为后退

  17. //sbit FM  = P2^6;

  19. void PwmLeft (void);
  20. void PwmRight (void);

  22. //前进函数
  23. void Go(void)
  24. {
  25.         ucFlagDirection = 0;

  27.         IN2=0;                 //左1电机  
  28.         IN4=0;                 //左2电机

  30.         IN6=0;                 //右1电机  
  31.         IN8=0;                 //右2电机
  32.         
  33.         PwmLeft();         
  34.         PwmRight();
  35.         
  36. }

  38. //后退函数
  39. void Back(void)
  40. {

  42.         ucFlagDirection = 1;

  44.         IN1=0;                 //左1电机         
  45.         IN3=0;                 //左2电机  

  47.         IN5=0;                 //右1电机  
  48.         IN7=0;                 //右2电机   

  50.         PwmLeft();         
  51.         PwmRight();
  52. }

  54. //小车左转函数                                
  55. void TurnLeft(void)
  56. {
  57.         ucFlagDirection = 0;
  58.         IN6=0;                 //右1电机  
  59.         IN8=0;                 //右2电机
  60.         
  61.         IN2=0;                 //左1电机
  62.         IN4=0;           //左2电机
  63.         IN1=0;
  64.         IN3=0;
  65.          
  66.         //右侧继续前进
  67.         PwmRight();
  68. }

  70. //小车右转函数                        
  71. void TurnRight(void)
  72. {
  73.         ucFlagDirection = 0;
  74.         IN2=0;                 //左1电机  
  75.         IN4=0;                 //左2电机

  77.         IN6=0;                 //右1电机  
  78.         IN8=0;                 //右2电机
  79.         IN5=0;
  80.         IN7=0;
  81.          
  82.         //左侧继续前进
  83.         PwmLeft();         
  84. }

  86. //电机停止转动函数            
  87. void Stop(void)
  88. {
  89.         P1 = 0x00;
  90. }

  92. //PwmLeft
  93. void PwmLeft (void)
  94. {  
  95.         if(ucPwmCountDianJ  <= ucPwm)
  96.         {
  97.             if(ucFlagDirection == 0)                                //前进时
  98.                 {
  99.                         IN1 = 1;
  100.                         IN3 = 1;
  101.                 }
  102.                 else if(ucFlagDirection == 1)                //后退时
  103.                 {
  104.                         IN2 = 1;
  105.                         IN4 = 1;
  106.                 }
  107.         }
  108.         else
  109.     {
  110.             if(ucFlagDirection == 0)                                //前进时
  111.                 {
  112.                         IN1 = 0;
  113.                         IN3 = 0;
  114.                 }
  115.                 else if(ucFlagDirection == 1)                //后退时
  116.                 {
  117.                         IN2 = 0;
  118.                         IN4 = 0;
  119.                 }
  120.     }
  121. //        if(ucPwmCountDianJ  >= 10)
  122. //        {
  123. //                TR0=0;
  124. //                ucPwmCountDianJ  = 0;
  125. //                TR0=1;
  126. //        }
  127. }

  129. //PwmRight
  130. void PwmRight (void)
  131. {  
  132.         if(ucPwmCountDianJ  <= ucPwm)
  133.         {
  134.             if(ucFlagDirection == 0)                                //前进时
  135.                 {
  136.                         IN5 = 1;
  137.                         IN7 = 1;
  138.                 }
  139.                 else if(ucFlagDirection == 1)                //后退时
  140.                 {
  141.                         IN6 = 1;
  142.                         IN8 = 1;
  143.                 }
  144.         }
  145.         else
  146.     {
  147.             if(ucFlagDirection == 0)                                //前进时
  148.                 {
  149.                         IN5 = 0;
  150.                         IN7 = 0;
  151.                 }
  152.                 else if(ucFlagDirection == 1)                //后退时
  153.                 {
  154.                         IN6 = 0;
  155.                         IN8 = 0;
  156.                 }
  157.     }
  158. //        if(ucPwmCountDianJ  >= 10)
  159. //        {
  160. //                TR0=0;
  161. //                ucPwmCountDianJ  = 0;
  162. //                TR0=1;
  163. //        }
  164. }
复制代码
主程序：
  1. /*******************************************************
  2. * 项目名称：循迹避障小车
  3. * 单 片 机：STC89C52RC
  4. * 功    能：循迹，红外遥控，超声波避障，舵机，PWM，跟踪
  5. * 作    者：刘琦
  6. * IO口定义：红外循迹                                P3^4，P3^5
  7. *                        红外避障                                P3^6，P3^7
  8. *                        电机                                          P1^0~P1^7               
  9. *                        超声波避障                                P2^4~P2^5
  10. *                        红外遥控                                P3^3
  11. *                        舵机                                        P2^3               
  12. *                        数码管段选                                P0
  13. *                        数码管位选                                P2^0~P2^3
  14. * 遥 控 器：2           前进                         (18)
  15. *                        8           后退                        (52)
  16. *                        5                停止                         (1C)
  17. *                        4           左转                        (08)
  18. *                        6           右转                        (5A)
  19. *                        1                遥控模式                (0C)
  20. *                        3                 循迹模式                (5E)
  21. *                        7                跟随模式                (42)
  22. *                        9                避障模式                (4A)
  23. *                        +                加速                        (15)
  24. *                        -                减速                        (07)
  25. * 定 时 器：T0                PWM（电机、舵机），数码管（超声波测距）
  26. *                         T1                红外遥控计时
  27. *                        T2                超声波计时
  28. *******************************************************/
  29. /******************************头文件区***********************************************/
  30. #include <reg52.h>
  31. #include "Dianji.h"
  32. #include "Yaokong.h"
  33. #include "RTX51TNY.H"
  34. #include "Chaoshengbo.h"
  35. #include "Duoji.h"

  37. /******************************宏定义区***********************************************/
  38. //需要定时刷新的任务数，0YaoKong,1Display,2CSB
  39. #define NUM_TASK_REFRESH 3
  40. //刷新频率
  41. //#define TIME_PER_SEC 200                                                        //每次进入中断的频率，200Hz,5ms
  42. #define TIME_PER_SEC 10000                                                        //每次进入中断的频率，10000Hz，0.1ms
  43. #define TIME_CLOCK 11059200                                                        //晶振频率
  44. #define TIME_YAOKONG_50HZ          TIME_PER_SEC/50                  //响应遥控命令频率，0.02s
  45. #define TIME_SUMA_300HZ                TIME_PER_SEC/300                //超声波距离显示数码管刷新频率，0.003s
  46. #define TIME_CSB_5HZ                TIME_PER_SEC/5                        //超声波自动检测的频率，0.2s

  48. #define FLAG_YAOKONG                0
  49. #define FLAG_XUNJI                        1
  50. #define FLAG_BIZHANG                2
  51. #define FLAG_GENSUI                        3

  53. #define FLAG_GO                                0
  54. #define FLAG_BACK                        1
  55. #define FLAG_STOP                        2
  56. #define FLAG_TURNLEFT                3
  57. #define FLAG_TURNRIGHT                4

  59. #define NO                                        0
  60. #define YES                                        1

  62. #define DELAYTURN                        5000
  63. #define DELAYDUOJI                        5000


  66. /******************************子函数声明区***********************************************/

  68. void initial_myself(void);   
  69. void initial_peripheral(void);
  70. void delay100ms(void);        

  72. /******************************IO口定义区***********************************************/
  73. sbit LEFT_XJ  = P3^4;        //        左循迹
  74. sbit RIGHT_XJ = P3^5;        //        右循迹
  75. sbit LEFT_GS  = P3^6;        //        左跟随
  76. sbit RIGHT_GS = P3^7;        //        右跟随

  78. //sbit LEFT_CS  = P                //        左测速
  79. //sbit RIGHT_CS = P                //        右测速

  81. sbit KEY=P2^6;                        //  激活超声波测距，测试用，蜂鸣器也响;

  83. /******************************全局变量定义区***********************************************/

  85. unsigned char ucPwm  = 4;                                                                //电机的PWM占空比，N/10
  86.                                 
  87. unsigned int ucPwmCountDianJ = 0;                                                //电机Pwm计数
  88. unsigned int ucPwmCountDuoJ = 0;                                                //舵机Pwm计数

  90. unsigned char ucFlagState = FLAG_YAOKONG;                                //模式选择，遥控，循迹，避障
  91. unsigned char ucFlagControl = FLAG_STOP;                                //遥控模式下的控制选择，前进后退停止左转右转


  94. unsigned int uc_delay_task_cnt[NUM_TASK_REFRESH];                //任务刷新延迟

  96. unsigned char ucCSBCheck    = NO;                                                //用于判断是否需要停车检测

  98. unsigned int ucPwmDuoj = 6;                                                                //舵机归中,默认情况下先归中
  99. unsigned int ulS[4]         = {0,0,0,0};                                        //储存距离数据,0°，180°，90°，后退时90°

  101. unsigned char ucDuoJiPosition[3]={11,2,6};                                //舵机的0°，180°，90°对应的ucPwmDuoj数值

  103. unsigned char ucFlagTurning=NO;                                                        //在超声波避障模式中，判断是否正在转弯
  104. unsigned char ucFlagDuoJiPositon=0;                                                //正在检测的舵机位置标示，0代表正在检测0°
  105. unsigned char ucLockCSBCheck=NO;                                                //超声波检测过程中时，此为YES，锁住红外传感器的检测
  106. unsigned int  uiDelayDuoJiMove=DELAYDUOJI;                                //舵机移动延迟结束
  107. unsigned char ucFlagDuoJiMove=NO;                                                //舵机开始移动的标志，此标志为YES时uiDelayDuoJiMove开始减
  108. unsigned char ucFlagCSBBegin=NO;                                                //超声波开始检测标志，当uiDelayDuoJiMove为0时，为YES
  109. unsigned char ucNumS=0;                                                                        //ulS数组的第几位
  110. unsigned char ucNumCSB=0;                                                                //进入超声波检测的次数，用来控制什么时候结束检测，开始转弯
  111. unsigned int  uiDelayTurn=DELAYTURN;                                        //转弯结束，大概90°
  112. unsigned char ucFlagTurn=NO;                                                        //开始转动的标志，此标志为YES时uiDelayTurn开始减
  113. unsigned char ucFlagTurnOver=NO;                                                //转弯结束标志，为YES时，退出转弯
  114. unsigned char ucFlagSMGLock=NO;                                                        //数码管锁，从检测到障碍，到转弯结束，这段时间锁上不显示
  115. unsigned char ucFlagGuiZhong=NO;                                                //头一次进入避障模式先归中
  116. unsigned char ucFlagBegin=NO;                                                        //归中后此位为YES
  117. unsigned char ucFlagChangeState=NO;                                                //改变状态标识，如果改变了，那么初始化避障模式的变量
  118. unsigned char ucFlagBackOK=NO;                                                        //后退OK标识，后退结束后，才开始转弯


  121. //unsigned char ucCSBDirection = 0;                                                //用来记录并判断检测后行进方向
  122. //unsigned char ucCSBFlag     = 0;                                                //用来激活400ms计时
  123. //unsigned char ucFlagJumpoutPwm = 0;                                                //Pwm跳出标示，1为跳出

  125. //unsigned char const discode[] ={ 0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xBF,0xff/*-*/};
  126. //unsigned char const positon[3]={ 0xfe,0xfd,0xfb};


  129. /******************************主函数开始***********************************************/
  130. void main(void)
  131. {
  132.         initial_myself();
  133.         delay100ms();   
  134.     initial_peripheral();


  137.         while(1)
  138.         {
  139.                 if(ucFlagChangeState==YES)                                                //每次改变状态，将避障模式的变量初始化
  140.                 {
  141.                         ucFlagTurning=NO;                                                        //在超声波避障模式中，判断是否正在转弯
  142.                         ucFlagDuoJiPositon=0;                                                //正在检测的舵机位置标示，0代表正在检测0°
  143.                         ucLockCSBCheck=NO;                                                //超声波检测过程中时，此为YES，锁住红外传感器的检测
  144.                         uiDelayDuoJiMove=DELAYDUOJI;                                //舵机移动延迟结束
  145.                         ucFlagDuoJiMove=NO;                                                //舵机开始移动的标志，此标志为YES时uiDelayDuoJiMove开始减
  146.                         ucFlagCSBBegin=NO;                                                //超声波开始检测标志，当uiDelayDuoJiMove为0时，为YES
  147.                         ucNumS=0;                                                                        //ulS数组的第几位
  148.                         ucNumCSB=0;                                                                //进入超声波检测的次数，用来控制什么时候结束检测，开始转弯
  149.                         uiDelayTurn=DELAYTURN;                                        //转弯结束，大概90°
  150.                         ucFlagTurn=NO;                                                        //开始转动的标志，此标志为YES时uiDelayTurn开始减
  151.                         ucFlagTurnOver=NO;                                                //转弯结束标志，为YES时，退出转弯
  152.                         ucFlagSMGLock=NO;                                                        //数码管锁，从检测到障碍，到转弯结束，这段时间锁上不显示
  153.                         ucFlagGuiZhong=NO;                                                //头一次进入避障模式先归中
  154.                         ucFlagBegin=NO;                                                        //归中后此位为YES
  155.                         ucFlagBackOK=NO;                                                //后退OK标识，后退结束后，才开始转弯
  156.                         ucPwm=4;
  157.                         ucFlagChangeState=NO;
  158.                 }
  159.                 if(uc_delay_task_cnt[0]==0)
  160.                 {
  161.                         YaoKong();
  162.                         ET0=0;//在中断中也有可能变化的变量在更改前时先关闭中断
  163.                         uc_delay_task_cnt[0]=TIME_YAOKONG_50HZ;
  164.                         ET0=1;
  165.                 }
  166.                 //遥控模式
  167.                 if(ucFlagState==FLAG_YAOKONG)
  168.                 {
  169.                         switch(ucFlagControl)
  170.                         {
  171.                                 case FLAG_GO:
  172.                                         Go();
  173.                                         break;
  174.                                 case FLAG_STOP:
  175.                                         Stop();
  176.                                         break;
  177.                                 case FLAG_BACK:
  178.                                         Back();
  179.                                         break;
  180.                                 case FLAG_TURNLEFT:
  181.                                         TurnLeft();
  182.                                         break;
  183.                                 case FLAG_TURNRIGHT:
  184.                                         TurnRight();
  185.                                         break;
  186.                                 default:
  187.                                         break;
  188.                         }
  189.                 }
  190.                 //循迹模式
  191.                 if(ucFlagState==FLAG_XUNJI)
  192.                 {
  193.                         if(LEFT_XJ==1&&RIGHT_XJ==1)
  194.                         {
  195.                                 ucPwm=3;
  196.                                 Go();
  197.                         }
  198.                         else if(RIGHT_XJ==0)
  199.                         {
  200.                                 ucPwm=8;
  201.                                 TurnRight();
  202.                         }
  203.                         else if(LEFT_XJ==0)
  204.                         {
  205.                                 ucPwm=8;
  206.                                 TurnLeft();
  207.                         }
  208.                                 
  209.                 }
  210.                 //跟随模式
  211.                 if(ucFlagState==FLAG_GENSUI)
  212.                 {
  213.                         if(LEFT_GS==1&&RIGHT_GS==1)                                                //左右都检测到物体
  214.                         {
  215.                                 Stop();
  216.                         }
  217.                         else if(LEFT_GS==0&&RIGHT_GS==1)                            //左侧未检测到，右侧检测到
  218.                         {
  219.                                 TurnRight();                                                                                                                                   
  220.                         }
  221.                         else if(LEFT_GS==1&&RIGHT_GS==0)                                //右侧未检测到，左侧检测到
  222.                         {
  223.                                 TurnLeft();
  224.                         }
  225.                         else                                                                                        //左右都未检测到
  226.                         {
  227.                                 Go();
  228.                         }        
  229.                 }
  230.                 //超声波+红外避障模式

  232.                 //ucFlagBegin=NO,
  233.                 if(ucFlagState==FLAG_BIZHANG)
  234.                 {
  235.                         if(ucFlagBegin==NO)
  236.                         {
  237.                                 ucPwmDuoj=ucDuoJiPosition[2];
  238.                                 ucFlagGuiZhong=YES;
  239.                         }
  240.                         else
  241.                         {
  242. //                                if(ucFlagSMGLock==NO&&uc_delay_task_cnt[1]==0)                                                //数码管刷新
  243.                                 if(uc_delay_task_cnt[1]==0)                                                //数码管刷新
  244.                                 {
  245.                                         Display();
  246.                                         ET0=0;//在中断中也有可能变化的变量在更改前时先关闭中断
  247.                                         uc_delay_task_cnt[1]=TIME_SUMA_300HZ;
  248.                                         ET0=1;
  249.                                 }
  250.         
  251.                                 if(ucFlagTurning==NO)                                                        //没在转弯
  252.                                 {                                                                                                
  253.                                         if(ucLockCSBCheck==NO&&uc_delay_task_cnt[2]==0)        //超声波自动检测
  254.                                         {
  255.                                                 CSB ();
  256.                                                 ET0=0;//在中断中也有可能变化的变量在更改前时先关闭中断
  257.                                                 uc_delay_task_cnt[2]=TIME_CSB_5HZ;
  258.                                                 ET0=1;
  259.                                                 if(S<=40)
  260.                                                 {
  261.                                                          ucLockCSBCheck=YES;
  262.                                                          ucFlagSMGLock=YES;
  263.                                                          Stop();
  264.                                                 }
  265.                                         }
  266.         
  267.                                         if(ucLockCSBCheck==NO)
  268.                                         {
  269.                                                 Go();
  270.                                         }
  271.                                        
  272.                                         if(ucLockCSBCheck==YES)                                                        //遇到障碍后超声波检测整个过程开始
  273.                                         {
  274.                                                 if(ucFlagCSBBegin==NO)                                                                //超声波检测未开始
  275.                                                 {                                                                                                        
  276.                                                         ucPwmDuoj=ucDuoJiPosition[ucFlagDuoJiPositon];        //正在检测的角度，随着ucFlagDuoJiPositon变化而变化
  277.                                                         ucFlagDuoJiMove=YES;
  278.                                                 }
  279.                                                 if(ucFlagCSBBegin==YES)
  280.                                                 {
  281. //                                                        if(ucFlagDuoJiPositon<2)                                                //只在0°，180°进行超声波检测
  282. //                                                        {
  283.                                                                 CSB ();
  284.                                                                 CSB ();
  285.                                                                 CSB ();
  286.                                                                 ulS[ucNumS]=S;                                                                //将距离数据存起来
  287. //                                                                if(ucNumS<2)
  288.                                                                         ucNumS++;
  289. //                                                        }
  290.                                                         if(++ucFlagDuoJiPositon>2)
  291.                                                                 ucFlagDuoJiPositon=0;
  292.                                                         if(++ucNumCSB>=3)                                                               
  293.                                                         {
  294.                                                                  ucFlagTurning=YES;                                                        //激活转弯
  295.                                                                  ucLockCSBCheck=NO;                                                        
  296.                                                                  ucNumCSB=0;                                                                //进入检测的次数清0
  297.                                                                  ucNumS=0;                                                                        //存储距离数据的位置清0
  298.                                                         }
  299.                                                         ucFlagCSBBegin=NO;                                                                //超声波检测结束
  300.                                                 }
  301.                
  302.                                         }
  303.                                 }
  304.                                 else                                                                                                                //正在转弯
  305.                                 {
  306.                                         if(ucFlagBackOK==NO)
  307.                                         {
  308.                                                 if(        ulS[2]<30)
  309.                                                 {
  310.                                                         Back();
  311.                                                         CSB();
  312.                                                         ulS[3]=S;
  313.                                                         if(ulS[3]>=30)
  314.                                                                 ucFlagBackOK=YES;        
  315.                                                 }
  316.                                                 else
  317.                                                         ucFlagBackOK=YES;
  318.                                         }
  319.                                         else
  320.                                         {
  321.                                                 if(ucFlagTurnOver==NO)                                                                        //未转弯结束
  322.                                                 {
  323.                                                         ucFlagTurn=YES;
  324.                                                         if(ulS[0]>ulS[1])                                                                        //左侧>右侧
  325.                                                                 TurnLeft();
  326.                                                         else
  327.                                                                 TurnRight();
  328.                                                 }
  329.                                                 else
  330.                                                 {
  331.                                                         ucFlagTurning=NO;
  332.                                                         ucFlagTurnOver=NO;
  333.                                                         ucFlagSMGLock=NO;
  334.                                                         ucFlagBackOK=NO;
  335.                                                 }
  336.                                         }        
  337.                                 }
  338.                         }
  339.                 }
  340.         }
  341. }

  343. //中断函数
  344. void timer0(void) interrupt 1
  345. {
  346.         unsigned char i;
  347.         TR0=0;
  348.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
  349.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
  350.         //task_delay[]减到0时，相应的函数准备就绪
  351.         for(i=0;i<NUM_TASK_REFRESH;i++)
  352.         {
  353.                 if(uc_delay_task_cnt[i]!=0)//延迟不为0时才减
  354.                         {uc_delay_task_cnt[i]--;};
  355.         }
  356.         ucPwmCountDianJ++;
  357.         if(ucPwmCountDianJ  >= 10)
  358.         {
  359.                 ucPwmCountDianJ  = 0;
  360.         }
  361.         
  362.         //舵机转动距离控制
  363.         if(ucFlagDuoJiMove==YES||ucFlagGuiZhong==YES)
  364.         {
  365.                 ucPwmCountDuoJ++;
  366.                 if(ucPwmCountDuoJ>205)                                                //0.5+20(ms),整个周期长度
  367.                 {
  368.                         ucPwmCountDuoJ=0;
  369.                 }
  370.                 PwmServomoto();
  371.         }

  373.         //舵机转动时间控制
  374.         if(ucFlagDuoJiMove==YES)
  375.         {
  376.                 if(uiDelayDuoJiMove!=0)
  377.                         uiDelayDuoJiMove--;
  378.                 else
  379.                 {
  380.                         uiDelayDuoJiMove=DELAYDUOJI;
  381.                         ucFlagDuoJiMove=NO;
  382.                         ucFlagCSBBegin=YES;        
  383.                 }        
  384.         }
  385.         //头一次进入避障模式的舵机归中
  386.         if(ucFlagGuiZhong==YES)
  387.         {
  388.                 if(uiDelayDuoJiMove!=0)
  389.                         uiDelayDuoJiMove--;
  390.                 else
  391.                 {
  392.                         uiDelayDuoJiMove=DELAYDUOJI;
  393.                         ucFlagGuiZhong=NO;
  394.                         ucFlagBegin=YES;        
  395.                 }        
  396.         }

  398.         //转弯延迟
  399.         if(ucFlagTurn==YES)
  400.         {
  401.                 if(uiDelayTurn!=0)
  402.                         uiDelayTurn--;
  403.                 else
  404.                 {
  405.                         uiDelayTurn=DELAYTURN;
  406.                         ucFlagTurn=NO;
  407.                         ucFlagTurnOver=YES;
  408.                 }        
  409.         }

  411.         TR0=1;
  412. }

  414. //初始化区
  415. void initial_myself(void)//第一区 初始化单片机
  416. {
  417.         unsigned char i;
  418.         for(i=0;i<NUM_TASK_REFRESH;i++)uc_delay_task_cnt[i]=0;//初始化让所有任务就绪
  419.         TMOD=0X11; //定时器0、1为16位不自动重装
  420.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
  421.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
  422.         TH1=0;
  423.         TL1=0;
  424.         TH2=0;
  425.         TL2=0;
  426.         DUOJI=0;                                                //防止舵机转动，同时不情愿的开启了第四个数码管的显示
  427. }

  429. void initial_peripheral(void) //第二区 初始化外围
  430. {
  431.         EA=1;                     //开总中断
  432.         ET0=1;                    //允许定时器中断

  434.     IT1=1;                          //下降沿触发
  435.     EX1=1;                         //允许外部1中断

  437.     TR0=1;                    //启动定时器0
  438.     TR1=1;                         //启动定时器1
  439. }

  441. void delay100ms(void)                //@11.0592MHz
  442. {
  443.         unsigned char i, j, k;

  445.         ;
  446.         ;
  447.         i = 5;
  448.         j = 52;
  449.         k = 195;
  450.         do
  451.         {
  452.                 do
  453.                 {
  454.                         while (--k);
  455.                 } while (--j);
  456.         } while (--i);
  457. }

复制代码





智能, 程序
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏7 分享淘帖 顶顶1 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:103810 发表于 2017-3-6 12:18 | 只看该作者
效果还是不错的啊
回复

使用道具 举报

板凳
ID:185968 发表于 2017-5-1 22:08 | 只看该作者
厉害了我的哥
回复

使用道具 举报

地板
ID:160485 发表于 2017-5-23 19:56 | 只看该作者
厉害了，大神。我最近在搞超声波跟随小车，但是都已失败告终。反反复复上网查资料，还是没结果。看了您的程序后稍有思绪，但是有些地方没看懂，也许是接触的太少的缘故罢了。向您学习。
回复

使用道具 举报

5#
ID:204673 发表于 2017-5-25 12:52 | 只看该作者
谢谢啦很受用
回复

使用道具 举报

6#
ID:140358 发表于 2017-5-26 07:24 来自手机 | 只看该作者
我最近也在做小车，只是效果有点不理想，看了感觉有点启发
回复

使用道具 举报

7#
ID:191542 发表于 2017-5-28 17:19 | 只看该作者
厉害了，准备搞小车
回复

使用道具 举报

8#
ID:157311 发表于 2017-8-8 17:56 | 只看该作者
有没有压缩包形式的资料
回复

使用道具 举报

9#
ID:240102 发表于 2017-10-16 23:20 | 只看该作者
大神，能写下用到的 原件么？
回复

使用道具 举报

10#
ID:240102 发表于 2017-10-16 23:20 | 只看该作者
大神能说下用到的原件么？
回复

使用道具 举报

11#
ID:240102 发表于 2017-10-16 23:21 | 只看该作者
大神能说下用到的原件和电路图么？ 我也想做一个四驱
回复

使用道具 举报

12#
ID:332698 发表于 2018-5-22 14:39 | 只看该作者
好资料，51黑有你更精彩!!!需要了解一下
回复

使用道具 举报

13#
ID:336169 发表于 2018-5-22 23:38 来自手机 | 只看该作者
确实不错
回复

使用道具 举报

14#
ID:340236 发表于 2018-6-1 09:29 | 只看该作者
好资料，51黑有你更精彩!!!需要了解一下
回复

使用道具 举报

15#
ID:356094 发表于 2018-6-21 15:33 | 只看该作者
确实很受用，谢谢楼主的分享
回复

使用道具 举报

16#
ID:361651 发表于 2018-6-30 13:29 | 只看该作者
大神，求助，怎么让小车按着走过的路线原路返回
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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