标题: 2.4G遥控小车设计 超声波数据回传 舵机转向 OLED显示 STC8A8K64S4单片机程序+电路 [打印本页]
作者: 15932885433    时间: 2018-12-28 20:22
标题: 2.4G遥控小车设计 超声波数据回传 舵机转向 OLED显示 STC8A8K64S4单片机程序+电路
在上一次用开发板做小车后  继续深入研究  把开发板换成了PCB  遥控器用两个模拟量摇杆，达到了玩小车的乐趣 ， 又在原有的基础上增加了超声波数据回传，实现了数据收发，而且程序也有了很大的优化 ，速度变得更快了点，最重要的还是用了PCB ，买一些元器件就可以自己做电路，特别适合学生DIY，我也是用腐刻做板的，所以不用担心很复杂。直接附上图片吧。

制作出来的实物图如下：


Altium Designer画的原理图和PCB图如下：(51hei附件中可下载工程文件)


nRF24L01无线发射检测：
1、将nRF24L01模块按照正确方向插到J11端子上；
2、MINI USB连接线给开发板通电下载程序，下载软件中内部IRC时钟选择11.0592MHZ；
3、下载程序后,开发板蓝色指示灯会不停闪烁，表示无线发送正常；
4、此时，如果有下发接收程序的开发板，则可以观察到有表示接收到的红色指示灯闪烁。
注：该实验需要配合接收实验进行。

nRF24L01无线接收实验：
1、将nRF24L01模块按照正确方向插到J11端子上；
2、MINI USB连接线给开发板通电下载程序，下载软件中内部IRC时钟选择11.0592MHZ；
3、下载程序后,开发板红色指示灯会常亮，表示没有接收到无线信号；
4、此时，如果有下发发送程序的开发板，则可以观察到该接收板上的红色指示灯闪烁。
注：该实验需要配合发送实验进行。

单片机源程序如下:
  1. /****************************************Copyright (c)****************************************************
  2. **                                       
  3. **                                 
  4. **
  5. **--------------File Info---------------------------------------------------------------------------------
  6. ** File name:                       
  7. ** Last modified Date:         
  8. ** Last Version:                  
  9. ** Descriptions:                                                       
  10. **--------------------------------------------------------------------------------------------------------
  11. ** Created by:                        FiYu
  12. ** Created date:                2018-2-1
  13. ** Version:                            1.0
  14. ** Descriptions:                nRF24L01无线发射程序（硬件SPI）                                       
  15. **--------------------------------------------------------------------------------------------------------
  16. ** Modified by:                        FiYu
  17. ** Modified date:                               
  18. ** Version:                                  
  19. ** Descriptions:               
  20. ** Rechecked by:                               
  21. **********************************************************************************************************/
  22. /****-----请阅读ReadMe.txt进行实验-----***********/


  25. #include        "STC8.H"
  26. #include "oled.h"
  27. #include  "intrins.h"
  28. #include  "delay.h"
  29. #include  "ADC.h"
  30. #include "NRF24L01.h"
  31. #include "timer.h"
  32.   bit ZF,CJ=0;
  33.         bit kaiqi=0;       
  34.         sbit Rled=P0^7;
  35.         sbit Gled=P0^6;
  36.         sbit Bled=P0^5;
  37. extern bit TIM,JS ;
  38. extern bit LEDK;         
  39. extern uint8  RxPayload[6];   //无线接收缓存
  40. extern uint8  TxPayload[6];   //无线发送缓存
  41. extern uint8 S2;
  42. void moter(uint8 zf,uint8 SD)        ;                                   //  电机驱动函数
  43. void CSZX(uint16 y);
  44. void INT0_init();                //外部中断0的初始化配置       
  45. void INT1_init();
  46. void led(bit x,bit y,bit z);
  47. void OLEDXS(void);
  48. void INT0_int (void) interrupt 0               
  49. {               
  50.      
  51.                 delay_ms(150);
  52.         if(P3^2==0)
  53.                 {
  54.                         kaiqi=~kaiqi;
  55.                 }
  56.        
  57.         }

  59. void INT1_int (void) interrupt 2               
  60. {               
  61.                 delay_ms(150);
  62.           if(P3^3==0){CJ=~CJ;}               
  63. }

  65. /***************************************************************************
  66. * 描  述 : 主函数
  67. * 入  参 : 无
  68. * 返回值 : 无
  69. **************************************************************************/
  70. int main()         
  71. {   
  72.                 uint16 n1=0;
  73.     bit M1=1;       
  74.                 TxPayload[0] = 0x5A;
  75.                 TxPayload[3] = 0xA5;
  76.                 OLED_Init() ;  
  77.                 delay_ms(20);                               
  78.                  OLEDXS();
  79.                 Init_NRF24L01_MA();                  //初始化
  80.                 Set_TxMode_MA();                                                  //配置nRF24L01为发送模式       
  81.           delay_ms(20);
  82.                 INT0_init();
  83.           INT1_init();
  84.     Timer1Init();
  85.                 EA=1;
  86.                 ADC_config();

  88.   while(1)
  89.   {
  90.         if(CJ==0&&kaiqi==0){led(1,1,1); led(0,1,1);Set_TxMode_MA();              //第0模式    发送停止不接受
  91.             while(CJ==0&&kaiqi==0){
  92.                         ADC1();                                //读取AD的值
  93.                         ADC2();               
  94.                         if(kaiqi==0&&LEDK==1)
  95.                         {
  96.                                 Rled=~Rled;                                                
  97.                                 TxPayload[0] = 0x5A;       
  98.                                 TxPayload[1] = 50;       
  99.                                 TxPayload[2] = 50;       
  100.                                 TxPayload[3] = 0xA5;       
  101.                                 TxPayload[4] = 0;       
  102.                                 NRF24L01_TxPacket_MA(TxPayload);            //发送校验码
  103.                                 NRF24L01_TxPacket_MA(TxPayload+1);          //发送数据               
  104.                                 NRF24L01_TxPacket_MA(TxPayload+2);    //发送数据
  105.                                 NRF24L01_TxPacket_MA(TxPayload+3);    //发送校验码
  106.                                 NRF24L01_TxPacket_MA(TxPayload+4);    //发送启动标志位

  108.                                 LEDK=0;
  109.                         }       
  110.                 }
  111.         }
  112.                        
  113. if(kaiqi==0&&CJ==1){led(1,0,1);                 //第1模式  接收和发送停止信号
  114.         while(CJ==1&&kaiqi==0){
  115.                         if(JS==1){Set_TxMode_MA();  
  116.             while(JS){        led(1,0,1);       
  117.                         ADC1();                                //读取AD的值
  118.                         ADC2();               
  119.                         TxPayload[1] = 50;       
  120.                         TxPayload[2] = 50;                               
  121.                         TxPayload[4] = 1;       
  122.           
  123.                         NRF24L01_TxPacket_MA(TxPayload);            //发送校验码
  124.                         NRF24L01_TxPacket_MA(TxPayload+1);          //发送数据               
  125.                         NRF24L01_TxPacket_MA(TxPayload+2);    //发送数据
  126.                         NRF24L01_TxPacket_MA(TxPayload+3);    //发送校验码
  127.                         NRF24L01_TxPacket_MA(TxPayload+4);    //发送启动标志位
  128.                         CSZX(70+20*TxPayload[1]/50);          //使控制超声波的舵机转到中间位置
  129.                                
  130.                                 if(TxPayload[2]<48)moter(0,(49-TxPayload[2])*80/45);   //用OLED显示控制电机的PWM值  这里最大是80，可以修改到90以上，但不能是100，因为AD的波动值会直接超过一百
  131.                                          else if(TxPayload[2]<52)   moter(2,0);              //防止AD波动造成误启动
  132.                                                                 else  moter(1,(TxPayload[2]-52)*80/45);                                //正转PWM值                       
  133.                 }
  134.         }                       
  135.                          if(JS==0){        Set_RxMode_MA();
  136.                         while(!JS){
  137.                   if(NRF24L01_RxPacket_MA(RxPayload) == RX_OK)          //如果接收成功
  138.                         {
  139.                         if(RxPayload[0] == 0x04)                                                                     //检验校验码
  140.                         {                               
  141.                         while( !(NRF24L01_RxPacket_MA(RxPayload+1)==RX_OK));                                //等待接收数据
  142.                          while( !(NRF24L01_RxPacket_MA(RxPayload+2)==RX_OK));                                //等待接收数据
  143.                                 while( !(NRF24L01_RxPacket_MA(RxPayload+3)==RX_OK));                        //检验校验码
  144.                         }
  145.                
  146.                         if(RxPayload[0] == 0x04 && RxPayload[3] == 0x05 )                 //符合校验码的值 ，则中间的数据是正确的，不然乱码，错位的数据就不对
  147.                                 {
  148.                                 n1= RxPayload[1]*256+RxPayload[2];
  149.                                         if(n1>=4000) LCD_P8x16Str(64, 6,"---.-");
  150.                                 if(n1/1000==0) OLED_ShowChar(64,6,' ');
  151.                                          else OLED_ShowChar(64,6,' '+16+n1/1000);
  152.                                                                 OLED_ShowChar(72,6,' '+16+n1%1000/100);
  153.                                                                 OLED_ShowChar(80,6,' '+16+n1%1000%100/10);
  154.                                                                 OLED_ShowChar(88,6,'.');       
  155.                                                                 OLED_ShowChar(96,6,' '+16+n1%1000%100%10);
  156.                                                                 RxPayload[0] = 0;
  157.                                                                 RxPayload[1] = 0;
  158.                                                                 RxPayload[2] = 0;
  159.                                                                 RxPayload[3] = 0;                               
  160.                                                                 }
  161.                                                         }
  162.                                                 }
  163.                                         }
  164.                                 }
  165.                         }
  166.        
  167. if(kaiqi==1&&CJ==0){ led(1,1,1);    led(1,1,0);         //第二模式  只发送不接收
  168.     Set_TxMode_MA();
  169. while(CJ==0&&kaiqi==1){
  170.                         ADC1();                                //读取AD的值
  171.                         ADC2();                    
  172.                         TxPayload[4] =2;          
  173.                         NRF24L01_TxPacket_MA(TxPayload);            //发送校验码
  174.                         NRF24L01_TxPacket_MA(TxPayload+1);          //发送数据               
  175.                         NRF24L01_TxPacket_MA(TxPayload+2);    //发送数据
  176.                         NRF24L01_TxPacket_MA(TxPayload+3);    //发送校验码
  177.                         NRF24L01_TxPacket_MA(TxPayload+4);    //发送启动标志位
  178.        
  179.                         CSZX(70+20*TxPayload[1]/50);          //使控制超声波的舵机转到中间位置               
  180.                                 if(TxPayload[2]<48)moter(0,(49-TxPayload[2])*80/45);   //用OLED显示控制电机的PWM值  这里最大是80，可以修改到90以上，但不能是100，因为AD的波动值会直接超过一百
  181.                                          else if(TxPayload[2]<52)   moter(2,0);              //防止AD波动造成误启动
  182.                                                                 else  moter(1,(TxPayload[2]-52)*80/45);                                //正转PWM值               
  183.                 }
  184.         }

  186. if(kaiqi==1&&CJ==1){led(1,1,1);}
  187. //if(kaiqi==1&&CJ==1){led(1,1,1);                 //第3模式  接收和发送
  188. //        while(CJ==1&&kaiqi==1){       
  189. //               
  190. //                        if(JS==1){Set_TxMode_MA();
  191. //            while(JS){led(0,0,0);
  192. //                        TxPayload[4] = 3;       
  193. //                        ADC1();                                //读取AD的值
  194. //                        ADC2();                            
  195. //                        NRF24L01_TxPacket_MA(TxPayload);            //发送校验码
  196. //                        NRF24L01_TxPacket_MA(TxPayload+1);          //发送数据               
  197. //                        NRF24L01_TxPacket_MA(TxPayload+2);    //发送数据
  198. //                        NRF24L01_TxPacket_MA(TxPayload+3);    //发送校验码
  199. //                        NRF24L01_TxPacket_MA(TxPayload+4);    //发送启动标志位
  200. //                        CSZX(70+20*TxPayload[1]/50);          //使控制超声波的舵机转到中间位置
  201. //                       
  202. //                                if(TxPayload[2]<48)moter(0,(49-TxPayload[2])*80/45);   //用OLED显示控制电机的PWM值  这里最大是80，可以修改到90以上，但不能是100，因为AD的波动值会直接超过一百
  203. //                                         else if(TxPayload[2]<52)   moter(2,0);              //防止AD波动造成误启动
  204. //                                                                else  moter(1,(TxPayload[2]-52)*80/45);                                //正转PWM值               
  205. //                }               
  206. //                       
  207. //                        if(JS==0){        Set_RxMode_MA();        led(1,1,1);
  208. //                        while(!JS){       
  209. //                  if(NRF24L01_RxPacket_MA(RxPayload) == RX_OK)          //如果接收成功
  210. //                        {
  211. //                        if(RxPayload[0] == 0x04)                                                                     //检验校验码
  212. //                        {                               
  213. //                        while( !(NRF24L01_RxPacket_MA(RxPayload+1)==RX_OK));                                //等待接收数据
  214. //                         while( !(NRF24L01_RxPacket_MA(RxPayload+2)==RX_OK));                                //等待接收数据
  215. //                                while( !(NRF24L01_RxPacket_MA(RxPayload+3)==RX_OK));                        //检验校验码
  216. //                        }
  217. //               
  218. //                        if(RxPayload[0] == 0x04 && RxPayload[3] == 0x05 )                 //符合校验码的值 ，则中间的数据是正确的，不然乱码，错位的数据就不对
  219. //                                {
  220. //                                n1= RxPayload[1]*256+RxPayload[2];
  221. //                                        if(n1>=5500) LCD_P8x16Str(56, 6,"---.-");
  222. //                                if(n1/1000==0) OLED_ShowChar(64,6,' ');
  223. //                                         else OLED_ShowChar(64,6,' '+16+n1/1000);
  224. //                                                                OLED_ShowChar(72,6,' '+16+n1%1000/100);
  225. //                                                                OLED_ShowChar(80,6,' '+16+n1%1000%100/10);
  226. //                                                                OLED_ShowChar(88,6,'.');       
  227. //                                                                OLED_ShowChar(96,6,' '+16+n1%1000%100%10);
  228. //                                                                RxPayload[0] = 0;
  229. //                                                                RxPayload[1] = 0;
  230. //                                                                RxPayload[2] = 0;
  231. //                                                                RxPayload[3] = 0;                               
  232. //                                                                }
  233. //                                                        }
  234. //                                                }
  235. //                                        }
  236. //                                }
  237. //                        }
  238. //                }

  240.         }
  241. }



  245. void led(bit x,bit y,bit z)
  246. {
  247.   Rled=x;
  248.         Gled=y;
  249.         Bled=z;
  250. }
  251. void OLEDXS(void)
  252. {                uint8 i;
  253.                 LCD_P8x16Str(56, 2,"X:");       //2.4G模块用了SPI，所以OLED用IIC显示
  254.                 LCD_P8x16Str(0, 2,"Y:");
  255.                 for(i=0;i<8;i++)        //遥控小车——发射
  256.            {
  257.                    LCD_P16x16Ch(i*16,0,i);                   
  258.                  };
  259.                  
  260.                          for(i=8;i<11;i++)
  261.            {
  262.                    LCD_P16x16Ch(i*16-16*8,4,i);        //转向角           控制小车转向的舵机
  263.                  };
  264.                  
  265.                  LCD_P8x16Str(48, 4,":");
  266.                 LCD_P8x16Str(80, 4,"'C");
  267.           LCD_P8x16Str(0, 6,"PWMY:");
  268.                 LCD_P8x16Str(104, 6,"CM");       
  269. }


  272. void moter(uint8 zf,uint8 SD)                                           //  电机驱动函数  
  273. {   uint8 sudu,i;
  274.            sudu=SD;
  275.           ZF=zf;
  276.           
  277.                 OLED_ShowChar(40,6, ' '+16+sudu%100/10);
  278.                 OLED_ShowChar(48,6, ' '+16+sudu%100%10);
  279.        
  280.                         if(zf<1)                           
  281.                         {
  282.                                 for(i=13;i<15;i++)  //反转
  283.                                  {
  284.                                         LCD_P16x16Ch(i*16-16*7,2,i);                   
  285.                                  }           
  286.                         }
  287.                                 else if(zf<2)      //正转
  288.                                         {
  289.                                                 for(i=11;i<13;i++)
  290.                                          {
  291.                                                 LCD_P16x16Ch(i*16-16*5,2,i);                   
  292.                                          };  
  293.                                  }
  294.                                            else {
  295.                                                                          for(i=15;i<17;i++)  //停转
  296.                                                                  {
  297.                                                                         LCD_P16x16Ch(i*16-16*9,2,i);                   
  298.                                                                  }
  299.                                                  }
  300.                                
  301.    
  302.                  
  303. }
  304. void CSZX(uint16 y)                  //超声波初值显示函数  ，没加可屏蔽
  305. {               
  306.                 uint8 yy;
  307.            yy=y;       
  308.             
  309.                 OLED_ShowChar(56,4,' '+16+yy/100);
  310.                 OLED_ShowChar(64,4,' '+16+yy%100/10);
  311.                 OLED_ShowChar(72,4,' '+16+yy%100%10);
  312.                                
  313. }
  314. void INT0_init()                //外部中断0的初始化配置       
  315. {
  316.         IE0  = 0;               //将INT0中断请求标志位清"0"
  317.         EX0 = 1;               //使能INT0中断允许位
  318.         IT0 = 1;                   //选择INT0为上升沿或下降沿触发方式          1为下降沿，0为上升沿

  320. }

  322. void INT1_init()
  323. {
  324.                                                                                 //外部中断1的初始化配置
  325.         IE1  = 0;                //将INT1中断请求标志位清"0"
  326.         EX1 = 1;                //使能INT1中断允许位
  327.         IT1 = 1;                      //选择INT1为下降沿触发方式           1为下降沿，0为上升沿                  
  328. }
复制代码

所有资料51hei提供下载:
PCB 图.zip (55.86 KB, 下载次数: 77)
遥控小车PCB版.zip (4.38 MB, 下载次数: 107)




作者: wuxishun    时间: 2019-2-24 20:57
好资料，希望能用得七
作者: 刘志超    时间: 2019-4-28 15:44
PCB封装库不全，根本打不开，文件大小才5KB
作者: shineyunze978    时间: 2021-3-30 01:41
15932885***@是高手玩家！编程水平较高！电路板设计也很到位！细节也做的比较到位！只是习惯了51编程，变量名称太随意，说明及关键理解性说明，太少有点可惜了！系统分析师可能会认为，这种习惯不适合做大型程序！但做玩家那是高手！
作者: zsttom    时间: 2021-12-3 16:31
请问小车底盘是从哪里弄的啊？



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1