欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機智能小車 功能 循跡,紅外遙控,超聲波避障,舵機,PWM,跟蹤 [打印本頁]
作者: 51hei學習技術中    時間: 2017-3-6 03:07
標題: 單片機智能小車 功能 循跡,紅外遙控,超聲波避障,舵機,PWM,跟蹤


下載：
智能小車資料.zip (89.07 KB, 下載次數(shù): 231)

一些問題：

問：
   大神請教個問題，我用keil給51單片機寫的程序能運行在其中設備上嗎？因為我是有一個打算就是用我的單片機作試驗，再把程序寫到自己設計的電路中去，我需要用到什么芯片才能執(zhí)行這個程序

答：
我就是用的KEIL+51單片機，你可以在自己的開發(fā)板上做實驗，只要單品機是一樣的就完全可以，即使不完全一樣，也僅僅需要改改IO口等

是用的兩個紅外，兩個紅外之間距離遠點，另外我這個直走和轉彎是兩個不同的PWM速度，轉彎大概是直走的2倍左右，效果好點.
下面是智能小車外形圖：


小車是用的慧靜4WD小車，程序是自己寫的.
http://player.youku.com/player.php/sid/XMTMwMjg2MDU0OA==/v.swf

http://player.youku.com/player.php/sid/XMTMwMzI0MjY0NA==/v.swf


遙控子程序：
  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存數(shù)時計數(shù)用
  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. //前進函數(shù)
  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. //后退函數(shù)
  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. //小車左轉函數(shù)                                
  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.         //右側繼續(xù)前進
  67.         PwmRight();
  68. }

  70. //小車右轉函數(shù)                        
  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.         //左側繼續(xù)前進
  83.         PwmLeft();         
  84. }

  86. //電機停止轉動函數(shù)            
  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. *                        數(shù)碼管段選                                P0
  13. *                        數(shù)碼管位選                                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（電機、舵機），數(shù)碼管（超聲波測距）
  26. *                         T1                紅外遙控計時
  27. *                        T2                超聲波計時
  28. *******************************************************/
  29. /******************************頭文件區(qū)***********************************************/
  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. /******************************宏定義區(qū)***********************************************/
  38. //需要定時刷新的任務數(shù)，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                //超聲波距離顯示數(shù)碼管刷新頻率，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. /******************************子函數(shù)聲明區(qū)***********************************************/

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

  72. /******************************IO口定義區(qū)***********************************************/
  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. /******************************全局變量定義區(qū)***********************************************/

  85. unsigned char ucPwm  = 4;                                                                //電機的PWM占空比，N/10
  86.                                 
  87. unsigned int ucPwmCountDianJ = 0;                                                //電機Pwm計數(shù)
  88. unsigned int ucPwmCountDuoJ = 0;                                                //舵機Pwm計數(shù)

  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};                                        //儲存距離數(shù)據(jù),0°，180°，90°，后退時90°

  101. unsigned char ucDuoJiPosition[3]={11,2,6};                                //舵機的0°，180°，90°對應的ucPwmDuoj數(shù)值

  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數(shù)組的第幾位
  110. unsigned char ucNumCSB=0;                                                                //進入超聲波檢測的次數(shù)，用來控制什么時候結束檢測，開始轉彎
  111. unsigned int  uiDelayTurn=DELAYTURN;                                        //轉彎結束，大概90°
  112. unsigned char ucFlagTurn=NO;                                                        //開始轉動的標志，此標志為YES時uiDelayTurn開始減
  113. unsigned char ucFlagTurnOver=NO;                                                //轉彎結束標志，為YES時，退出轉彎
  114. unsigned char ucFlagSMGLock=NO;                                                        //數(shù)碼管鎖，從檢測到障礙，到轉彎結束，這段時間鎖上不顯示
  115. unsigned char ucFlagGuiZhong=NO;                                                //頭一次進入避障模式先歸中
  116. unsigned char ucFlagBegin=NO;                                                        //歸中后此位為YES
  117. unsigned char ucFlagChangeState=NO;                                                //改變狀態(tài)標識，如果改變了，那么初始化避障模式的變量
  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. /******************************主函數(shù)開始***********************************************/
  130. void main(void)
  131. {
  132.         initial_myself();
  133.         delay100ms();   
  134.     initial_peripheral();


  137.         while(1)
  138.         {
  139.                 if(ucFlagChangeState==YES)                                                //每次改變狀態(tài)，將避障模式的變量初始化
  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數(shù)組的第幾位
  148.                         ucNumCSB=0;                                                                //進入超聲波檢測的次數(shù)，用來控制什么時候結束檢測，開始轉彎
  149.                         uiDelayTurn=DELAYTURN;                                        //轉彎結束，大概90°
  150.                         ucFlagTurn=NO;                                                        //開始轉動的標志，此標志為YES時uiDelayTurn開始減
  151.                         ucFlagTurnOver=NO;                                                //轉彎結束標志，為YES時，退出轉彎
  152.                         ucFlagSMGLock=NO;                                                        //數(shù)碼管鎖，從檢測到障礙，到轉彎結束，這段時間鎖上不顯示
  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)                                                //數(shù)碼管刷新
  243.                                 if(uc_delay_task_cnt[1]==0)                                                //數(shù)碼管刷新
  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;                                                                //將距離數(shù)據(jù)存起來
  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;                                                                //進入檢測的次數(shù)清0
  297.                                                                  ucNumS=0;                                                                        //存儲距離數(shù)據(jù)的位置清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. //中斷函數(shù)
  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時，相應的函數(shù)準備就緒
  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. //初始化區(qū)
  415. void initial_myself(void)//第一區(qū) 初始化單片機
  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;                                                //防止舵機轉動，同時不情愿的開啟了第四個數(shù)碼管的顯示
  427. }

  429. void initial_peripheral(void) //第二區(qū) 初始化外圍
  430. {
  431.         EA=1;                     //開總中斷
  432.         ET0=1;                    //允許定時器中斷

  434.     IT1=1;                          //下降沿觸發(fā)
  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. }

復制代碼





作者: ginny    時間: 2017-3-6 12:18
效果還是不錯的啊
作者: 925302604    時間: 2017-5-1 22:08
厲害了我的哥
作者: 小鵬鳥    時間: 2017-5-23 19:56
厲害了，大神。我最近在搞超聲波跟隨小車，但是都已失敗告終。反反復復上網(wǎng)查資料，還是沒結果。看了您的程序后稍有思緒，但是有些地方沒看懂，也許是接觸的太少的緣故罷了。向您學習。
作者: 笙歌飄飄    時間: 2017-5-25 12:52
謝謝啦很受用
作者: yjs    時間: 2017-5-26 07:24
我最近也在做小車，只是效果有點不理想，看了感覺有點啟發(fā)
作者: 總是離人淚    時間: 2017-5-28 17:19
厲害了，準備搞小車
作者: 李文威    時間: 2017-8-8 17:56
有沒有壓縮包形式的資料
作者: 星云體    時間: 2017-10-16 23:20
大神，能寫下用到的 原件么？
作者: 星云體    時間: 2017-10-16 23:20
大神能說下用到的原件么？
作者: 星云體    時間: 2017-10-16 23:21
大神能說下用到的原件和電路圖么？ 我也想做一個四驅
作者: 曦秋    時間: 2018-5-22 14:39
好資料，51黑有你更精彩!!!需要了解一下
作者: 王鑫雨    時間: 2018-5-22 23:38
確實不錯
作者: imsssu    時間: 2018-6-1 09:29
好資料，51黑有你更精彩!!!需要了解一下
作者: eydms    時間: 2018-6-21 15:33
確實很受用，謝謝樓主的分享
作者: 冷顏    時間: 2018-6-30 13:29
大神，求助，怎么讓小車按著走過的路線原路返回



歡迎光臨 (http://www.raoushi.com/bbs/) Powered by Discuz! X3.1