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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 开源12通道2.4G遥控制作-接收机
返回列表 发新帖
查看: 34261|回复: 22
收起左侧

开源12通道2.4G遥控制作-接收机

  [复制链接]
ID:203249 发表于 2017-5-21 20:36 | 显示全部楼层 |阅读模式
首先感谢开源大神萝莉，感谢开源精神，感谢大学。

友情提示，本教程必须有单片机基础，2.4G遥控基础（至少用过这类遥控）才可以操作。


7个模拟通道，5个开关通道


1-）准备材料
                        keil编译软件
                        stc-isp烧录软件
                        接收机的源码链接: https://pan.baidu.com/s/1pKPC9nX 密码: eaz2
                        usb转ttl下载器（那个宝上面随便搜的）
                         1493445289_452286.png
                        
2-）电路制作材料
                               材料清单：
                               10*10cm孔洞洞板；
                               STC12C5608AD 单片机；
                               12M晶振，30P电容*2；
                               电源电容470uf，无线模块电容大于等于47uf，104电容；
                               发光二极管，1K欧电阻；
                               NRF24L01模块；
                               3.3V稳压芯片；
                               1493446108_212076.png
                               下面那块是从这里裁剪出来的
                               1493445830_593546.png
3-）电路图
                   链接: https://pan.baidu.com/s/1bC5NtW 密码: u3mn

4-）做好的样子（有条件的话可以去打印pcb板）
                           1493447205_90195.png
                           1493447215_898265.png
                           1493447225_650292.png         
5-）下载程序  （下载程序可以焊好晶振后就烧写，这样避免后面焊好下载不了程序的尴尬）   
                            使用keil编译器编译出hex文件
                            用usb转ttl下载器连接做好的板子
                            用stc-isp软件烧写hex文件到板子
                           注意下载的时候不要选择使用内部晶振时钟
6-）注意事项
                        这样子装无线模块是错误的，因为天线下面就是电路，干扰很强，可以使用外置天线解决
                         1493448363_99624.png
                         1493448479_621266.png
                         1493448756_355916.png

如果是新制作的接收机，那么第一次开机就是等待对频状态；
使用金属物品，将接收机5/6通道相互连通在一起（就是把单片机5/6通的引脚短接），然后通电，也可以重新对频；
*如何判断等待对频状态：上电后LED直接高亮；
*如何判断已经对过频：上电时LED灯会闪一下再熄灭。如果此时遥控没有开机，2秒后会再亮；
*如何判断故障状态：上电时LED灯会快速闪烁。可能是无线模块接线不良或电源不稳；
*确认进入等待对频状态，遥控器选择对频，屏幕会显示通信成功。
*如果很长时间不能成功，那么不要折腾怎么对频了、对频怎么这么麻烦、到底怎么对频……(*>﹏<*)，这是电路出现问题，检查电路吧。

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

  5. //15系列新增寄存器
  6. sfr IAP_DATA=0xc2;
  7. sfr IAP_ADDRH=0xc3;
  8. sfr IAP_ADDRL=0xc4;
  9. sfr IAP_CMD=0xc5;
  10. sfr IAP_TRIG=0xc6;
  11. sfr IAP_CONTR=0xc7;

  13. sfr AUXR=0x8e;
  14. sfr T2H=0xd6;
  15. sfr T2L=0xd7;
  16. sfr IE2=0xaf;
  17. sfr P1ASF=0x9d;
  18. sfr ADC_CONTR=0xbc;
  19. sfr ADC_RES=0xbd;
  20. sfr ADC_RESL=0xbe;

  22. sfr P5=0xc8;
  23. sfr P0M0=0x94;
  24. sfr P1M0=0x92;
  25. sfr P2M0=0x96;
  26. sfr P3M0=0xb2;
  27. sfr P4M0=0xb4;
  28. sfr P1M1=0x91;

  30. sfr P_SW1   = 0xA2;             //外设功能切换寄存器1
  31. sfr CMOD=0xd9;
  32. sfr CCON=0xd8;
  33. sfr CCAPM1=0xdb;
  34. sfr CCAPM2=0xdc;
  35. sfr CCAP1L=0xeb;
  36. sfr CCAP2L=0xec;
  37. sfr CCAP1H=0xfb;
  38. sfr CCAP2H=0xfc;
  39. sfr CL=0xe9;
  40. sfr CH=0xf9;
  41. sfr PCA_PWM1=0xf3;
  42. sfr PCA_PWM2=0xf4;



  46. /**************************************************************************/
  47. //引脚定义
  48. sbit LED=P1^0;        //定义指示灯

  50. sbit CH1=P3^7;        //定义6个通道输出
  51. sbit CH2=P3^6;
  52. sbit CH3=P3^3;
  53. sbit CH4=P3^2;
  54. sbit CH5=P3^1;
  55. sbit CH6=P3^0;

  57. sbit MDO=P1^5;        //定义无线模块的管脚
  58. sbit SCK=P5^4;
  59. sbit CE=P5^5;
  60. sbit IRQ=P1^4;
  61. sbit MDI=P1^3;
  62. sbit CSN=P1^2;





  68. /**************************************************************************/

  70. u8 code random[100]={4,1,3,2,2,1,0,0,2,2,2,3,4,1,2,1,4,3,3,4,//随机跳频序列
  71.                                                                                  2,0,2,2,3,1,2,3,2,2,2,4,2,4,0,3,4,2,3,1,
  72.                                                                                  0,3,1,3,3,0,2,0,4,3,3,3,3,3,4,1,1,4,3,0,
  73.                            1,0,3,2,3,2,3,3,4,4,1,3,0,0,3,1,3,3,3,0,
  74.                            3,3,4,1,2,4,1,3,0,1,3,4,4,3,2,3,1,2,3,3};



  78.                                                                                        

  80. //无线通信
  81. u8 rx[11];                //接收的11字节数据
  82. u8 tx[11];
  83. u8 m;
  84. u8 hopping_turn,hopping_num,hopping_count;

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

  89. u8 hopping[5]={10,35,60,85,110};
  90. bit first,restar;
  91. bit connecting,lose;
  92. bit jump_1,jump_2,jump_mode;

  94. u8 NRF_error;


  97. u8 TX_power=3;



  101. //通道输出
  102. u16 timer1,timer2,timer3;
  103. u8 rx_num,receive;
  104. bit LED_flash;
  105. bit out_control_change;
  106. u16 idata out_control_data[8];

  108. u16 CH_data[8]={0,1024,0,1024,0,1024};
  109. u16 data buff[8];
  110. u16 temp1,temp2;
  111. u8 t_output;



  115. //电压检测
  116. u8 t_adc;
  117. u16 adc1,adc2;
  118. u16 voltage_bec,voltage_total;


  121. /**************************************************************************/
  122. //延时函数
  123. void Delay1ms()                //@12.000MHz
  124. {
  125.         unsigned char i, j;
  126.         i = 12;
  127.         j = 168;
  128.         do
  129.         {
  130.                 while (--j);
  131.         } while (--i);
  132. }

  134. void delay_ms(u8 i)
  135. {
  136.         while(i--)
  137.         Delay1ms();
  138. }

  140. /**************************************************************************/
  141. //ROM存储
  142. u8 EEPROM_read(u8 address)
  143. {
  144.         IAP_CMD=0x01;
  145.         IAP_ADDRH=0;
  146.         IAP_ADDRL=address;
  147.         IAP_TRIG=0x5a;                        
  148.         IAP_TRIG=0xa5;
  149.         return IAP_DATA;
  150. }

  152. void EEPROM_write(u8 address,u8 byte)
  153. {
  154.         IAP_CMD=0x02;
  155.         IAP_DATA=byte;
  156.         IAP_ADDRH=0;
  157.         IAP_ADDRL=address;
  158.         IAP_TRIG=0x5a;
  159.         IAP_TRIG=0xa5;
  160.         
  161. }

  163. void EEPROM_clean(u8 address)
  164. {
  165.         IAP_CMD=0x03;
  166.         IAP_ADDRH=0;
  167.         IAP_ADDRL=address;
  168.         IAP_TRIG=0x5a;
  169.         IAP_TRIG=0xa5;
  170. }

  172. void DATA_read()
  173. {
  174.         IAP_CONTR=0x82;
  175.         if((EEPROM_read(0)!=0xe4)||(EEPROM_read(1)!=0xa5))         
  176.         {
  177.            first=1;

  179.         }
  180.         else
  181.         {
  182.           hopping[0]=EEPROM_read(2);
  183.                 hopping[1]=EEPROM_read(3);
  184.                 hopping[2]=EEPROM_read(4);
  185.                 hopping[3]=EEPROM_read(5);
  186.                 hopping[4]=EEPROM_read(6);
  187.                 address[0]=EEPROM_read(7);
  188.                 address[1]=EEPROM_read(8);
  189.                 address[2]=EEPROM_read(9);
  190.                 address[3]=EEPROM_read(10);
  191.                 address[4]=EEPROM_read(11);
  192.         }
  193.         
  194.         if((EEPROM_read(12)!=0xe4)||(EEPROM_read(13)!=0xa5))         
  195.         {
  196.           out_control_data[0]=512;
  197.                 out_control_data[1]=512;
  198.                 out_control_data[2]=80;
  199.                 out_control_data[3]=512;
  200.                 out_control_data[4]=512;
  201.                 out_control_data[5]=512;
  202.                 out_control_data[6]=512;
  203.                 out_control_data[7]=512;

  205.         }
  206.         else
  207.         {
  208.                
  209.                 out_control_data[0]=EEPROM_read(14);
  210.                 out_control_data[0]<<=8;
  211.                 out_control_data[0]+=EEPROM_read(15);
  212.                 out_control_data[1]=EEPROM_read(16);
  213.                 out_control_data[1]<<=8;
  214.                 out_control_data[1]+=EEPROM_read(17);
  215.                 out_control_data[2]=EEPROM_read(18);
  216.                 out_control_data[2]<<=8;
  217.                 out_control_data[2]+=EEPROM_read(19);
  218.                 out_control_data[3]=EEPROM_read(20);
  219.                 out_control_data[3]<<=8;
  220.                 out_control_data[3]+=EEPROM_read(21);
  221.                 out_control_data[4]=EEPROM_read(22);
  222.                 out_control_data[4]<<=8;
  223.                 out_control_data[4]+=EEPROM_read(23);
  224.                 out_control_data[5]=EEPROM_read(24);
  225.                 out_control_data[5]<<=8;
  226.                 out_control_data[5]+=EEPROM_read(25);
  227.                 out_control_data[6]=EEPROM_read(26);
  228.                 out_control_data[6]<<=8;
  229.                 out_control_data[6]+=EEPROM_read(27);
  230.                 out_control_data[7]=EEPROM_read(28);
  231.                 out_control_data[7]<<=8;
  232.                 out_control_data[7]+=EEPROM_read(29);

  234.         }
  235.         

  237.         IAP_CONTR=0;
  238. }
  239. void DATA_save()
  240. {
  241.         IAP_CONTR=0x82;
  242.                 EEPROM_clean(0);
  243.                 EEPROM_write(0,0xe4);
  244.                 EEPROM_write(1,0xa5);
  245.                 EEPROM_write(2,hopping[0]);
  246.                 EEPROM_write(3,hopping[1]);
  247.                 EEPROM_write(4,hopping[2]);
  248.                 EEPROM_write(5,hopping[3]);
  249.                 EEPROM_write(6,hopping[4]);
  250.                 EEPROM_write(7,address[0]);
  251.                 EEPROM_write(8,address[1]);
  252.                 EEPROM_write(9,address[2]);
  253.                 EEPROM_write(10,address[3]);
  254.                 EEPROM_write(11,address[4]);
  255.         
  256.                 if(out_control_change)
  257.                 {
  258.                         EEPROM_write(12,0xe4);
  259.                         EEPROM_write(13,0xa5);
  260.                
  261.                         EEPROM_write(14,out_control_data[0]>>8);
  262.                         EEPROM_write(15,out_control_data[0]);
  263.                         EEPROM_write(16,out_control_data[1]>>8);
  264.                         EEPROM_write(17,out_control_data[1]);
  265.                         EEPROM_write(18,out_control_data[2]>>8);
  266.                         EEPROM_write(19,out_control_data[2]);
  267.                         EEPROM_write(20,out_control_data[3]>>8);
  268.                         EEPROM_write(21,out_control_data[3]);
  269.                         EEPROM_write(22,out_control_data[4]>>8);
  270.                         EEPROM_write(23,out_control_data[4]);
  271.                         EEPROM_write(24,out_control_data[5]>>8);
  272.                         EEPROM_write(25,out_control_data[5]);
  273.                         EEPROM_write(26,out_control_data[6]>>8);
  274.                         EEPROM_write(27,out_control_data[6]);
  275.                         EEPROM_write(28,out_control_data[7]>>8);
  276.                         EEPROM_write(29,out_control_data[7]);
  277.                 }
  278.         
  279.                
  280.                
  281.         
  282.         
  283.         
  284.                 IAP_CONTR=0;
  285. }
  286. /**************************************************************************/
  287. //NRF24L01
  288. u8 SPI(u8 byte)
  289. {
  290.         u8 i;
  291.         for(i=0;i<8;i++)
  292.         {
  293.                 MDI=(byte&0x80);
  294.                 SCK=1;
  295.                 byte<<=1;
  296.                 byte|=MDO;
  297.                 SCK=0;
  298.         }
  299.         return byte;
  300. }

  302. void REG_write(u8 address,u8 command)
  303. {
  304.         CSN=0;
  305.         SPI(0x20+address);
  306.         SPI(command);
  307.         CSN=1;
  308. }

  310. void FIFO_write(u8 DATA_OUT[],u8 lengh)
  311. {
  312.         u8 i;
  313.         CSN=0;
  314.         SPI(0xa0);
  315.         for(i=0;i<lengh;i++)
  316.         SPI(DATA_OUT[i]);
  317.         CSN=1;
  318. }
  319. void FIFO_read(u8 DATA_IN[],u8 lengh)                //读取接收数据缓冲区
  320. {
  321.         u8 i;
  322.         CSN=0;
  323.         SPI(0x61);        //读取命令
  324.         for(i=0;i<lengh;i++)
  325.         DATA_IN[i]=SPI(0);           
  326.         CSN=1;
  327. }

  329. void TX_address(u8 DATA_IN[])
  330. {
  331.         CSN=0;                 
  332.         SPI(0x20+0x10);
  333.         SPI(DATA_IN[0]);
  334.         SPI(DATA_IN[1]);
  335.         SPI(DATA_IN[2]);
  336.         SPI(DATA_IN[3]);
  337.         SPI(DATA_IN[4]);
  338.         CSN=1;  
  339. }  
  340. void RX_address(u8 DATA_IN[])
  341. {
  342.         CSN=0;                 
  343.         SPI(0x20+0x0a);
  344.         SPI(DATA_IN[0]);
  345.         SPI(DATA_IN[1]);
  346.         SPI(DATA_IN[2]);
  347.         SPI(DATA_IN[3]);
  348.         SPI(DATA_IN[4]);
  349.         CSN=1;  
  350. }
  351. void RX_mode()                                 
  352. {
  353.         CE=0;
  354.         REG_write(0x00,0x3b); //CRC,8 bit,Power on,RX
  355.         CE=1;
  356. }                                    
  357.         
  358. void TX_mode()                                 
  359. {
  360.         CE=0;
  361.         REG_write(0x00,0x0a);
  362.   CE=1;
  363. }

  365. void  NRF_power(u8 P)                                //发射功率设置 250k
  366. {                                                                                                               
  367.         CE=0;
  368.         if(P==3)REG_write(0x06,0x27);                  //0db 修正之前注释错误
  369.         else if(P==2)REG_write(0x06,0x25);          //-6db
  370.         else if(P==1)REG_write(0x06,0x23);          //-12db
  371.         else if(P==0)REG_write(0x06,0x21);    //-18db
  372.         CE=1;
  373. }

  375. void NRF_size(u8 l)
  376. {
  377.         CE=0;
  378.         REG_write(0x11,l);  
  379.         CE=1;
  380. }

  382. void NRF_channel(u8 c)
  383. {
  384.         CE=0;
  385.         REG_write(0x05,c);  
  386.         CE=1;
  387. }


  390. void NRF_init()
  391. {        
  392.         CE=0;
  393.         SCK=0;
  394.         REG_write(0x01,0x00); //禁止 自动应答
  395.         REG_write(0x02,0x01); //允许 P0信道
  396.         REG_write(0x04,0x00); //禁止 自动重发
  397.         RX_mode();                          
  398.         NRF_channel(66);
  399.         NRF_power(TX_power);
  400.         NRF_size(11);
  401.         RX_address(address);
  402.         TX_address(address);
  403. }

  405. void NRF_test()        //无线模块终极测试
  406. {        
  407.         u8 reset_err=0;
  408.         CE=0;
  409.         SCK=0;
  410.         CSN=0;
  411.         
  412.         if(SPI(0x20)!=0x0e){reset_err=1;}
  413.         SPI(0x0a);

  415.         CSN=1;

  417.         CSN=0;
  418.         SPI(0x00);

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

  423.         REG_write(0x01,0x00);
  424.         REG_write(0x04,0x00);
  425.         REG_write(0x11,1);
  426.         
  427.         FIFO_write(tx,1);
  428.         CE=1;

  430.         delay_ms(2);
  431.         
  432.         CSN=0;

  434.         if(SPI(0x00)!=0x2e){NRF_error|=0x04;}//CE bad
  435.         CSN=1;
  436.                
  437.         if(IRQ)NRF_error|=0x18;        //IRQ bad
  438.         else
  439.         {
  440.                 if(NRF_error&0x04==0)NRF_error|=0x10;                //MISO bad
  441.         }
  442.         CE=1;
  443.         
  444.         if(reset_err&&NRF_error>1)NRF_error|=0x01;//CSN,CLK bad
  445.         
  446.         REG_write(0x07,0x20);        //清除TX中断信号
  447. }

  449. /**************************************************************************/

  451. void data_check(int x,int max,int min)
  452. {
  453.         
  454.         if(x>max)x=max;
  455.         if(x<min)x=min;

  457. }

  459. void initial()
  460. {        
  461.         u8 t;
  462.         
  463.         CH5=0;                        //如果CH5与CH6被短接，重新对码
  464.         Delay1ms();
  465.         if(CH6==0)                  //修正通道6插上舵机不能用
  466.         {
  467.                 P3M0=0x02;          //插上舵机也会使CH6为0，所以将CH5设为推挽
  468.                 CH5=1;
  469.                 Delay1ms();
  470.                 if(CH6)restar=1;   //如果CH6被拉高，说明5/6通道短接，启动重新对码
  471.         }
  472.                  
  473.         LED=0;                //点亮指示灯再关闭，表示单片机正常工作
  474.         delay_ms(100);
  475.         P3M0=0xcf;         //四通接收机实际上是6通。
  476.         P1M1=0x02;        //将6通道输出IO口配置为大电流推挽模式，保证正常驱动电调与舵机
  477.         TMOD=0x01;        //允许两个定时器中断        
  478.         
  479.         if(restar)first=1;
  480.         DATA_read();
  481.         data_check(out_control_data[0],1023,0);
  482.         data_check(out_control_data[1],1023,0);
  483.         data_check(out_control_data[2],1023,0);
  484.         data_check(out_control_data[3],1023,0);
  485.         data_check(out_control_data[4],1023,0);
  486.         data_check(out_control_data[5],1023,0);
  487.         data_check(out_control_data[6],1023,0);
  488.         data_check(out_control_data[7],1023,0);
  489.         

  491.         NRF_test();
  492.         if(NRF_error)
  493.         {
  494.                 t=10;
  495.                 while(t)
  496.                 {
  497.                         LED=0;                //模块错误闪灯
  498.                         delay_ms(50);
  499.                         LED=1;                //模块错误闪灯
  500.                         delay_ms(50);
  501.                         t--;
  502.                 }
  503.         }
  504.         
  505.         NRF_init();

  507.         

  509.         
  510.         if(first)
  511.         {
  512.                 NRF_power(0);
  513.                 NRF_channel(33);
  514.                 TX_address(address_0);
  515.                 RX_address(address_0);
  516.                 while(IRQ);
  517.                 FIFO_read(rx,11);                //读取接收数据
  518.                 CE=0;
  519.                 REG_write(0x07,0x40);        //清除无线模块中断信号
  520.                 CE=1;
  521.                 if(rx[0]==0xa0)
  522.                 {
  523.                         hopping[0]=rx[1];
  524.                         hopping[1]=rx[2];
  525.                         hopping[2]=rx[3];
  526.                         hopping[3]=rx[4];
  527.                         hopping[4]=rx[5];
  528.                         address[0]=rx[6];
  529.                         address[1]=rx[7];
  530.                         address[2]=rx[8];
  531.                         address[3]=rx[9];
  532.                         address[4]=rx[10];
  533.                 }
  534.                
  535.                 tx[0]='O',tx[1]='K';
  536.                 connecting=1;
  537.                 while(connecting)
  538.                 {
  539.                         TX_mode();               
  540.                         NRF_channel(33);
  541.                         TX_address(address_0);
  542.                         RX_address(address_0);
  543.                         FIFO_write(tx,11);
  544.                         Delay1ms();
  545.                         
  546.                         RX_mode();
  547.                         NRF_channel(hopping[0]);
  548.                         TX_address(address);
  549.                         RX_address(address);
  550.                         while(1)
  551.                         {
  552.                                 Delay1ms();
  553.                                 if(IRQ==0)
  554.                                 {
  555.                                         FIFO_read(rx,11);                //读取接收数据
  556.                                         CE=0;
  557.                                         REG_write(0x07,0x40);        //清除无线模块中断信号
  558.                                         CE=1;         
  559.                                         connecting=0;break;
  560.                                 }
  561.                                 t++;if(t>100){t=0;break;}
  562.                         }                          
  563.                 }
  564.                         DATA_save();
  565.         RX_address(address);
  566.         TX_address(address);
  567.         NRF_power(3);
  568.         }
  569.         
  570. }

  572.                                                                                                                                              

  574. main()
  575. {        
  576.         delay_ms(200);delay_ms(200);//开机延时以避过电源波动
  577.         
  578.         initial();
  579.         ADC_CONTR=0x80;                 //ADC配置

  581.                   
  582.         IP=0x02;
  583.         IE=0x82;
  584.         IE2=0x04;
  585.         
  586.         T2L=0x47,T2H=0xf4;
  587.         AUXR=0x10;           //打开定时器2，开始统计信号

  589.         
  590.         NRF_channel(hopping[0]);
  591.         
  592.         
  593.         while(IRQ);
  594.         TR0=1;
  595.         lose=1;
  596.         LED=1;
  597.         while(1)
  598.         {        
  599.                 while(IRQ&lose);
  600.                 if(lose)
  601.                 {        
  602.                         jump_1=0;jump_2=0;hopping_count=0;//收到有效信号后刷新跳频器
  603.                         receive++;timer1=0;timer3=0;m=0;               
  604.                         
  605.                         FIFO_read(rx,11);                //读取接收数据
  606.                         CE=0;
  607.                         REG_write(0x07,0x40);        //清除无线模块中断信号
  608.                         CE=1;
  609.                         
  610.                         TX_mode();
  611.                         tx[0]=rx_num;
  612.                         voltage_bec=32385/adc1;
  613.                         tx[1]=voltage_bec>>8;
  614.                         tx[2]=voltage_bec;
  615.                         voltage_total=(long)adc2*voltage_bec*3/1024;
  616.                         tx[3]=voltage_total>>8;
  617.                         tx[4]=voltage_total;
  618.                         
  619.                         FIFO_write(tx,11);
  620.                         Delay1ms();

  622.                         RX_mode();
  623.                                                 
  624.                         if(jump_mode)
  625.                         {
  626.                                 jump_mode=0;
  627.                                 hopping_turn=random[hopping_num];
  628.                         }
  629.                         hopping_turn++;
  630.                         if(hopping_turn>4)hopping_turn=0;
  631.                         NRF_channel(hopping[hopping_turn]);
  632.                         



  636.                         if(rx[0]==0xa0)
  637.                         {
  638.                                 LED_flash=1,LED=0;
  639.                                 buff[0]=rx[1];
  640.                                 buff[0]<<=2;
  641.                                 buff[0]+=rx[2]>>6;
  642.                                 buff[1]=rx[2]&0x3f;
  643.                                 buff[1]<<=4;
  644.                                 buff[1]+=rx[3]>>4;                        
  645.                                 buff[2]=rx[3]&0x0f;
  646.                                 buff[2]<<=6;
  647.                                 buff[2]+=rx[4]>>2;
  648.                                 buff[3]=rx[4]&0x03;
  649.                                 buff[3]<<=8;
  650.                                 buff[3]+=rx[5];

  652.                                 buff[4]=rx[6];
  653.                                 buff[4]<<=2;
  654.                                 buff[4]+=rx[7]>>6;
  655.                                 buff[5]=rx[7]&0x3f;
  656.                                 buff[5]<<=4;
  657.                                 buff[5]+=rx[8]>>4;                        
  658.                                 buff[6]=rx[8]&0x0f;
  659.                                 buff[6]<<=6;
  660.                                 buff[6]+=rx[9]>>2;
  661.                                 buff[7]=rx[9]&0x03;
  662.                                 buff[7]<<=8;
  663.                                 buff[7]+=rx[10];
  664.                                 
  665.                                 
  666.                                 data_check(buff[0],1023,0);
  667.                                 data_check(buff[1],1023,0);
  668.                                 data_check(buff[2],1023,0);
  669.                                 data_check(buff[3],1023,0);
  670.                                 data_check(buff[4],1023,0);
  671.                                 data_check(buff[5],1023,0);
  672.                                 data_check(buff[6],1023,0);
  673.                                 data_check(buff[7],1023,0);
  674.                                 
  675.                                 out_control_data[0]=buff[0];
  676.                                 out_control_data[1]=buff[1];
  677.                                 out_control_data[2]=buff[2];
  678.                                 out_control_data[3]=buff[3];
  679.                                 out_control_data[4]=buff[4];
  680.                                 out_control_data[5]=buff[5];
  681.                                 out_control_data[6]=buff[6];
  682.                                 out_control_data[7]=buff[7];
  683.                                 
  684.                                 out_control_change=1;
  685.                                 DATA_save();
  686.                                 out_control_change=0;
  687.                                 
  688.                         }
  689.                         else if(rx[0]==0xa1)
  690.                         {
  691.                                 buff[0]=rx[1];
  692.                                 buff[0]<<=2;
  693.                                 buff[0]+=rx[2]>>6;
  694.                                 buff[1]=rx[2]&0x3f;
  695.                                 buff[1]<<=4;
  696.                                 buff[1]+=rx[3]>>4;                        
  697.                                 buff[2]=rx[3]&0x0f;
  698.                                 buff[2]<<=6;
  699.                                 buff[2]+=rx[4]>>2;
  700.                                 buff[3]=rx[4]&0x03;
  701.                                 buff[3]<<=8;
  702.                                 buff[3]+=rx[5];

  704.                                 buff[4]=rx[6];
  705.                                 buff[4]<<=2;
  706.                                 buff[4]+=rx[7]>>6;
  707.                                 buff[5]=rx[7]&0x3f;
  708.                                 buff[5]<<=4;
  709.                                 buff[5]+=rx[8]>>4;                        
  710.                                 buff[6]=rx[8]&0x0f;
  711.                                 buff[6]<<=6;
  712.                                 buff[6]+=rx[9]>>2;
  713.                                 buff[7]=rx[9]&0x03;
  714.                                 buff[7]<<=8;
  715.                                 buff[7]+=rx[10];
  716.                                 
  717.                                 
  718.                                 data_check(buff[0],1023,0);
  719.                                 data_check(buff[1],1023,0);
  720.                                 data_check(buff[2],1023,0);
  721.                                 data_check(buff[3],1023,0);
  722.                                 data_check(buff[4],1023,0);
  723.                                 data_check(buff[5],1023,0);
  724.                                 data_check(buff[6],1023,0);
  725.                                 data_check(buff[7],1023,0);
  726.                                 
  727.                                 CH_data[0]=buff[0];
  728.                                 CH_data[1]=buff[1];
  729.                                 CH_data[2]=buff[2];
  730.                                 CH_data[3]=buff[3];
  731.                                 CH_data[4]=buff[4];
  732.                                 CH_data[5]=buff[5];
  733.                                 CH_data[6]=buff[6];
  734.                                 CH_data[7]=buff[7];                                
  735.                         }
  736.                         
  737.                         


  740.                 }
  741.                 else
  742.                 {
  743.                          hopping_count++;
  744.                         if(hopping_count>5)jump_mode=1;
  745.                         
  746.                         if(jump_mode)
  747.                         {
  748.                                 hopping_num++;
  749.                                 if(hopping_num>99)hopping_num=0;
  750.                                 NRF_channel(hopping[random[hopping_num]]);
  751.                                 lose=1;
  752.                         }
  753.                         else
  754.                         {
  755.                                 hopping_turn++;
  756.                                 if(hopping_turn>4)hopping_turn=0;
  757.                                 NRF_channel(hopping[hopping_turn]);
  758.                                 lose=1;
  759.                         }
  760.                         
  761.                 }
  762.                
  763.         }
  764.         
  765. }


  768. void et0()interrupt 1                //定时器0用作信号输出        
  769. {
  770. TR0=0;
  771.         t_output++;
  772.         switch(t_output)
  773.         {
  774.                
  775.                 case 1:CH1=1;temp1=64750-CH_data[0]*27/20;
  776.                                                 TL0=temp1,TH0=temp1>>8;break;
  777.                                                 
  778.                
  779.                 case 2:CH1=0;temp2=128500-temp1;
  780.                                                 TL0=temp2,TH0=temp2>>8;break;
  781.                 case 3:CH2=1;temp1=64750-CH_data[1]*27/20;
  782.                                                 TL0=temp1,TH0=temp1>>8;break;
  783.                                                 
  784.                                                 
  785.                 case 4:CH2=0;temp2=128500-temp1;
  786.                                                 TL0=temp2,TH0=temp2>>8;break;
  787.                 case 5:CH3=1;temp1=64750-CH_data[2]*27/20;
  788.                                                 TL0=temp1,TH0=temp1>>8;break;
  789.                 case 6:CH3=0;temp2=128500-temp1;
  790.                                                 TL0=temp2,TH0=temp2>>8;break;
  791.                 case 7:CH4=1;temp1=64750-CH_data[3]*27/20;
  792.                                                 TL0=temp1,TH0=temp1>>8;break;
  793.                 case 8:CH4=0;temp2=128500-temp1;
  794.                                                 TL0=temp2,TH0=temp2>>8;break;
  795. ……………………

  797. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
0.png
所有程序51hei提供下载:
萝丽新版6通接收机A版程序.rar (4.53 KB, 下载次数: 187)

评分

参与人数 2黑币 +20 收起 理由
475345347 + 5 绝世好帖！
GUOXUAN + 15 给新来的老师以奖分鼓励!

查看全部评分

回复

使用道具 举报

ID:1 发表于 2017-6-3 02:56 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:196311 发表于 2017-6-3 15:56 | 显示全部楼层
就提供接收机代码和发射器图纸，其他配套资料怎么没上来
回复

使用道具 举报

ID:257847 发表于 2017-12-5 19:30 | 显示全部楼层
支持楼主！
回复

使用道具 举报

ID:249545 发表于 2017-12-5 20:38 | 显示全部楼层
支持楼主共享如此雄伟的DIY资料!
回复

使用道具 举报

ID:255989 发表于 2017-12-5 21:01 | 显示全部楼层
LZ强人呀。12通的。想想我就歇菜了！
回复

使用道具 举报

ID:254584 发表于 2018-4-23 16:13 | 显示全部楼层
谢谢分享
回复

使用道具 举报

ID:254251 发表于 2018-4-27 22:37 | 显示全部楼层
有时间拿来试一下谢谢分享
回复

使用道具 举报

ID:138282 发表于 2018-4-27 22:51 | 显示全部楼层
这谁发的？有没经过群主同意啊
回复

使用道具 举报

ID:79544 发表于 2018-9-26 18:20 | 显示全部楼层
程序下载进去指示灯没反应？
回复

使用道具 举报

ID:399179 发表于 2018-9-27 07:51 来自手机 | 显示全部楼层
等学会了试试
回复

使用道具 举报

ID:79544 发表于 2018-9-27 17:46 | 显示全部楼层
今天搞定12通道萝莉飞控和接收机。对频成功
回复

使用道具 举报

ID:55211 发表于 2018-10-16 09:37 | 显示全部楼层
喜欢航模的可以参考diy
回复

使用道具 举报

ID:280736 发表于 2018-11-13 12:49 | 显示全部楼层
谢谢！学习了！
回复

使用道具 举报

ID:272906 发表于 2019-9-13 10:50 | 显示全部楼层
具体怎么连线的？
回复

使用道具 举报

ID:619608 发表于 2019-10-5 22:22 | 显示全部楼层
解压后怎么没有原理图，只有C文件还不知道能不能用?
回复

使用道具 举报

ID:563109 发表于 2019-10-14 20:25 | 显示全部楼层
没有其他的吗
回复

使用道具 举报

ID:626287 发表于 2019-10-18 20:08 | 显示全部楼层
这个很火啊！！
回复

使用道具 举报

ID:613618 发表于 2019-10-24 14:22 来自手机 | 显示全部楼层
带发射机做成一套就更好了
回复

使用道具 举报

ID:622823 发表于 2019-11-23 19:48 | 显示全部楼层
这个萝莉控本来就是开源的  百度一下什么都有了。
回复

使用道具 举报

ID:469607 发表于 2020-1-12 17:32 | 显示全部楼层
谢谢楼主分享
回复

使用道具 举报

ID:308570 发表于 2020-9-3 16:19 | 显示全部楼层
萝莉的遥控通用吗？
回复

使用道具 举报

ID:718620 发表于 2021-1-23 15:54 来自手机 | 显示全部楼层
POPLAND 发表于 2019-10-5 22:22
解压后怎么没有原理图，只有C文件还不知道能不能用?

通过程序可以看出来外围电路
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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