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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › STC单片机+nRF24L01萝莉控遥控器发射机加接收机，单片机 ...
12下一页
返回列表 发新帖
查看: 24839|回复: 57
打印 上一主题 下一主题
收起左侧

STC单片机+nRF24L01萝莉控遥控器发射机加接收机，单片机源码加原理图

  [复制链接]
跳转到指定楼层
楼主
ID:222798 发表于 2018-8-31 08:16 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本人亲测成功可用，感兴趣的可以试试，nRF24L01无线芯片和stc的51单片机构成

制作出来的实物图如下：



单片机源程序如下:
  1. #include<reg51.h>
  2. #define u8 unsigned char
  3. #define u16 unsigned int

  5. sfr IAP_DATA=0xe2;
  6. sfr IAP_ADDRH=0xe3;
  7. sfr IAP_ADDRL=0xe4;
  8. sfr IAP_CMD=0xe5;
  9. sfr IAP_TRIG=0xe6;
  10. sfr IAP_CONTR=0xe7;
  11. sfr AUXR=0x8e;
  12. sfr BRT=0x9c;
  13. sbit LED=P2^2;
  14. //sbit LED=P2^3;

  16. sbit CH1=P2^1;
  17. sbit CH2=P2^0;
  18. sbit CH3=P1^7;
  19. sbit CH4=P1^6;
  20. sbit CH5=P1^5;
  21. sbit CH6=P1^4;
  22. sbit CH7=P1^3;
  23. sbit CH8=P1^1;

  25. sbit CHB=P1^0;
  26. sbit CHC=P3^7;
  27. sbit CHD=P2^7;
  28. sbit CHE=P2^6;

  30. sbit MDO=P3^5;
  31. sbit SCK=P2^4;
  32. sbit CE=P2^5;
  33. sbit IRQ=P3^4;
  34. sbit MDI=P3^3;
  35. sbit CSN=P3^2;

  37. sfr P1M1=0x92;
  38. sfr P3M1=0xb2;
  39. sfr P2M1=0x96;


  42. u8 code random[100]={4,1,3,2,2,1,0,0,2,2,2,3,4,1,2,1,4,3,3,4,//随机跳频序列
  43.                                                                                  2,0,2,2,3,1,2,3,2,2,2,4,2,4,0,3,4,2,3,1,
  44.                                                                                  0,3,1,3,3,0,2,0,4,3,3,3,3,3,4,1,1,4,3,0,
  45.                            1,0,3,2,3,2,3,3,4,4,1,3,0,0,3,1,3,3,3,0,
  46.                            3,3,4,1,2,4,1,3,0,1,3,4,4,3,2,3,1,2,3,3};


  49. u16 timer1,timer2,timer3;
  50. u8 rx_num,receive;
  51.                                                                                        


  54. u8 rx[11];                //接收的11字节数据
  55. u8 tx[11];
  56. u8 m;
  57. u8 hopping_turn,hopping_num,hopping_count;


  60. //u8 missing_data[4];
  61. u8 address[5]={0xe7,0xe7,0xe7,0xe7,0xe7};
  62. u8 code address_0[5]={'L','O','V','E','!'};//使用LOVE作为对频暗语

  64. u8 hopping[5]={10,35,60,85,110};
  65. bit first,restar;
  66. bit connecting,lose;
  67. bit jump_1,jump_2,jump_mode;

  69. u8 NRF_error;
  70. u16 CH_data[8]={0,1024,0,1024,0,1024};
  71. u16 data buff[8];
  72. u16 temp1,temp2;
  73. u8 t_output;

  75. u8 TX_power=3;

  77. bit LED_flash;
  78. bit out_control_change;
  79. u16 idata out_control_data[8];


  82. void Delay1ms()                //@12.000MHz
  83. {
  84.         unsigned char i, j;
  85.         i = 12;
  86.         j = 168;
  87.         do
  88.         {
  89.                 while (--j);
  90.         } while (--i);
  91. }

  93. void delay_ms(u8 i)
  94. {
  95.         while(i--)
  96.         Delay1ms();
  97. }

  99. u8 EEPROM_read(u8 address)
  100. {
  101.         IAP_CMD=0x01;
  102.         IAP_ADDRH=0;
  103.         IAP_ADDRL=address;
  104.         IAP_TRIG=0x46;                        
  105.         IAP_TRIG=0xb9;
  106.         return IAP_DATA;
  107. }

  109. void EEPROM_write(u8 address,u8 byte)
  110. {
  111.         IAP_CMD=0x02;
  112.         IAP_DATA=byte;
  113.         IAP_ADDRH=0;
  114.         IAP_ADDRL=address;
  115.         IAP_TRIG=0x46;
  116.         IAP_TRIG=0xb9;
  117.         
  118. }

  120. void EEPROM_clean(u8 address)
  121. {
  122.         IAP_CMD=0x03;
  123.         IAP_ADDRH=0;
  124.         IAP_ADDRL=address;
  125.         IAP_TRIG=0x46;
  126.         IAP_TRIG=0xb9;
  127. }

  129. void DATA_read()
  130. {
  131.         IAP_CONTR=0x82;
  132.         if((EEPROM_read(0)!=0xe4)||(EEPROM_read(1)!=0xa5))         
  133.         {
  134.            first=1;

  136.         }
  137.         else
  138.         {
  139.           hopping[0]=EEPROM_read(2);
  140.                 hopping[1]=EEPROM_read(3);
  141.                 hopping[2]=EEPROM_read(4);
  142.                 hopping[3]=EEPROM_read(5);
  143.                 hopping[4]=EEPROM_read(6);
  144.                 address[0]=EEPROM_read(7);
  145.                 address[1]=EEPROM_read(8);
  146.                 address[2]=EEPROM_read(9);
  147.                 address[3]=EEPROM_read(10);
  148.                 address[4]=EEPROM_read(11);
  149.         }
  150.         
  151.         if((EEPROM_read(12)!=0xe4)||(EEPROM_read(13)!=0xa5))         
  152.         {
  153.           out_control_data[0]=512;
  154.                 out_control_data[1]=512;
  155.                 out_control_data[2]=80;
  156.                 out_control_data[3]=512;
  157.                 out_control_data[4]=512;
  158.                 out_control_data[5]=512;
  159.                 out_control_data[6]=512;
  160.                 out_control_data[7]=512;

  162.         }
  163.         else
  164.         {
  165.                
  166.                 out_control_data[0]=EEPROM_read(14);
  167.                 out_control_data[0]<<=8;
  168.                 out_control_data[0]+=EEPROM_read(15);
  169.                 out_control_data[1]=EEPROM_read(16);
  170.                 out_control_data[1]<<=8;
  171.                 out_control_data[1]+=EEPROM_read(17);
  172.                 out_control_data[2]=EEPROM_read(18);
  173.                 out_control_data[2]<<=8;
  174.                 out_control_data[2]+=EEPROM_read(19);
  175.                 out_control_data[3]=EEPROM_read(20);
  176.                 out_control_data[3]<<=8;
  177.                 out_control_data[3]+=EEPROM_read(21);
  178.                 out_control_data[4]=EEPROM_read(22);
  179.                 out_control_data[4]<<=8;
  180.                 out_control_data[4]+=EEPROM_read(23);
  181.                 out_control_data[5]=EEPROM_read(24);
  182.                 out_control_data[5]<<=8;
  183.                 out_control_data[5]+=EEPROM_read(25);
  184.                 out_control_data[6]=EEPROM_read(26);
  185.                 out_control_data[6]<<=8;
  186.                 out_control_data[6]+=EEPROM_read(27);
  187.                 out_control_data[7]=EEPROM_read(28);
  188.                 out_control_data[7]<<=8;
  189.                 out_control_data[7]+=EEPROM_read(29);

  191.         }
  192.         

  194.         IAP_CONTR=0;
  195. }
  196. void DATA_save()
  197. {
  198.         IAP_CONTR=0x82;
  199.                 EEPROM_clean(0);
  200.                 EEPROM_write(0,0xe4);
  201.                 EEPROM_write(1,0xa5);
  202.                 EEPROM_write(2,hopping[0]);
  203.                 EEPROM_write(3,hopping[1]);
  204.                 EEPROM_write(4,hopping[2]);
  205.                 EEPROM_write(5,hopping[3]);
  206.                 EEPROM_write(6,hopping[4]);
  207.                 EEPROM_write(7,address[0]);
  208.                 EEPROM_write(8,address[1]);
  209.                 EEPROM_write(9,address[2]);
  210.                 EEPROM_write(10,address[3]);
  211.                 EEPROM_write(11,address[4]);
  212.         
  213.                 if(out_control_change)
  214.                 {
  215.                         EEPROM_write(12,0xe4);
  216.                         EEPROM_write(13,0xa5);
  217.                
  218.                         EEPROM_write(14,out_control_data[0]>>8);
  219.                         EEPROM_write(15,out_control_data[0]);
  220.                         EEPROM_write(16,out_control_data[1]>>8);
  221.                         EEPROM_write(17,out_control_data[1]);
  222.                         EEPROM_write(18,out_control_data[2]>>8);
  223.                         EEPROM_write(19,out_control_data[2]);
  224.                         EEPROM_write(20,out_control_data[3]>>8);
  225.                         EEPROM_write(21,out_control_data[3]);
  226.                         EEPROM_write(22,out_control_data[4]>>8);
  227.                         EEPROM_write(23,out_control_data[4]);
  228.                         EEPROM_write(24,out_control_data[5]>>8);
  229.                         EEPROM_write(25,out_control_data[5]);
  230.                         EEPROM_write(26,out_control_data[6]>>8);
  231.                         EEPROM_write(27,out_control_data[6]);
  232.                         EEPROM_write(28,out_control_data[7]>>8);
  233.                         EEPROM_write(29,out_control_data[7]);
  234.                 }
  235.         
  236.                
  237.                
  238.         
  239.         
  240.         
  241.                 IAP_CONTR=0;
  242. }

  244. /**************************************************************************/
  245. //NRF24L01
  246. u8 SPI(u8 byte)
  247. {
  248.         u8 i;
  249.         for(i=0;i<8;i++)
  250.         {
  251.                 MDI=(byte&0x80);
  252.                 SCK=1;
  253.                 byte<<=1;
  254.                 byte|=MDO;
  255.                 SCK=0;
  256.         }
  257.         return byte;
  258. }

  260. void REG_write(u8 address,u8 command)
  261. {
  262.         CSN=0;
  263.         SPI(0x20+address);
  264.         SPI(command);
  265.         CSN=1;
  266. }

  268. void FIFO_write(u8 DATA_OUT[],u8 lengh)
  269. {
  270.         u8 i;
  271.         CSN=0;
  272.         SPI(0xa0);
  273.         for(i=0;i<lengh;i++)
  274.         SPI(DATA_OUT[i]);
  275.         CSN=1;
  276. }
  277. void FIFO_read(u8 DATA_IN[],u8 lengh)                //读取接收数据缓冲区
  278. {
  279.         u8 i;
  280.         CSN=0;
  281.         SPI(0x61);        //读取命令
  282.         for(i=0;i<lengh;i++)
  283.         DATA_IN[i]=SPI(0);           
  284.         CSN=1;
  285. }

  287. void TX_address(u8 DATA_IN[])
  288. {
  289.         CSN=0;                 
  290.         SPI(0x20+0x10);
  291.         SPI(DATA_IN[0]);
  292.         SPI(DATA_IN[1]);
  293.         SPI(DATA_IN[2]);
  294.         SPI(DATA_IN[3]);
  295.         SPI(DATA_IN[4]);
  296.         CSN=1;  
  297. }  
  298. void RX_address(u8 DATA_IN[])
  299. {
  300.         CSN=0;                 
  301.         SPI(0x20+0x0a);
  302.         SPI(DATA_IN[0]);
  303.         SPI(DATA_IN[1]);
  304.         SPI(DATA_IN[2]);
  305.         SPI(DATA_IN[3]);
  306.         SPI(DATA_IN[4]);
  307.         CSN=1;  
  308. }
  309. void RX_mode()                                 
  310. {
  311.         CE=0;
  312.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  313.         CE=1;
  314. }                                    
  315.         
  316. void TX_mode()                                 
  317. {
  318.         CE=0;
  319.         REG_write(0x00,0x0a);
  320.   CE=1;
  321. }

  323. void  NRF_power(u8 P)                                //发射功率设置 250k
  324. {                                                                                                               
  325.         CE=0;
  326.         if(P==3)REG_write(0x06,0x27);                  //0db 修正之前注释错误
  327.         else if(P==2)REG_write(0x06,0x25);          //-6db
  328.         else if(P==1)REG_write(0x06,0x23);          //-12db
  329.         else if(P==0)REG_write(0x06,0x21);    //-18db
  330.         CE=1;
  331. }

  333. void NRF_size(u8 l)
  334. {
  335.         CE=0;
  336.         REG_write(0x11,l);  
  337.         CE=1;
  338. }

  340. void NRF_channel(u8 c)
  341. {
  342.         CE=0;
  343.         REG_write(0x05,c);  
  344.         CE=1;
  345. }


  348. void NRF_init()
  349. {        
  350.         CE=0;
  351.         SCK=0;
  352.         REG_write(0x01,0x00); //禁止 自动应答
  353.         REG_write(0x02,0x01); //允许 P0信道
  354.         REG_write(0x04,0x00); //禁止 自动重发
  355.         RX_mode();                          
  356.         NRF_channel(66);
  357.         NRF_power(TX_power);
  358.         NRF_size(11);
  359.         RX_address(address);
  360.         TX_address(address);
  361. }

  363. void NRF_test()        //无线模块终极测试
  364. {        
  365.         u8 reset_err=0;
  366.         CE=0;
  367.         SCK=0;
  368.         CSN=0;
  369.         
  370.         if(SPI(0x20)!=0x0e){reset_err=1;}
  371.         SPI(0x0a);

  373.         CSN=1;

  375.         CSN=0;
  376.         SPI(0x00);

  378.         if(SPI(0x00)!=0x0a){NRF_error|=0x02;}//MOSI bad
  379.         CSN=1;

  381.         REG_write(0x01,0x00);
  382.         REG_write(0x04,0x00);
  383.         REG_write(0x11,1);
  384.         
  385.         FIFO_write(tx,1);
  386.         CE=1;

  388.         delay_ms(2);
  389.         
  390.         CSN=0;

  392.         if(SPI(0x00)!=0x2e){NRF_error|=0x04;}//CE bad
  393.         CSN=1;
  394.                
  395.         if(IRQ)NRF_error|=0x18;        //IRQ bad
  396.         else
  397.         {
  398.                 if(NRF_error&0x04==0)NRF_error|=0x10;                //MISO bad
  399.         }
  400.         CE=1;
  401.         
  402.         if(reset_err&&NRF_error>1)NRF_error|=0x01;//CSN,CLK bad
  403.         
  404.         REG_write(0x07,0x20);        //清除TX中断信号
  405. }

  407. void data_check(int x,int max,int min)
  408. {
  409.         
  410.         if(x>max)x=max;
  411.         if(x<min)x=min;

  413. }

  415. void initial()
  416. {        
  417.         u8 t;
  418.         
  419.         CH5=0;                        //如果CH5与CH6被短接，重新对码
  420.         Delay1ms();
  421.         if(CH6==0)                  //新增修正通道6插上舵机不能用的BUG
  422.         {
  423.                 P1M1=0x08;          //插上舵机也会使CH6为0，所以将CH5设为推挽
  424.                 CH5=1;
  425.                 Delay1ms();
  426.                 if(CH6)restar=1;   //如果CH6被拉高，说明5/6通道短接，启动重新对码
  427.         }
  428.                  
  429.         LED=0;                //点亮指示灯再关闭，表示单片机正常工作
  430.         delay_ms(100);
  431.         P1M1=0xfb;
  432.         P2M1=0xc7;
  433.         P3M1=0x80;        //将6通道输出IO口配置为大电流推挽模式，保证正常驱动电调与舵机
  434.         TMOD=0x11;        //允许两个定时器中断        
  435.         IE=0x8a;
  436.         IP=0x08;


  439.         if(restar)first=1;
  440.         DATA_read();

  442.         
  443.         data_check(out_control_data[0],1023,0);
  444.         data_check(out_control_data[1],1023,0);
  445.         data_check(out_control_data[2],1023,0);
  446.         data_check(out_control_data[3],1023,0);
  447.         data_check(out_control_data[4],1023,0);
  448.         data_check(out_control_data[5],1023,0);
  449.         data_check(out_control_data[6],1023,0);
  450.         data_check(out_control_data[7],1023,0);
  451.         

  453.         NRF_test();
  454.         if(NRF_error)
  455.         {
  456.                 t=10;
  457.                 while(t)
  458.                 {
  459.                         LED=0;                //模块错误闪灯
  460.                         delay_ms(50);
  461.                         LED=1;                //模块错误闪灯
  462.                         delay_ms(50);
  463.                         t--;
  464.                 }
  465.         }
  466.         
  467.         NRF_init();

  469.         

  471.         
  472.         if(first)
  473.         {
  474.                 NRF_power(0);
  475.                 NRF_channel(33);
  476.                 TX_address(address_0);
  477.                 RX_address(address_0);
  478.                 while(IRQ);
  479.                 FIFO_read(rx,11);                //读取接收数据
  480.                 CE=0;
  481.                 REG_write(0x07,0x40);        //清除无线模块中断信号
  482.                 CE=1;
  483.                 if(rx[0]==0xa0)
  484.                 {
  485.                         hopping[0]=rx[1];
  486.                         hopping[1]=rx[2];
  487.                         hopping[2]=rx[3];
  488.                         hopping[3]=rx[4];
  489.                         hopping[4]=rx[5];
  490.                         address[0]=rx[6];
  491.                         address[1]=rx[7];
  492.                         address[2]=rx[8];
  493.                         address[3]=rx[9];
  494.                         address[4]=rx[10];
  495.                 }
  496.                
  497.                 tx[0]='O',tx[1]='K';
  498.                 connecting=1;
  499.                 while(connecting)
  500.                 {
  501.                         TX_mode();               
  502.                         NRF_channel(33);
  503.                         TX_address(address_0);
  504.                         RX_address(address_0);
  505.                         FIFO_write(tx,11);
  506.                         Delay1ms();
  507.                         
  508.                         RX_mode();
  509.                         NRF_channel(hopping[0]);
  510.                         TX_address(address);
  511.                         RX_address(address);
  512.                         while(1)
  513.                         {
  514.                                 Delay1ms();
  515.                                 if(IRQ==0)
  516.                                 {
  517.                                         FIFO_read(rx,11);                //读取接收数据
  518.                                         CE=0;
  519.                                         REG_write(0x07,0x40);        //清除无线模块中断信号
  520.                                         CE=1;         
  521.                                         connecting=0;break;
  522.                                 }
  523.                                 t++;if(t>100){t=0;break;}
  524.                         }                          
  525.                 }
  526.                         DATA_save();
  527.         RX_address(address);
  528.         TX_address(address);
  529.         NRF_power(3);
  530.         }
  531.         
  532. }

  534.                                                                                                                                              

  536. main()
  537. {        
  538.         delay_ms(200);delay_ms(200);//开机延时以避过电源波动
  539.         
  540.         initial();
  541. PCON |= 0x80;                //使能波特率倍速位SMOD
  542.         SCON = 0x50;                //8位数据,可变波特率
  543.         AUXR |= 0x04;                //独立波特率发生器时钟为Fosc,即1T
  544.         BRT = 0xF3;                //设定独立波特率发生器重装值
  545.         AUXR |= 0x01;                //串口1选择独立波特率发生器为波特率发生器
  546.         AUXR |= 0x10;
  547.                   
  548.         
  549.         TR0=1;                        //打开定时器

  551.         
  552.         NRF_channel(hopping[0]);
  553.         
  554.         
  555.         while(IRQ);
  556.         TR1=1;
  557.         lose=1;
  558.         LED=1;
  559.         while(1)
  560.         {        
  561.                 while(IRQ&lose);
  562.                 if(lose)
  563.                 {        
  564.                         jump_1=0;jump_2=0;hopping_count=0;//收到有效信号后刷新跳频器
  565.                         receive++;timer1=0;timer3=0;m=0;               
  566.                         
  567.                         FIFO_read(rx,11);                //读取接收数据
  568.                         CE=0;
  569.                         REG_write(0x07,0x40);        //清除无线模块中断信号
  570.                         CE=1;
  571.                         
  572.                         TX_mode();
  573.                         tx[0]=rx_num;
  574.                         tx[1]=0;
  575.                         tx[2]=0;
  576.                         tx[3]=0;
  577.                         tx[4]=0;
  578.                         FIFO_write(tx,11);
  579.                         Delay1ms();

  581.                         RX_mode();
  582.                                                 
  583.                         if(jump_mode)
  584.                         {
  585.                                 jump_mode=0;
  586.                                 hopping_turn=random[hopping_num];
  587.                         }
  588.                         hopping_turn++;
  589.                         if(hopping_turn>4)hopping_turn=0;
  590.                         NRF_channel(hopping[hopping_turn]);
  591.                         



  595.                         if(rx[0]==0xa0)
  596.                         {
  597.                                 LED_flash=1,LED=0;
  598.                                 buff[0]=rx[1];
  599.                                 buff[0]<<=2;
  600.                                 buff[0]+=rx[2]>>6;
  601.                                 buff[1]=rx[2]&0x3f;
  602.                                 buff[1]<<=4;
  603.                                 buff[1]+=rx[3]>>4;                        
  604.                                 buff[2]=rx[3]&0x0f;
  605.                                 buff[2]<<=6;
  606.                                 buff[2]+=rx[4]>>2;
  607.                                 buff[3]=rx[4]&0x03;
  608.                                 buff[3]<<=8;
  609.                                 buff[3]+=rx[5];

  611.                                 buff[4]=rx[6];
  612.                                 buff[4]<<=2;
  613.                                 buff[4]+=rx[7]>>6;
  614.                                 buff[5]=rx[7]&0x3f;
  615.                                 buff[5]<<=4;
  616.                                 buff[5]+=rx[8]>>4;                        
  617.                                 buff[6]=rx[8]&0x0f;
  618.                                 buff[6]<<=6;
  619.                                 buff[6]+=rx[9]>>2;
  620.                                 buff[7]=rx[9]&0x03;
  621.                                 buff[7]<<=8;
  622.                                 buff[7]+=rx[10];
  623.                                 
  624.                                 
  625.                                 data_check(buff[0],1023,0);
  626.                                 data_check(buff[1],1023,0);
  627.                                 data_check(buff[2],1023,0);
  628.                                 data_check(buff[3],1023,0);
  629.                                 data_check(buff[4],1023,0);
  630.                                 data_check(buff[5],1023,0);
  631.                                 data_check(buff[6],1023,0);
  632.                                 data_check(buff[7],1023,0);
  633.                                 
  634.                                 out_control_data[0]=buff[0];
  635.                                 out_control_data[1]=buff[1];
  636.                                 out_control_data[2]=buff[2];
  637.                                 out_control_data[3]=buff[3];
  638.                                 out_control_data[4]=buff[4];
  639.                                 out_control_data[5]=buff[5];
  640.                                 out_control_data[6]=buff[6];
  641.                                 out_control_data[7]=buff[7];
  642.                                 
  643.                                 out_control_change=1;
  644.                                 DATA_save();
  645.                                 out_control_change=0;
  646.                                 
  647.                         }
  648.                         else if(rx[0]==0xa1)
  649.                         {
  650.                                 buff[0]=rx[1];
  651.                                 buff[0]<<=2;
  652.                                 buff[0]+=rx[2]>>6;
  653.                                 buff[1]=rx[2]&0x3f;
  654.                                 buff[1]<<=4;
  655.                                 buff[1]+=rx[3]>>4;                        
  656.                                 buff[2]=rx[3]&0x0f;
  657.                                 buff[2]<<=6;
  658.                                 buff[2]+=rx[4]>>2;
  659.                                 buff[3]=rx[4]&0x03;
  660.                                 buff[3]<<=8;
  661.                                 buff[3]+=rx[5];

  663.                                 buff[4]=rx[6];
  664.                                 buff[4]<<=2;
  665.                                 buff[4]+=rx[7]>>6;
  666.                                 buff[5]=rx[7]&0x3f;
  667.                                 buff[5]<<=4;
  668.                                 buff[5]+=rx[8]>>4;                        
  669.                                 buff[6]=rx[8]&0x0f;
  670.                                 buff[6]<<=6;
  671.                                 buff[6]+=rx[9]>>2;
  672.                                 buff[7]=rx[9]&0x03;
  673.                                 buff[7]<<=8;
  674.                                 buff[7]+=rx[10];
  675.                                 
  676.                                 
  677.                                 data_check(buff[0],1023,0);
  678.                                 data_check(buff[1],1023,0);
  679.                                 data_check(buff[2],1023,0);
  680.                                 data_check(buff[3],1023,0);
  681.                                 data_check(buff[4],1023,0);
  682.                                 data_check(buff[5],1023,0);
  683.                                 data_check(buff[6],1023,0);
  684.                                 data_check(buff[7],1023,0);
  685.                                 
  686.                                 CH_data[0]=buff[0];
  687.                                 CH_data[1]=buff[1];
  688.                                 CH_data[2]=buff[2];
  689.                                 CH_data[3]=buff[3];
  690.                                 CH_data[4]=buff[4];
  691.                                 CH_data[5]=buff[5];
  692.                                 CH_data[6]=buff[6];
  693.                                 CH_data[7]=buff[7];                                
  694.                         }
  695.                         
  696.                         


  699.                 }
  700.                 else
  701.                 {
  702.                          hopping_count++;
  703.                         if(hopping_count>5)jump_mode=1;
  704.                         
  705.                         if(jump_mode)
  706.                         {
  707.                                 hopping_num++;
  708.                                 if(hopping_num>99)hopping_num=0;
  709.                                 NRF_channel(hopping[random[hopping_num]]);
  710.                                 lose=1;
  711.                         }
  712.                         else
  713.                         {
  714.                                 hopping_turn++;
  715.                                 if(hopping_turn>4)hopping_turn=0;
  716.                                 NRF_channel(hopping[hopping_turn]);
  717.                                 lose=1;
  718.                         }
  719.                         
  720.                 }
  721.                
  722.         }
  723.         
  724. }


  727. void et0()interrupt 1                        //跳频定时器 3ms
  728. {
  729.         TL0=0x47;TH0=0xf4;

  731.         timer1++;
  732.         if(timer1>333)                        //每秒统计有效信号，小于20个点亮LED示警，表示信号微弱
  733.         {
  734.                 timer1=333;
  735.                 rx_num=0;LED=0;
  736.         }
  737.         else LED=1;
  738.         
  739.         timer2++;
  740.         if(timer2>333)
  741.         {
  742.                 timer2=0;
  743.                 rx_num=receive;
  744.                 receive=0;
  745.         }
  746.         
  747.         timer3++;
  748.         if(timer3>666)
  749. ……………………

  751. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
萝莉遥控.rar (236.02 KB, 下载次数: 713)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:432192 发表于 2019-2-17 12:28 来自手机 | 只看该作者
感谢楼主分享，同时感谢萝莉大神开源
回复

使用道具 举报

板凳
ID:486784 发表于 2019-3-8 12:40 | 只看该作者

感谢楼主分享，同时感谢萝莉大神开源
回复

使用道具 举报

地板
ID:275111 发表于 2019-3-8 14:00 | 只看该作者
NB。这个可以做遥控的车或者飞机吗？
回复

使用道具 举报

5#
ID:43383 发表于 2019-3-8 15:26 | 只看该作者
谢谢分享
回复

使用道具 举报

6#
ID:84997 发表于 2019-3-17 14:30 | 只看该作者
感谢楼主分享
回复

使用道具 举报

7#
ID:497166 发表于 2019-3-24 12:40 来自手机 | 只看该作者
楼主有基于51单片机的船模程序吗？
回复

使用道具 举报

8#
ID:35873 发表于 2019-3-25 01:29 | 只看该作者
好资料   谢谢分享
回复

使用道具 举报

9#
ID:385637 发表于 2019-3-25 10:10 | 只看该作者
注释少了，对于我这种新手看的很吃力
回复

使用道具 举报

10#
ID:79913 发表于 2019-5-25 12:24 | 只看该作者
感谢你的分享，同时感谢萝莉大神开源
回复

使用道具 举报

11#
ID:282981 发表于 2019-6-8 15:24 | 只看该作者
楼主有没有2代源码 看你的电路图凑齐了原价结果买的是5110屏幕求2代源码   lele4090039@163.com
回复

使用道具 举报

12#
ID:557411 发表于 2019-6-8 21:34 | 只看该作者
非常给力的设计，谢谢分享！
回复

使用道具 举报

13#
ID:574543 发表于 2019-6-29 13:59 | 只看该作者
感谢楼主分享
回复

使用道具 举报

14#
ID:282095 发表于 2019-6-29 14:13 | 只看该作者
感谢分享
回复

使用道具 举报

15#
ID:404831 发表于 2019-7-5 13:30 | 只看该作者
正要找的呢！感谢楼主分享！
回复

使用道具 举报

16#
ID:580382 发表于 2019-7-9 01:17 来自手机 | 只看该作者
很棒的分享，很感激
回复

使用道具 举报

17#
ID:408841 发表于 2019-7-10 13:02 来自手机 | 只看该作者
没有解压码啊
回复

使用道具 举报

18#
ID:243394 发表于 2019-7-13 09:19 | 只看该作者
感谢楼主分享，同时感谢萝莉大神开源
回复

使用道具 举报

19#
ID:598167 发表于 2019-8-9 09:23 | 只看该作者
楼主，有六通道接收代码吗      3131829009@qq.com
回复

使用道具 举报

20#
ID:51142 发表于 2019-8-19 23:06 | 只看该作者
支持一下
回复

使用道具 举报

21#
ID:48413 发表于 2019-8-20 19:19 | 只看该作者
谢谢楼主学习了
回复

使用道具 举报

22#
ID:464231 发表于 2019-9-4 21:36 | 只看该作者
向楼主学习,
回复

使用道具 举报

23#
ID:140420 发表于 2019-9-9 14:11 | 只看该作者
发射机原理图和程序定义引脚对不上
回复

使用道具 举报

24#
ID:477152 发表于 2019-9-13 16:09 | 只看该作者
不错哦  萝莉控
回复

使用道具 举报

25#
ID:459181 发表于 2019-10-7 16:56 | 只看该作者
谢谢大神的慷慨
回复

使用道具 举报

26#
ID:613618 发表于 2019-10-16 21:12 来自手机 | 只看该作者
很好的程序，要是注释多点就好了
回复

使用道具 举报

27#
ID:88256 发表于 2019-10-17 00:02 | 只看该作者
谢谢分享！
回复

使用道具 举报

28#
ID:499701 发表于 2019-10-17 13:29 | 只看该作者
感谢大神分享，感谢开源
回复

使用道具 举报

29#
ID:625659 发表于 2019-10-17 15:32 | 只看该作者
感谢分享
回复

使用道具 举报

30#
ID:252511 发表于 2019-10-19 10:30 | 只看该作者
很给力的资料，谢谢楼主分享
回复

使用道具 举报

31#
ID:285380 发表于 2019-10-19 14:25 | 只看该作者
我正说弄个航模，这遥控延迟有多高呢。
回复

使用道具 举报

32#
ID:641862 发表于 2019-11-14 13:42 | 只看该作者
感谢大神分享，萝莉三硬件都有了，就程序未找到，大神雪中送炭啊
回复

使用道具 举报

33#
ID:622823 发表于 2019-11-16 22:03 | 只看该作者
确实是个开源的好遥控 很多人都制作过
回复

使用道具 举报

34#
ID:517344 发表于 2019-11-28 18:38 | 只看该作者
感谢楼主分享，同时感谢萝莉大神开源
回复

使用道具 举报

35#
ID:517344 发表于 2019-12-2 21:55 | 只看该作者
问下楼主这个怎么对频呢？
回复

使用道具 举报

36#
ID:517344 发表于 2019-12-3 11:35 | 只看该作者
mealie666 发表于 2019-9-9 14:11
发射机原理图和程序定义引脚对不上

确实是对不上  兄弟等你做成了吗？
回复

使用道具 举报

37#
ID:254584 发表于 2019-12-5 21:57 | 只看该作者
谢谢楼主分享
回复

使用道具 举报

38#
ID:657586 发表于 2019-12-6 15:15 来自手机 | 只看该作者
感谢楼主分享，同时感谢萝莉大神开源
回复

使用道具 举报

39#
ID:517344 发表于 2019-12-6 18:35 | 只看该作者
lpwqgr 发表于 2019-12-5 21:57
谢谢楼主分享

兄弟做成了吗？  我做的没放应
回复

使用道具 举报

40#
ID:360391 发表于 2019-12-13 09:10 | 只看该作者
这个用其他模块会不会出现干扰
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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