久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 3549|回復: 0
打印 上一主題 下一主題
收起左側

基于51單片機的nrf24l01遙控小車程序

[復制鏈接]
跳轉到指定樓層
樓主
用到了兩塊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黑下載附件…………
復制代碼

所有資料51hei提供下載:
遙控小車.zip (94.59 KB, 下載次數: 52)


評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏3 分享淘帖 頂頂1 踩踩
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 精品免费国产一区二区三区四区介绍 | 日本一区二区影视 | 欧美极品在线观看 | 香蕉一区二区 | www国产成人免费观看视频,深夜成人网 | 中文字幕第一页在线 | 欧美一区二区三区在线观看 | 国产高清视频在线观看 | 99久久99热这里只有精品 | 精精久久| 精品视频99 | 综合二区 | 免费午夜剧场 | 久夜精品| av大片| 久久综合国产 | 国产激情在线播放 | 亚州综合在线 | 999国产视频 | 国产精品免费高清 | 日韩欧美在线观看 | 一级黄色短片 | 毛片电影 | 又黄又色 | 亚洲欧洲在线观看视频 | 欧美日韩在线播放 | 2020国产在线| 精品国产一区二区三区久久 | 成人在线视频免费观看 | 91精品在线看 | 欧美一区二区三区在线观看 | 国产日韩欧美一区 | 天天曰天天干 | 欧美精品福利视频 | 久久久99国产精品免费 | 国产xxxx搡xxxxx搡麻豆 | 国产视频一区二区在线观看 | 久久精品欧美一区二区三区麻豆 | 久久这里只有精品首页 | 精品久久久久久亚洲综合网站 | 亚洲一区国产精品 |