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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机的nrf24l01遥控小车程序
返回列表 发新帖
查看: 3236|回复: 0
收起左侧

基于51单片机的nrf24l01遥控小车程序

[复制链接]
ID:669379 发表于 2020-3-23 21:38 | 显示全部楼层 |阅读模式
用到了两块51单片机，一块遥控，另一块控制小车。小车上测得的距离传送到遥控的单片机上显示。屏幕用的是1602；

单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #include <api.h>
  4. #include <duoji.h>
  5. #define uchar unsigned char
  6. #define uint unsigned int
  7. #define TX_ADR_WIDTH   5  // 5字节宽度的发送/接收地址
  8. #define TX_PLOAD_WIDTH 4  // 数据通道有效数据宽度

  10. unsigned long ultrasonic[5] = {0};
  11. unsigned int  time=0;//用于存放定时器时间值
  12. unsigned long S = 0;//用于存放距离的值//用于超声波测距

  14. uchar flag;
  15. static uint  aaa;//接受数据
  16. static uint dd;//存放距离

  18. uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址
  19. uchar RX_BUF[TX_PLOAD_WIDTH];
  20. uchar TX_BUF[TX_PLOAD_WIDTH];
  21. uchar DATA = 0x01;
  22. uchar bdata sta;

  24. sbit  RX_DR         = sta^6;
  25. sbit  TX_DS         = sta^5;
  26. sbit  MAX_RT = sta^4;
  27. sbit TX=P3^7;           //超声波模块Trig        控制端
  28. sbit RX=P3^6;           //超声波模块Echo        接收端
  29. sbit hw1=P2^6;
  30. sbit hw2=P2^7;//红外循迹
  31. bit  fl =0; //量程溢出标志位

  33. void yaokong2(void);
  34. void init_io(void)
  35. {
  36.         CE  = 0;        // 待机
  37.         CSN = 1;        // SPI禁止
  38.         SCK = 0;        // SPI时钟置低
  39.         IRQ = 1;        // 中断复位

  41. }

  43. void delay_ms(uchar x)
  44. {
  45.     uchar i, j;
  46.     i = 0;
  47.     for(i=0; i<x; i++)
  48.     {
  49.        j = 250;
  50.        while(--j);
  51.            j = 250;
  52.        while(--j);
  53.     }
  54. }

  56. uchar SPI_RW(uchar byte)
  57. {
  58.         uchar i;
  59.            for(i=0; i<8; i++)          // 循环8次
  60.            {
  61.                    MOSI = (byte & 0x80);   // byte最高位输出到MOSI
  62.                    byte <<= 1;             // 低一位移位到最高位
  63.                    SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
  64.                    byte |= MISO;               // 读MISO到byte最低位
  65.                    SCK = 0;                    // SCK置低
  66.            }
  67.     return(byte);                   // 返回读出的一字节
  68. }

  70. uchar SPI_RW_Reg(uchar reg, uchar value)
  71. {
  72.         uchar status;
  73.           CSN = 0;                   // CSN置低，开始传输数据
  74.           status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
  75.           SPI_RW(value);             // 然后写数据到该寄存器
  76.           CSN = 1;                   // CSN拉高，结束数据传输
  77.           return(status);            // 返回状态寄存器
  78. }

  80. uchar SPI_Read(uchar reg)
  81. {
  82.         uchar reg_val;
  83.           CSN = 0;                    // CSN置低，开始传输数据
  84.           SPI_RW(reg);                // 选择寄存器
  85.           reg_val = SPI_RW(0);        // 然后从该寄存器读数据
  86.           CSN = 1;                    // CSN拉高，结束数据传输
  87.           return(reg_val);            // 返回寄存器数据
  88. }

  90. uchar SPI_Read_Buf(uchar reg, uchar * pBuf, uchar bytes)
  91. {
  92.         uchar status, i;
  93.           CSN = 0;                    // CSN置低，开始传输数据
  94.           status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  95.           for(i=0; i<bytes; i++)
  96.             pBuf[i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
  97.           CSN = 1;                    // CSN拉高，结束数据传输
  98.           return(status);             // 返回状态寄存器
  99. }

  101. uchar SPI_Write_Buf(uchar reg, uchar * pBuf, uchar bytes)
  102. {
  103.         uchar status, i;
  104.           CSN = 0;                    // CSN置低，开始传输数据
  105.           status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
  106.           for(i=0; i<bytes; i++)
  107.             SPI_RW(pBuf[i]);        // 逐个字节写入nRF24L01
  108.           CSN = 1;                    // CSN拉高，结束数据传输
  109.           return(status);             // 返回状态寄存器
  110. }
  111. void RX_Mode(void)
  112. {
  113.           CE = 0;
  114.           SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 接收设备接收通道0使用和发送设备相同的发送地址
  115.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);               // 使能接收通道0自动应答
  116.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);           // 使能接收通道0
  117.           SPI_RW_Reg(WRITE_REG + RF_CH, 40);                 // 选择射频通道0x40
  118.           SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);  // 接收通道0选择和发送通道相同有效数据宽度
  119.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);            // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  120.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);              // CRC使能，16位CRC校验，上电，接收模式
  121.           CE = 1;                                            // 拉高CE启动接收设备
  122. }

  124. void TX_Mode(uchar * BUF)
  125. {
  126.         CE = 0;
  127.           SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
  128.           SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
  129.           SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
  130.           SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);       // 使能接收通道0自动应答
  131.           SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   // 使能接收通道0
  132.           SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
  133.           SPI_RW_Reg(WRITE_REG + RF_CH, 40);         // 选择射频通道0x40
  134.           SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
  135.           SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电
  136.         CE = 1;
  137. }

  139. uchar Check_ACK(bit clear)
  140. {
  141.         while(IRQ);
  142.         sta = SPI_RW(NOP);                    // 返回状态寄存器
  143.         if(MAX_RT)
  144.                 if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
  145.                         SPI_RW(FLUSH_TX);
  146.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  147.         IRQ = 1;
  148.         if(TX_DS)
  149.                 return(0x00);
  150.         else
  151.                 return(0xff);
  152. }

  154. void delay__(uint count)      //delay
  155. {
  156.   uint i;
  157.   while(count)
  158.   {
  159.     i=200;
  160.     while(i>0)
  161.     i--;
  162.     count--;
  163.   }
  164. }                       
  165. void Delay10us(unsigned int i)            //10us延时函数
  166. {
  167.            unsigned int j;
  168.         do{
  169.                   j = 10;
  170.                   do
  171.                 {
  172.                            _nop_();
  173.                    }while(--j);
  174.         }while(--i);
  175. }  

  177. void  StartModule()                          //启动超声波模块
  178. {
  179.             TX=1;                                             //启动一次模块
  180.       Delay10us(2);
  181.             TX=0;
  182. }
  183. unsigned long conut1(void)  //测量一次距离
  184. {
  185.         unsigned long dis = 0;
  186.         time=TH1*256+TL1;
  187.         TH1=0;
  188.         TL1=0;
  189.        
  190.   dis=(float)(time*1.085)*0.17;
  191.         return dis;
  192. }


  195. void bubble(unsigned long *a, int n) //冒泡程序

  197. {
  198.         int i,j,temp;       
  199.         for(i = 0;i < n-1; i++)       
  200.         {       
  201.                 for(j = i + 1; j < n; j++)
  202.                 {
  203.                         if(a[i] > a[j])
  204.                         {
  205.                                 temp = a[i];               
  206.                                 a[i] = a[j];               
  207.                                 a[j] = temp;                       
  208.                         }
  209.                 }
  210.         }

  212. }
  213. uint distance22()
  214. {
  215.           uint dis;
  216.     RX = 1;
  217.           StartModule();                                
  218.     while(RX==0);   
  219.        
  220.     TR1=1;                            
  221.     while(RX);                       
  222.     TR1=0;                               
  223.    dis=conut1();
  224.         return dis;
  225. }
  226. unsigned long Distance(void)        //测距
  227. {
  228.         int num = 0;
  229.         unsigned long Distance = 0;
  230.         RX = 1;
  231.         StartModule();                                
  232.     while(RX==0);   
  233.        
  234.     TR1=1;                            
  235.     while(RX);                       
  236.     TR1=0;                               
  237.    
  238.         conut1();

  240.         while(num < 5) // 测5次数据
  241.         {
  242.                 RX = 1;
  243.                 StartModule();                                
  244.             while(RX==0);   
  245.        
  246.                   TR1=1;                            
  247.             while(RX);                       
  248.             TR1=0;                               
  249.             
  250.                 S = conut1();
  251.                 ultrasonic[num] = S;
  252.                 num++;
  253.         }
  254.         num = 0;
  255.         bubble(ultrasonic, 5);
  256.         Distance = (ultrasonic[1]+ultrasonic[2]+ultrasonic[3])/3;
  257.         return Distance;
  258. }
  259. void duobi(void)                                //避障程序
  260. {               
  261.          uint a[]={0,0};//zuoyoujuli
  262.         //        dd=Distance();
  263.   //         juli=distance;
  264.           z0();
  265. if(dd>600)//old接收到的为cm，distance为毫米
  266.                 {
  267.                         qj();
  268.           }//前进时发射距离
  269.           else
  270.         {
  271.                 t(10);
  272.           y90();    y90();    y90();
  273.                 delaydj(100);
  274.         a[1]=Distance();
  275.           z90();          z90();          z90();
  276.                 delaydj(100);
  277.         a[0]=Distance();
  278.                 z0();
  279.                 if   (a[0]>a[1] && a[1]>300)
  280.                 {
  281.                         z(900);
  282.                         t(50);
  283.                 }
  284.                 else if(a[0]<a[1] && a[0]>300)
  285.                 {
  286.                         y(900);
  287.                         t(50);
  288.                 }
  289.                 else if (a[0]>a[1] && a[1]<300 || a[0]<a[1] && a[1]<300)
  290.                 {
  291.                        
  292.                   ht(500);
  293.                         t(50);
  294.                         if(a[0]<a[1])
  295.                   y(820);
  296.                         else z(820);
  297.                 }
  298.                 else
  299.                 {
  300.                         if(a[0]<a[1])
  301.                         {hz(800);
  302.                         t(10);}
  303.                         else hy(800);
  304.                
  305.                 }
  306.         }
  307. }

  309. //void hongwai(void)
  310. //{
  311. //          EX0 = 1;//开外部中断0
  312. //          IT0 = 1;//外部中断0高电平触发
  313. //    EX1 = 1;//开外部中断0
  314. //          IT1 = 1;//外部中断0高电平触发
  315. //        switch (hms)
  316. //        {
  317. //                case 0:qjj(100);      break;
  318. //          case 1:{t(10);z(200);}break;
  319. //          case 2:{t(10);y(200);}break;
  320. //        }
  321. //        if(dd<200)
  322. //                duobi();
  323. //          hms=0;
  324. //}
  325. void fashe (uint b)                        //发射数据十六进制码
  326. {

  328.          b/=10;                          //转化为cm
  329.         TX_BUF[2]=TT;
  330.          if(fl!=1 && b<500 && b>250)
  331.         {  
  332.                 b-=250;
  333.                 b=0x01/0x01*b;
  334.                 TX_BUF[0]=250;
  335.                 TX_BUF[1]=b;
  336.           TX_Mode(TX_BUF);
  337.                  SPI_RW(FLUSH_TX);
  338.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  339.         IRQ = 1;
  340.         }
  341.         else if(b<250)
  342.         {
  343.           b=0x01/0x01*b;
  344.                 TX_BUF[0]=b;
  345.                 TX_BUF[1]=0x00;
  346.           TX_Mode(TX_BUF);
  347.                  SPI_RW(FLUSH_TX);
  348.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  349.         IRQ = 1;
  350.         }
  351.         else if(fl==1)
  352.                  {
  353.                           fl=0;
  354.                           TX_BUF[0]=0x01;
  355.               TX_BUF[1]=0x00;
  356.               TX_Mode(TX_BUF);
  357.               SPI_RW(FLUSH_TX);
  358.         SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
  359.         IRQ = 1;
  360.                  }
  361.                  SPI_RW_Reg(FLUSH_TX, 0x00); //清除寄存器
  362.                  init_io();
  363.                  RX_Mode();
  364.                
  365.         }

  367. uint jieshou(void)
  368. {       
  369.           sta = SPI_Read(STATUS);          // 读状态寄存器
  370.             if(RX_DR)                                  // 判断是否接受到数据
  371.                 {
  372.                         SPI_Read_Buf(RD_RX_PLOAD, RX_BUF, TX_PLOAD_WIDTH);  // 从RX FIFO读出数据
  373.                         flag = 1;
  374.                 }
  375.                 SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除RX_DS中断标志
  376.                 if(flag)                           // 接受完成
  377.                 {  
  378.                         flag = 0;                       // 清标志
  379.                         aaa=RX_BUF[0];
  380. //                        if(aaa>15)  old=aaa;                //修改避障距离
  381.                 }
  382.                 SPI_RW_Reg(FLUSH_RX, 0xff);//清除寄存器
  383.                 return aaa;
  384. }
  385. void yaokong(uint a)
  386. {
  387.           switch (a)
  388.                         {
  389.                                 case 0: hz(300); break;
  390.                                 case 1: qjj(500);    break;
  391.                           case 2: hy(300); break;
  392.                                 case 3: duobi(); break;
  393.                                 case 4: z(400); break;
  394.                                 case 5: ht(400);break;
  395.                           case 6: y(500); break;
  396.                           case 8: yaokong2();break;
  397.                           case 15: t(1); break;
  398. //                  case 7: hongwai();break;
  399.                   }
  400. }
  401. void yaokong2(void)
  402. {
  403.         while(aaa!=15)//接收到3退出
  404.         {         TT=9;
  405.                 RX_Mode();
  406.                 aaa=jieshou();
  407.          switch(aaa)
  408.          {
  409.                  case 1:qjj(500);break;
  410.                  case 4:z(300); break;
  411.                  case 5:ht(500);break;
  412.            case 6:y(500);break;
  413.                  case 0:t(1);break;
  414. //                 case 9:{if(TT<9)++TT;}break;
  415. //                 case 10:{if(TT>4)--TT;}break;//加减速
  416.          }
  417.         if(aaa!=15)
  418.                 aaa=0;
  419.         }
  420. }
  421. //void gensui(void)
  422. //{
  423. //        uint pa;
  424. //          TT=4;
  425. //                if(hw1==0 && hw2==0)
  426. //                {
  427. //                        dd=Distance();
  428. //                        if(dd>30)
  429. //                        { pa=(dd/10-30)*25;qjj(pa);}
  430. //                 else {pa=(30-dd/10)*25;ht(pa);}
  431. //                       
  432. //                }
  433. //                else if(hw1==1 && hw2==1)
  434. //                {
  435. //                        dd=Distance();
  436. //                        if(dd>250 && dd<350)
  437. //                        t(1);
  438. //                        else
  439. //       {
  440. //         if (dd>300)
  441. //            { pa=(dd/10-30)*25;qjj(pa);}
  442. //                     else
  443. //             {pa=(30-dd/10)*25;ht(pa);}
  444. //                         }
  445. //                }
  446. //                else if(hw1==0 && hw2==1)
  447. //                y(400);
  448. //                else if(hw1==1 && hw2==0)
  449. //                        z(400);
  450. //}
  451. void sudu(void)
  452. {
  453.         if(dd>1000)   {TT=9;}
  454.         else if(dd>400&&dd<1000) {TT=dd/100;}
  455.         else TT=4;
  456. }
  457. void timer1() interrupt 3                  //T1 中断用来计数器溢出,超过测距范围
  458. {
  459.     fl=1;                                       //中断溢出标志
  460.     RX=0;
  461. }
  462. void timer0(void) interrupt 1//定时器0中断函数
  463. {
  464.           TR0 = 0;      //关闭定时器0
  465.     TH0 = 0xff;   //重装初值0.1ms
  466.     TL0 = 0xa3;

  468.                 kk++;
  469.          if(kk>=10)
  470.                 {
  471.                         kk=0;
  472. ……………………

  474. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
捕获.JPG
所有资料51hei提供下载:
遥控小车.zip (94.59 KB, 下载次数: 52)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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