找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1720|回复: 1
打印 上一主题 下一主题
收起左侧

NRF24L01水库无线传输控制

[复制链接]
跳转到指定楼层
楼主
ID:328749 发表于 2018-5-13 11:48 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
水库无线传输
  1. 附录C
  2. 显示电路程序
  3. #include <reg51.h>
  4. #include <intrins.h>

  5. #define u8 unsigned char
  6. #define u16  unsigned int




  7. sbit rs  =  P2^6;            //寄存器选择输入
  8. sbit e  =  P2^7;            //液晶使能控制

  9. sbit MDO=P1^3;
  10. sbit SCK=P1^4;
  11. sbit CE=P1^5;
  12. sbit IRQ=P1^2;
  13. sbit MDI=P1^1;
  14. sbit CSN=P1^0;

  15. sbit key1=P1^6;
  16. sbit key2=P1^7;
  17. sbit key3=P3^2;
  18. sbit key4=P3^3;
  19. sbit buzzer=P2^5;



  20. u8 code table1[16]=" WELCOME TO USE ";
  21. u8 code table2[16]="Upper limit     ";
  22. u8 code table3[16]="  Connected     ";
  23. u8 code table4[16]="Lower limit     ";
  24. u8 code table5[16]="  Disconnected  ";

  25. u8 i,MAX,MIN,height,H;

  26. u8 menu,cont,n,m,x,y;
  27. bit star,lose,mode;
  28. bit key1_press,key2_press,key3_press,key4_press;
  29. bit s1,s2,s3,s4;

  30. u8 tx[6],rx[6];
  31. u16 wait;

  32. void Delay15us()                //@12.000MHz
  33. {
  34.         unsigned char i;

  35.         i = 5;
  36.         while (--i);
  37. }

  38. void delay(u16 i)
  39. {
  40.         while(i--)
  41.         Delay15us();
  42. }

  43. void  write_com(u8 com)           //函数功能:写指令
  44. {
  45.     e=0;
  46.         rs=0;
  47.         P0=com;
  48.         delay(10);
  49.         e=1;
  50.         delay(20);
  51.         e=0;
  52. }

  53. void write_data(u8 dat)           //函数功能:写数据
  54. {
  55.     e=0;
  56.         rs=1;
  57.         P0=dat;
  58.         delay(10);
  59.         e=1;
  60.         delay(20);
  61.         e=0;
  62. }

  63. void init1602(void)                           //函数功能:初始化1602
  64. {
  65.     delay(300);
  66.         write_com(0x38);
  67.         delay(100);
  68.         write_com(0x38);
  69.         delay(100);
  70.         write_com(0x38);
  71.         write_com(0x38);
  72.         write_com(0x01);
  73.         write_com(0x01);
  74.         write_com(0x06);
  75.         write_com(0x0c);
  76. }


  77. u8 SPI(u8 byte)                //以下为无线模块的控制程序,比较复杂。SPI模拟程序
  78. {
  79.         u8 i;
  80.         for(i=0;i<8;i++)
  81.         {
  82.                 MDI=(byte&0x80);//单片机输出最高位数据
  83.                 SCK=1;                //时钟信号的上升沿后无线模块读取新数据
  84.                 byte<<=1;        //数据左移
  85.                 byte|=MDO;        //单片机读取数据
  86.                 SCK=0;                //时钟信号的下降沿后无线模块输出新数据
  87.         }
  88.         return byte;
  89. }

  90. void REG_write(u8 address,u8 command)        //写配置寄存器
  91. {
  92.         CSN=0;                //选中无线模块
  93.         SPI(0x20+address);        //地址
  94.         SPI(command);                //命令
  95.         CSN=1;                //停止操作

  96. }

  97. void FIFO_read(u8 DATA_IN[])                //读取接收数据缓冲区
  98. {
  99.         CSN=0;
  100.         SPI(0x61);        //读取命令
  101.         DATA_IN[0]=SPI(0);        //读取数据
  102.         DATA_IN[1]=SPI(0);
  103.         DATA_IN[2]=SPI(0);
  104.         DATA_IN[3]=SPI(0);
  105.         DATA_IN[4]=SPI(0);
  106.         DATA_IN[5]=SPI(0);
  107.         CSN=1;
  108. }

  109. void FIFO_write(u8 DATA_OUT[])
  110. {
  111.         CSN=0;
  112.         SPI(0xa0);
  113.         SPI(DATA_OUT[0]);
  114.         SPI(DATA_OUT[1]);
  115.         SPI(DATA_OUT[2]);
  116.         SPI(DATA_OUT[3]);
  117.         SPI(DATA_OUT[4]);
  118.         SPI(DATA_OUT[5]);

  119.         CSN=1;
  120. }

  121. void NRF_init()
  122. {
  123.         CE=0;                //先关闭模块,才能写命令寄存器
  124.         SCK=0;
  125.        
  126.         REG_write(0x01,0x00); //不允许自动应答
  127.         REG_write(0x02,0x01); //使用P0信道通信,使用默认地址
  128.         REG_write(0x04,0x00); //不允许自动应答
  129.         REG_write(0x05,66); //使用第64频道,总计128频道,可自定义
  130.         REG_write(0x06,0x27); //250kbps,0dBm
  131.         REG_write(0x11,6);//每次信号6字节数据
  132.         CE=1;
  133. }

  134. void RX_mode()                                 
  135. {
  136.         CE=0;                //先关闭模块,才能写命令寄存器
  137.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  138.         CE=1;
  139. }

  140. void TX_mode()                                 
  141. {
  142.         CE=0;                 
  143.         REG_write(0x00,0x0a);  
  144.         CE=1;
  145. }

  146. main()
  147. {
  148.     delay(100);
  149.         init1602();
  150.         NRF_init();
  151.         TX_mode();
  152.         write_com(0x80);
  153.         for(i=0;i<16;i++)
  154.         {
  155.             write_data(table1[i]);
  156.         }       
  157.         delay(50000);       

  158.         FIFO_write(tx);       

  159.         IP=0x08;                         //T1优先级
  160.         star=1;MAX=70;MIN=40;tx[2]=MIN;mode=1;       
  161.         TR1=1;
  162.         TR0=1;
  163.         IE=0x8a;
  164.      while(1);
  165. }

  166. void ET0_isr()interrupt 1
  167. {
  168.         TL0 = 0xB0;                //设置定时初值50ms
  169.         TH0 = 0x3C;

  170.         n++;
  171.         if(n==1)
  172.         {
  173.                 TX_mode();
  174.                 FIFO_write(tx);
  175.                 delay(100);
  176.                 RX_mode();
  177.         }
  178.         else if(n==10)                //200ms
  179.         {
  180.                 n=0;
  181.                 lose=0;
  182.                 if(IRQ==0)
  183.                 {
  184.                         FIFO_read(rx);                //读取接收数据
  185.                         CE=0;
  186.                         REG_write(0x07,0x40);        //清除无线模块中断信号
  187.                         CE=1;       
  188.                 }
  189.                 else  lose=1;
  190.                
  191.                 x=100-MIN;
  192.                 y=100-MAX;
  193.                 if(height>x||height<y||lose)buzzer=0;
  194.                 else buzzer=1;
  195.                

  196.                 if(key1_press)
  197.                 {
  198.                         key1_press=0;
  199.                         menu++;
  200.                         if(menu>2)menu=0;
  201.                         star=1;
  202.                 }
  203.                 if(key4_press)
  204.                 {
  205.                         key4_press=0;
  206.                        
  207.                         if(mode)mode=0,tx[5]=0x55;
  208.                         else mode=1,tx[5]=0;
  209.                 }
  210.                
  211.                 if(menu==0)
  212.                 {
  213.                        
  214.                         star=0;
  215.                         write_com(0x80);
  216.                         if(lose)
  217.                         {
  218.                                 for(i=0;i<16;i++)
  219.                                 {
  220.                                     write_data(table5[i]);
  221.                                 }
  222.                         }
  223.                         else
  224.                         {        for(i=0;i<16;i++)
  225.                                 {
  226.                                     write_data(table3[i]);
  227.                                 }
  228.                                
  229.                         }
  230.                                
  231.                        
  232.                        
  233.                         write_com(0x80+0x40);
  234.        
  235.                         write_data('H');
  236.                         write_data('e');
  237.                         write_data('i');
  238.                         write_data('g');
  239.                         write_data('h');
  240.                         write_data('t');
  241.                         write_data(':');
  242.        

  243.                         H=rx[0];
  244.                         if(H>90)H=90;
  245.                         height=100-H;
  246.                         if(height<100)write_data(' ');
  247.                         else write_data(height/100+48);
  248.                         write_data(height%100/10+48);
  249.                         write_data(height%10+48);

  250.                         write_data('m');
  251.                         write_data(' ');
  252.                         if(mode)
  253.                         {
  254.                                 write_data('A');
  255.                                 write_data('u');
  256.                                 write_data('t');
  257.                                 write_data('o');
  258.                         }
  259.                         else
  260.                         {
  261.                                 write_data('P');
  262.                                 write_data('u');
  263.                                 write_data('m');
  264.                                 write_data('p');
  265.                         }
  266.                         write_data((u8)mode+48);

  267.                 }
  268.                 else if(menu==1)
  269.                 {
  270.                         if(star)
  271.                         {
  272.                                 star=0;
  273.                                 write_com(0x80);
  274.                                
  275.                                 for(i=0;i<16;i++)
  276.                                 {
  277.                                     write_data(table2[i]);
  278.                                 }
  279.                         }
  280.                        
  281.                         write_com(0x80+0x40);

  282.                         if(key2_press)                //调整最大值
  283.                         {
  284.                                 key2_press=0;
  285.                                 MIN++;
  286.                         }          
  287.                         if(key3_press)
  288.                         {
  289.                                 key3_press=0;
  290.                                 MIN--;
  291.                         }
  292.                        
  293.                         tx[2]=MIN;          
  294.                        
  295.                         write_data('<');
  296.                         write_data('=');
  297.                         write_data(x%100/10+48);
  298.                         write_data(x%10+48);
  299.                         write_data(' ');
  300.                         write_data(' ');
  301.                         write_data(' ');
  302.                         write_data(' ');
  303.                         write_data(' ');
  304.                         write_data(' ');
  305.                         write_data(' ');
  306.                         write_data(' ');
  307.                         write_data(' ');
  308.                         write_data(' ');
  309.                         write_data(' ');
  310.                         write_data(' ');

  311.                        
  312.                                
  313.                 }
  314.                 else if(menu==2)
  315.                 {
  316.                         if(star)
  317.                         {
  318.                                 star=0;
  319.                                 write_com(0x80);
  320.                                 for(i=0;i<16;i++)
  321.                                 {
  322.                                     write_data(table4[i]);
  323.                                 }
  324.                         }
  325.                        
  326.                         write_com(0x80+0x40);

  327.                         if(key2_press)                //调整角度最大值
  328.                         {
  329.                                 key2_press=0;
  330.                                 MAX++;
  331.                         }          
  332.                         if(key3_press)
  333.                         {
  334.                                 key3_press=0;
  335.                                 MAX--;
  336.                         }          
  337.                        
  338.                         write_data('>');
  339.                         write_data('=');
  340.                         write_data(y%100/10+48);
  341.                         write_data(y%10+48);
  342.                         write_data(' ');
  343.                         write_data(' ');
  344.                         write_data(' ');
  345.                         write_data(' ');
  346.                         write_data(' ');
  347.                         write_data(' ');
  348.                         write_data(' ');
  349.                         write_data(' ');
  350.                         write_data(' ');
  351.                         write_data(' ');
  352.                         write_data(' ');
  353.                         write_data(' ');

  354.                        
  355.                                
  356.                 }
  357.                
  358.         }
  359.        
  360. }

  361. void ET1_isr()interrupt 3
  362. {
  363.         TL1 = 0xf0;                //设置定时初值10ms
  364.         TH1 = 0xd8;
  365.                
  366.                
  367.        
  368.         if(key1)                 //按键检测
  369.         {
  370.                 if(s1)
  371.                 {
  372.                         s1=0;
  373.                         key1_press=1;
  374.                 }
  375.         }
  376.         else s1=1;
  377.                
  378.         if(key2)
  379.         {
  380.                 if(s2)
  381.                 {
  382.                         s2=0;
  383.                         key2_press=1;
  384.                 }
  385.         }
  386.         else s2=1;

  387.         if(key3)
  388.         {
  389.                 if(s3)
  390.                 {
  391.                         s3=0;
  392.                         key3_press=1;
  393.                 }
  394.         }
  395.         else s3=1;

  396.         if(key4)
  397.         {
  398.                 if(s4)
  399.                 {
  400.                         s4=0;
  401.                         key4_press=1;
  402.                 }
  403.         }
  404.         else s4=1;
  405. }
  406. 控制电路程序
  407. #include <reg51.h>
  408. #include <intrins.h>

  409. #define u8 unsigned char
  410. #define u16  unsigned int





  411. sbit trig=P1^7;
  412. sbit echo=P1^6;

  413. sbit relay=  P1^0;          //继电器


  414. u8 height,MIN,n;


  415. sbit MDO=P2^3;
  416. sbit SCK=P2^4;
  417. sbit CE=P2^5;
  418. sbit IRQ=P2^2;
  419. sbit MDI=P2^1;
  420. sbit CSN=P2^0;

  421. u8 i;

  422. u8 tx[6],rx[6];
  423. u8 last,t,fast;
  424. u16 h;

  425. void Delay15us()                //@12.000MHz
  426. {
  427.         unsigned char i;

  428.         i = 5;
  429.         while (--i);
  430. }

  431. void delay(u16 i)
  432. {
  433.         while(i--)
  434.         Delay15us();
  435. }



  436. u8 SPI(u8 byte)                //以下为无线模块的控制程序,比较复杂。SPI模拟程序
  437. {
  438.         u8 i;
  439.         for(i=0;i<8;i++)
  440.         {
  441.                 MDI=(byte&0x80);//单片机输出最高位数据
  442.                 SCK=1;                //时钟信号的上升沿后无线模块读取新数据
  443.                 byte<<=1;        //数据左移
  444.                 byte|=MDO;        //单片机读取数据
  445.                 SCK=0;                //时钟信号的下降沿后无线模块输出新数据
  446.         }
  447.         return byte;
  448. }

  449. void REG_write(u8 address,u8 command)        //写配置寄存器
  450. {
  451.         CSN=0;                //选中无线模块
  452.         SPI(0x20+address);        //地址
  453.         SPI(command);                //命令
  454.         CSN=1;                //停止操作

  455. }

  456. void FIFO_read(u8 DATA_IN[])                //读取接收数据缓冲区
  457. {
  458.         CSN=0;
  459.         SPI(0x61);        //读取命令
  460.         DATA_IN[0]=SPI(0);        //读取数据
  461.         DATA_IN[1]=SPI(0);
  462.         DATA_IN[2]=SPI(0);
  463.         DATA_IN[3]=SPI(0);
  464.         DATA_IN[4]=SPI(0);
  465.         DATA_IN[5]=SPI(0);
  466.         CSN=1;
  467. }

  468. void FIFO_write(u8 DATA_OUT[])
  469. {
  470.         CSN=0;
  471.         SPI(0xa0);
  472.         SPI(DATA_OUT[0]);
  473.         SPI(DATA_OUT[1]);
  474.         SPI(DATA_OUT[2]);
  475.         SPI(DATA_OUT[3]);
  476.         SPI(DATA_OUT[4]);
  477.         SPI(DATA_OUT[5]);

  478.         CSN=1;
  479. }

  480. void NRF_init()
  481. {
  482.         CE=0;                //先关闭模块,才能写命令寄存器
  483.         SCK=0;
  484.        
  485.         REG_write(0x01,0x00); //不允许自动应答
  486.         REG_write(0x02,0x01); //使用P0信道通信,使用默认地址
  487.         REG_write(0x04,0x00); //不允许自动应答
  488.         REG_write(0x05,66); //使用第64频道,总计128频道,可自定义
  489.         REG_write(0x06,0x27); //250kbps,0dBm
  490.         REG_write(0x11,6);//每次信号6字节数据
  491.         CE=1;
  492. }

  493. void RX_mode()                                 
  494. {
  495.         CE=0;                //先关闭模块,才能写命令寄存器
  496.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  497.         CE=1;
  498. }

  499. void TX_mode()                                 
  500. {
  501.         CE=0;                 
  502.         REG_write(0x00,0x0a);  
  503.         CE=1;
  504. }






  505. main()
  506. {
  507.         delay(100);

  508.         NRF_init();
  509.         RX_mode();
  510.         MIN=40;

  511.         TMOD=0x01;
  512.         IE=0x82;
  513.         TR0=1;

  514.         while(1)
  515.         {
  516.           
  517.         }

  518. }

  519. void ET0_isr()interrupt 1
  520. {
  521.         TL0 = 0xB0;                //设置定时初值50ms
  522.         TH0 = 0x3C;
  523.        

  524.         if(IRQ==0)
  525.         {
  526.                 FIFO_read(rx);                //读取接收数据
  527.                 CE=0;
  528.                 REG_write(0x07,0x40);        //清除无线模块中断信号
  529.                 CE=1;

  530.                 MIN=rx[2];

  531.                 TX_mode();
  532.                 FIFO_write(tx);
  533.                 delay(100);
  534.                 RX_mode();
  535.         }

  536. /*
  537.        
  538.            */
  539.         n++;

  540.         trig=1;
  541.         delay(30);
  542.         trig=0;
  543.         height=0;
  544.         while(!echo);
  545.         while(echo)
  546.         {
  547.                 height++;
  548.                 if(height>250)break;       
  549.         }

  550.         h+=height;
  551.         if(n==10)
  552.         {
  553.                 n=0;

  554.                 h=h/10;
  555.                 tx[0]=h;
  556.                
  557.                
  558.                 t++;
  559.                 if(t>4)
  560.                 {
  561.                         t=0;
  562.                         if(h-15<MIN)                 
  563.                         {
  564.                                
  565.                                 if(last-MIN>15)fast=1;
  566.                                 else fast=0;
  567.                                 last=MIN;       
  568.                         }
  569.                         else fast=0,last=MIN+15;
  570.                        
  571.                 }
  572.        
  573.                 if(h<MIN||rx[5]==0x55||fast)
  574.                 {
  575.                         relay=0;
  576.                 }
  577.                 else relay=1;

  578.                 h=0;
  579.         }       
  580. }

复制代码


程序.docx

22.4 KB, 下载次数: 6, 下载积分: 黑币 -5

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:614724 发表于 2019-10-22 22:54 | 只看该作者
感想分享
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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