標題: NRF24L01水庫無線傳輸控制 [打印本頁]
作者: Beastly    時間: 2018-5-13 11:48
標題: NRF24L01水庫無線傳輸控制
水庫無線傳輸
  1. 附錄C
  2. 顯示電路程序
  3. #include <reg51.h>
  4. #include <intrins.h>

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




  12. sbit rs  =  P2^6;            //寄存器選擇輸入
  13. sbit e  =  P2^7;            //液晶使能控制

  15. sbit MDO=P1^3;
  16. sbit SCK=P1^4;
  17. sbit CE=P1^5;
  18. sbit IRQ=P1^2;
  19. sbit MDI=P1^1;
  20. sbit CSN=P1^0;

  22. sbit key1=P1^6;
  23. sbit key2=P1^7;
  24. sbit key3=P3^2;
  25. sbit key4=P3^3;
  26. sbit buzzer=P2^5;



  30. u8 code table1[16]=" WELCOME TO USE ";
  31. u8 code table2[16]="Upper limit     ";
  32. u8 code table3[16]="  Connected     ";
  33. u8 code table4[16]="Lower limit     ";
  34. u8 code table5[16]="  Disconnected  ";

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

  38. u8 menu,cont,n,m,x,y;
  39. bit star,lose,mode;
  40. bit key1_press,key2_press,key3_press,key4_press;
  41. bit s1,s2,s3,s4;

  43. u8 tx[6],rx[6];
  44. u16 wait;

  46. void Delay15us()                //@12.000MHz
  47. {
  48.         unsigned char i;

  50.         i = 5;
  51.         while (--i);
  52. }

  54. void delay(u16 i)
  55. {
  56.         while(i--)
  57.         Delay15us();
  58. }

  60. void  write_com(u8 com)           //函數(shù)功能：寫指令
  61. {
  62.     e=0;
  63.         rs=0;
  64.         P0=com;
  65.         delay(10);
  66.         e=1;
  67.         delay(20);
  68.         e=0;
  69. }

  71. void write_data(u8 dat)           //函數(shù)功能：寫數(shù)據(jù)
  72. {
  73.     e=0;
  74.         rs=1;
  75.         P0=dat;
  76.         delay(10);
  77.         e=1;
  78.         delay(20);
  79.         e=0;
  80. }

  82. void init1602(void)                           //函數(shù)功能：初始化1602
  83. {
  84.     delay(300);
  85.         write_com(0x38);
  86.         delay(100);
  87.         write_com(0x38);
  88.         delay(100);
  89.         write_com(0x38);
  90.         write_com(0x38);
  91.         write_com(0x01);
  92.         write_com(0x01);
  93.         write_com(0x06);
  94.         write_com(0x0c);
  95. }


  98. u8 SPI(u8 byte)                //以下為無線模塊的控制程序，比較復雜。SPI模擬程序
  99. {
  100.         u8 i;
  101.         for(i=0;i<8;i++)
  102.         {
  103.                 MDI=(byte&0x80);//單片機輸出最高位數(shù)據(jù)
  104.                 SCK=1;                //時鐘信號的上升沿后無線模塊讀取新數(shù)據(jù)
  105.                 byte<<=1;        //數(shù)據(jù)左移
  106.                 byte|=MDO;        //單片機讀取數(shù)據(jù)
  107.                 SCK=0;                //時鐘信號的下降沿后無線模塊輸出新數(shù)據(jù)
  108.         }
  109.         return byte;
  110. }

  112. void REG_write(u8 address,u8 command)        //寫配置寄存器
  113. {
  114.         CSN=0;                //選中無線模塊
  115.         SPI(0x20+address);        //地址
  116.         SPI(command);                //命令
  117.         CSN=1;                //停止操作

  119. }

  121. void FIFO_read(u8 DATA_IN[])                //讀取接收數(shù)據(jù)緩沖區(qū)
  122. {
  123.         CSN=0;
  124.         SPI(0x61);        //讀取命令
  125.         DATA_IN[0]=SPI(0);        //讀取數(shù)據(jù)
  126.         DATA_IN[1]=SPI(0);
  127.         DATA_IN[2]=SPI(0);
  128.         DATA_IN[3]=SPI(0);
  129.         DATA_IN[4]=SPI(0);
  130.         DATA_IN[5]=SPI(0);
  131.         CSN=1;
  132. }

  134. void FIFO_write(u8 DATA_OUT[])
  135. {
  136.         CSN=0;
  137.         SPI(0xa0);
  138.         SPI(DATA_OUT[0]);
  139.         SPI(DATA_OUT[1]);
  140.         SPI(DATA_OUT[2]);
  141.         SPI(DATA_OUT[3]);
  142.         SPI(DATA_OUT[4]);
  143.         SPI(DATA_OUT[5]);

  145.         CSN=1;
  146. }

  148. void NRF_init()
  149. {
  150.         CE=0;                //先關(guān)閉模塊，才能寫命令寄存器
  151.         SCK=0;
  152.        
  153.         REG_write(0x01,0x00); //不允許自動應答
  154.         REG_write(0x02,0x01); //使用P0信道通信，使用默認地址
  155.         REG_write(0x04,0x00); //不允許自動應答
  156.         REG_write(0x05,66); //使用第64頻道，總計128頻道，可自定義
  157.         REG_write(0x06,0x27); //250kbps,0dBm
  158.         REG_write(0x11,6);//每次信號6字節(jié)數(shù)據(jù)
  159.         CE=1;
  160. }

  162. void RX_mode()                                 
  163. {
  164.         CE=0;                //先關(guān)閉模塊，才能寫命令寄存器
  165.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  166.         CE=1;
  167. }

  169. void TX_mode()                                 
  170. {
  171.         CE=0;                 
  172.         REG_write(0x00,0x0a);  
  173.         CE=1;
  174. }

  176. main()
  177. {
  178.     delay(100);
  179.         init1602();
  180.         NRF_init();
  181.         TX_mode();
  182.         write_com(0x80);
  183.         for(i=0;i<16;i++)
  184.         {
  185.             write_data(table1[i]);
  186.         }       
  187.         delay(50000);       

  189.         FIFO_write(tx);       

  191.         IP=0x08;                         //T1優(yōu)先級
  192.         star=1;MAX=70;MIN=40;tx[2]=MIN;mode=1;       
  193.         TR1=1;
  194.         TR0=1;
  195.         IE=0x8a;
  196.      while(1);
  197. }

  199. void ET0_isr()interrupt 1
  200. {
  201.         TL0 = 0xB0;                //設置定時初值50ms
  202.         TH0 = 0x3C;

  204.         n++;
  205.         if(n==1)
  206.         {
  207.                 TX_mode();
  208.                 FIFO_write(tx);
  209.                 delay(100);
  210.                 RX_mode();
  211.         }
  212.         else if(n==10)                //200ms
  213.         {
  214.                 n=0;
  215.                 lose=0;
  216.                 if(IRQ==0)
  217.                 {
  218.                         FIFO_read(rx);                //讀取接收數(shù)據(jù)
  219.                         CE=0;
  220.                         REG_write(0x07,0x40);        //清除無線模塊中斷信號
  221.                         CE=1;       
  222.                 }
  223.                 else  lose=1;
  224.                
  225.                 x=100-MIN;
  226.                 y=100-MAX;
  227.                 if(height>x||height<y||lose)buzzer=0;
  228.                 else buzzer=1;
  229.                

  231.                 if(key1_press)
  232.                 {
  233.                         key1_press=0;
  234.                         menu++;
  235.                         if(menu>2)menu=0;
  236.                         star=1;
  237.                 }
  238.                 if(key4_press)
  239.                 {
  240.                         key4_press=0;
  241.                        
  242.                         if(mode)mode=0,tx[5]=0x55;
  243.                         else mode=1,tx[5]=0;
  244.                 }
  245.                
  246.                 if(menu==0)
  247.                 {
  248.                        
  249.                         star=0;
  250.                         write_com(0x80);
  251.                         if(lose)
  252.                         {
  253.                                 for(i=0;i<16;i++)
  254.                                 {
  255.                                     write_data(table5[i]);
  256.                                 }
  257.                         }
  258.                         else
  259.                         {        for(i=0;i<16;i++)
  260.                                 {
  261.                                     write_data(table3[i]);
  262.                                 }
  263.                                
  264.                         }
  265.                                
  266.                        
  267.                        
  268.                         write_com(0x80+0x40);
  269.        
  270.                         write_data('H');
  271.                         write_data('e');
  272.                         write_data('i');
  273.                         write_data('g');
  274.                         write_data('h');
  275.                         write_data('t');
  276.                         write_data(':');
  277.        

  279.                         H=rx[0];
  280.                         if(H>90)H=90;
  281.                         height=100-H;
  282.                         if(height<100)write_data(' ');
  283.                         else write_data(height/100+48);
  284.                         write_data(height%100/10+48);
  285.                         write_data(height%10+48);

  287.                         write_data('m');
  288.                         write_data(' ');
  289.                         if(mode)
  290.                         {
  291.                                 write_data('A');
  292.                                 write_data('u');
  293.                                 write_data('t');
  294.                                 write_data('o');
  295.                         }
  296.                         else
  297.                         {
  298.                                 write_data('P');
  299.                                 write_data('u');
  300.                                 write_data('m');
  301.                                 write_data('p');
  302.                         }
  303.                         write_data((u8)mode+48);

  305.                 }
  306.                 else if(menu==1)
  307.                 {
  308.                         if(star)
  309.                         {
  310.                                 star=0;
  311.                                 write_com(0x80);
  312.                                
  313.                                 for(i=0;i<16;i++)
  314.                                 {
  315.                                     write_data(table2[i]);
  316.                                 }
  317.                         }
  318.                        
  319.                         write_com(0x80+0x40);

  321.                         if(key2_press)                //調(diào)整最大值
  322.                         {
  323.                                 key2_press=0;
  324.                                 MIN++;
  325.                         }          
  326.                         if(key3_press)
  327.                         {
  328.                                 key3_press=0;
  329.                                 MIN--;
  330.                         }
  331.                        
  332.                         tx[2]=MIN;          
  333.                        
  334.                         write_data('<');
  335.                         write_data('=');
  336.                         write_data(x%100/10+48);
  337.                         write_data(x%10+48);
  338.                         write_data(' ');
  339.                         write_data(' ');
  340.                         write_data(' ');
  341.                         write_data(' ');
  342.                         write_data(' ');
  343.                         write_data(' ');
  344.                         write_data(' ');
  345.                         write_data(' ');
  346.                         write_data(' ');
  347.                         write_data(' ');
  348.                         write_data(' ');
  349.                         write_data(' ');

  351.                        
  352.                                
  353.                 }
  354.                 else if(menu==2)
  355.                 {
  356.                         if(star)
  357.                         {
  358.                                 star=0;
  359.                                 write_com(0x80);
  360.                                 for(i=0;i<16;i++)
  361.                                 {
  362.                                     write_data(table4[i]);
  363.                                 }
  364.                         }
  365.                        
  366.                         write_com(0x80+0x40);

  368.                         if(key2_press)                //調(diào)整角度最大值
  369.                         {
  370.                                 key2_press=0;
  371.                                 MAX++;
  372.                         }          
  373.                         if(key3_press)
  374.                         {
  375.                                 key3_press=0;
  376.                                 MAX--;
  377.                         }          
  378.                        
  379.                         write_data('>');
  380.                         write_data('=');
  381.                         write_data(y%100/10+48);
  382.                         write_data(y%10+48);
  383.                         write_data(' ');
  384.                         write_data(' ');
  385.                         write_data(' ');
  386.                         write_data(' ');
  387.                         write_data(' ');
  388.                         write_data(' ');
  389.                         write_data(' ');
  390.                         write_data(' ');
  391.                         write_data(' ');
  392.                         write_data(' ');
  393.                         write_data(' ');
  394.                         write_data(' ');

  396.                        
  397.                                
  398.                 }
  399.                
  400.         }
  401.        
  402. }

  404. void ET1_isr()interrupt 3
  405. {
  406.         TL1 = 0xf0;                //設置定時初值10ms
  407.         TH1 = 0xd8;
  408.                
  409.                
  410.        
  411.         if(key1)                 //按鍵檢測
  412.         {
  413.                 if(s1)
  414.                 {
  415.                         s1=0;
  416.                         key1_press=1;
  417.                 }
  418.         }
  419.         else s1=1;
  420.                
  421.         if(key2)
  422.         {
  423.                 if(s2)
  424.                 {
  425.                         s2=0;
  426.                         key2_press=1;
  427.                 }
  428.         }
  429.         else s2=1;

  431.         if(key3)
  432.         {
  433.                 if(s3)
  434.                 {
  435.                         s3=0;
  436.                         key3_press=1;
  437.                 }
  438.         }
  439.         else s3=1;

  441.         if(key4)
  442.         {
  443.                 if(s4)
  444.                 {
  445.                         s4=0;
  446.                         key4_press=1;
  447.                 }
  448.         }
  449.         else s4=1;
  450. }
  451. 控制電路程序
  452. #include <reg51.h>
  453. #include <intrins.h>

  455. #define u8 unsigned char
  456. #define u16  unsigned int





  462. sbit trig=P1^7;
  463. sbit echo=P1^6;

  465. sbit relay=  P1^0;          //繼電器


  468. u8 height,MIN,n;


  471. sbit MDO=P2^3;
  472. sbit SCK=P2^4;
  473. sbit CE=P2^5;
  474. sbit IRQ=P2^2;
  475. sbit MDI=P2^1;
  476. sbit CSN=P2^0;

  478. u8 i;

  480. u8 tx[6],rx[6];
  481. u8 last,t,fast;
  482. u16 h;

  484. void Delay15us()                //@12.000MHz
  485. {
  486.         unsigned char i;

  488.         i = 5;
  489.         while (--i);
  490. }

  492. void delay(u16 i)
  493. {
  494.         while(i--)
  495.         Delay15us();
  496. }



  500. u8 SPI(u8 byte)                //以下為無線模塊的控制程序，比較復雜。SPI模擬程序
  501. {
  502.         u8 i;
  503.         for(i=0;i<8;i++)
  504.         {
  505.                 MDI=(byte&0x80);//單片機輸出最高位數(shù)據(jù)
  506.                 SCK=1;                //時鐘信號的上升沿后無線模塊讀取新數(shù)據(jù)
  507.                 byte<<=1;        //數(shù)據(jù)左移
  508.                 byte|=MDO;        //單片機讀取數(shù)據(jù)
  509.                 SCK=0;                //時鐘信號的下降沿后無線模塊輸出新數(shù)據(jù)
  510.         }
  511.         return byte;
  512. }

  514. void REG_write(u8 address,u8 command)        //寫配置寄存器
  515. {
  516.         CSN=0;                //選中無線模塊
  517.         SPI(0x20+address);        //地址
  518.         SPI(command);                //命令
  519.         CSN=1;                //停止操作

  521. }

  523. void FIFO_read(u8 DATA_IN[])                //讀取接收數(shù)據(jù)緩沖區(qū)
  524. {
  525.         CSN=0;
  526.         SPI(0x61);        //讀取命令
  527.         DATA_IN[0]=SPI(0);        //讀取數(shù)據(jù)
  528.         DATA_IN[1]=SPI(0);
  529.         DATA_IN[2]=SPI(0);
  530.         DATA_IN[3]=SPI(0);
  531.         DATA_IN[4]=SPI(0);
  532.         DATA_IN[5]=SPI(0);
  533.         CSN=1;
  534. }

  536. void FIFO_write(u8 DATA_OUT[])
  537. {
  538.         CSN=0;
  539.         SPI(0xa0);
  540.         SPI(DATA_OUT[0]);
  541.         SPI(DATA_OUT[1]);
  542.         SPI(DATA_OUT[2]);
  543.         SPI(DATA_OUT[3]);
  544.         SPI(DATA_OUT[4]);
  545.         SPI(DATA_OUT[5]);

  547.         CSN=1;
  548. }

  550. void NRF_init()
  551. {
  552.         CE=0;                //先關(guān)閉模塊，才能寫命令寄存器
  553.         SCK=0;
  554.        
  555.         REG_write(0x01,0x00); //不允許自動應答
  556.         REG_write(0x02,0x01); //使用P0信道通信，使用默認地址
  557.         REG_write(0x04,0x00); //不允許自動應答
  558.         REG_write(0x05,66); //使用第64頻道，總計128頻道，可自定義
  559.         REG_write(0x06,0x27); //250kbps,0dBm
  560.         REG_write(0x11,6);//每次信號6字節(jié)數(shù)據(jù)
  561.         CE=1;
  562. }

  564. void RX_mode()                                 
  565. {
  566.         CE=0;                //先關(guān)閉模塊，才能寫命令寄存器
  567.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  568.         CE=1;
  569. }

  571. void TX_mode()                                 
  572. {
  573.         CE=0;                 
  574.         REG_write(0x00,0x0a);  
  575.         CE=1;
  576. }






  583. main()
  584. {
  585.         delay(100);

  587.         NRF_init();
  588.         RX_mode();
  589.         MIN=40;

  591.         TMOD=0x01;
  592.         IE=0x82;
  593.         TR0=1;

  595.         while(1)
  596.         {
  597.           
  598.         }

  600. }

  602. void ET0_isr()interrupt 1
  603. {
  604.         TL0 = 0xB0;                //設置定時初值50ms
  605.         TH0 = 0x3C;
  606.        

  608.         if(IRQ==0)
  609.         {
  610.                 FIFO_read(rx);                //讀取接收數(shù)據(jù)
  611.                 CE=0;
  612.                 REG_write(0x07,0x40);        //清除無線模塊中斷信號
  613.                 CE=1;

  615.                 MIN=rx[2];

  617.                 TX_mode();
  618.                 FIFO_write(tx);
  619.                 delay(100);
  620.                 RX_mode();
  621.         }

  623. /*
  624.        
  625.            */
  626.         n++;

  628.         trig=1;
  629.         delay(30);
  630.         trig=0;
  631.         height=0;
  632.         while(!echo);
  633.         while(echo)
  634.         {
  635.                 height++;
  636.                 if(height>250)break;       
  637.         }

  639.         h+=height;
  640.         if(n==10)
  641.         {
  642.                 n=0;

  644.                 h=h/10;
  645.                 tx[0]=h;
  646.                
  647.                
  648.                 t++;
  649.                 if(t>4)
  650.                 {
  651.                         t=0;
  652.                         if(h-15<MIN)                 
  653.                         {
  654.                                
  655.                                 if(last-MIN>15)fast=1;
  656.                                 else fast=0;
  657.                                 last=MIN;       
  658.                         }
  659.                         else fast=0,last=MIN+15;
  660.                        
  661.                 }
  662.        
  663.                 if(h<MIN||rx[5]==0x55||fast)
  664.                 {
  665.                         relay=0;
  666.                 }
  667.                 else relay=1;

  669.                 h=0;
  670.         }       
  671. }

復制代碼


程序.docx

22.4 KB, 下載次數(shù): 6, 下載積分: 黑幣 -5

作者: emnides    時間: 2019-10-22 22:54
感想分享



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1