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

<kbd id="y00gc"></kbd>

標題: 單片機智能小車 功能 循跡,紅外遙控,超聲波避障,舵機,PWM,跟蹤 [打印本頁]

---

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


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

2017-3-6 03:10 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

一些問題：

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

答：
我就是用的KEIL+51單片機，你可以在自己的開發板上做實驗，只要單品機是一樣的就完全可以，即使不完全一樣，也僅僅需要改改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"
   
5. 
   
6. 
   
7. #define Imax 14000    //此處為晶振為11.0592時的取值,
   
8. #define Imin 8000    //如用其它頻率的晶振時,
   
9. #define Inum1 1450    //要改變相應的取值。
   
10. #define Inum2 700
    
11. #define Inum3 3000
    
12. 
    
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
    
18. 
    
19. unsigned char ImOld=0;                                                //儲存舊命令，用于加減速控制
    
20. 
    
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
    
24. 
    
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. }
     
102. 
     
103. 
     
104. //外部中斷解碼程序
     
105. void intersvr1() interrupt 2
     
106. {
     
107.         Tc=TH1*256+TL1;     //提取中斷時間間隔時長，兩次下降沿之間的時間間隔
     
108.     TH1=0;
     
109.     TL1=0;              //定時中斷重新置零
     
110. 
     
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"
   
5. 
   
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輸出
    
14. 
    
15. unsigned char ucFlagDirection = 0;                                            //方向，0為前進，1為后退
    
16. 
    
17. //sbit FM  = P2^6;
    
18. 
    
19. void PwmLeft (void);
    
20. void PwmRight (void);
    
21. 
    
22. //前進函數
    
23. void Go(void)
    
24. {
    
25.         ucFlagDirection = 0;
    
26. 
    
27.         IN2=0;                 //左1電機  
    
28.         IN4=0;                 //左2電機
    
29. 
    
30.         IN6=0;                 //右1電機  
    
31.         IN8=0;                 //右2電機
    
32.         
    
33.         PwmLeft();         
    
34.         PwmRight();
    
35.         
    
36. }
    
37. 
    
38. //后退函數
    
39. void Back(void)
    
40. {
    
41. 
    
42.         ucFlagDirection = 1;
    
43. 
    
44.         IN1=0;                 //左1電機         
    
45.         IN3=0;                 //左2電機  
    
46. 
    
47.         IN5=0;                 //右1電機  
    
48.         IN7=0;                 //右2電機   
    
49. 
    
50.         PwmLeft();         
    
51.         PwmRight();
    
52. }
    
53. 
    
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. }
    
69. 
    
70. //小車右轉函數                        
    
71. void TurnRight(void)
    
72. {
    
73.         ucFlagDirection = 0;
    
74.         IN2=0;                 //左1電機  
    
75.         IN4=0;                 //左2電機
    
76. 
    
77.         IN6=0;                 //右1電機  
    
78.         IN8=0;                 //右2電機
    
79.         IN5=0;
    
80.         IN7=0;
    
81.          
    
82.         //左側繼續前進
    
83.         PwmLeft();         
    
84. }
    
85. 
    
86. //電機停止轉動函數            
    
87. void Stop(void)
    
88. {
    
89.         P1 = 0x00;
    
90. }
    
91. 
    
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. }
     
128. 
     
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"
    
36. 
    
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
    
47. 
    
48. #define FLAG_YAOKONG                0
    
49. #define FLAG_XUNJI                        1
    
50. #define FLAG_BIZHANG                2
    
51. #define FLAG_GENSUI                        3
    
52. 
    
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
    
58. 
    
59. #define NO                                        0
    
60. #define YES                                        1
    
61. 
    
62. #define DELAYTURN                        5000
    
63. #define DELAYDUOJI                        5000
    
64. 
    
65. 
    
66. /******************************子函數聲明區***********************************************/
    
67. 
    
68. void initial_myself(void);   
    
69. void initial_peripheral(void);
    
70. void delay100ms(void);        
    
71. 
    
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;        //        右跟隨
    
77. 
    
78. //sbit LEFT_CS  = P                //        左測速
    
79. //sbit RIGHT_CS = P                //        右測速
    
80. 
    
81. sbit KEY=P2^6;                        //  激活超聲波測距，測試用，蜂鳴器也響;
    
82. 
    
83. /******************************全局變量定義區***********************************************/
    
84. 
    
85. unsigned char ucPwm  = 4;                                                                //電機的PWM占空比，N/10
    
86.                                 
    
87. unsigned int ucPwmCountDianJ = 0;                                                //電機Pwm計數
    
88. unsigned int ucPwmCountDuoJ = 0;                                                //舵機Pwm計數
    
89. 
    
90. unsigned char ucFlagState = FLAG_YAOKONG;                                //模式選擇，遙控，循跡，避障
    
91. unsigned char ucFlagControl = FLAG_STOP;                                //遙控模式下的控制選擇，前進后退停止左轉右轉
    
92. 
    
93. 
    
94. unsigned int uc_delay_task_cnt[NUM_TASK_REFRESH];                //任務刷新延遲
    
95. 
    
96. unsigned char ucCSBCheck    = NO;                                                //用于判斷是否需要停車檢測
    
97. 
    
98. unsigned int ucPwmDuoj = 6;                                                                //舵機歸中,默認情況下先歸中
    
99. unsigned int ulS[4]         = {0,0,0,0};                                        //儲存距離數據,0°，180°，90°，后退時90°
    
100. 
     
101. unsigned char ucDuoJiPosition[3]={11,2,6};                                //舵機的0°，180°，90°對應的ucPwmDuoj數值
     
102. 
     
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標識，后退結束后，才開始轉彎
     
119. 
     
120. 
     
121. //unsigned char ucCSBDirection = 0;                                                //用來記錄并判斷檢測后行進方向
     
122. //unsigned char ucCSBFlag     = 0;                                                //用來激活400ms計時
     
123. //unsigned char ucFlagJumpoutPwm = 0;                                                //Pwm跳出標示，1為跳出
     
124. 
     
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};
     
127. 
     
128. 
     
129. /******************************主函數開始***********************************************/
     
130. void main(void)
     
131. {
     
132.         initial_myself();
     
133.         delay100ms();   
     
134.     initial_peripheral();
     
135. 
     
136. 
     
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.                 //超聲波+紅外避障模式
     
231. 
     
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. }
     
342. 
     
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.         }
     
372. 
     
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.         }
     
397. 
     
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.         }
     
410. 
     
411.         TR0=1;
     
412. }
     
413. 
     
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. }
     
428. 
     
429. void initial_peripheral(void) //第二區 初始化外圍
     
430. {
     
431.         EA=1;                     //開總中斷
     
432.         ET0=1;                    //允許定時器中斷
     
433. 
     
434.     IT1=1;                          //下降沿觸發
     
435.     EX1=1;                         //允許外部1中斷
     
436. 
     
437.     TR0=1;                    //啟動定時器0
     
438.     TR1=1;                         //啟動定時器1
     
439. }
     
440. 
     
441. void delay100ms(void)                //@11.0592MHz
     
442. {
     
443.         unsigned char i, j, k;
     
444. 
     
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. }
     
458. 
     

復制代碼

---

作者: ginny    時間: 2017-3-6 12:18
效果還是不錯的啊

---

作者: 925302604    時間: 2017-5-1 22:08
厲害了我的哥

---

作者: 小鵬鳥    時間: 2017-5-23 19:56
厲害了，大神。我最近在搞超聲波跟隨小車，但是都已失敗告終。反反復復上網查資料，還是沒結果。看了您的程序后稍有思緒，但是有些地方沒看懂，也許是接觸的太少的緣故罷了。向您學習。

---

作者: 笙歌飄飄    時間: 2017-5-25 12:52
謝謝啦很受用

---

作者: yjs    時間: 2017-5-26 07:24
我最近也在做小車，只是效果有點不理想，看了感覺有點啟發

---

作者: 總是離人淚    時間: 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

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影

<ul id="yu0ki"><td id="yu0ki"></td></ul><acronym id="yu0ki"></acronym>

<dl id="yu0ki"><source id="yu0ki"></source></dl>

<button id="yu0ki"></button>