单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

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

四路学习型315m无线开关单片机程序 因能学习到一种阻值信号学习不到其他 阻值的遥控

[复制链接]
回帖奖励 10 黑币 回复本帖可获得 10 黑币奖励! 每人限 1 次
跳转到指定楼层
楼主
ll13536121668 发表于 2019-9-12 15:58 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
四路学习型315m无线开关  因能学习到一种阻值信号学习不到其他    阻值的遥控

现在走到一款,自适应多阻值实现2262、1527解码,学习的,测试过支持很多阻值的遥控,把两个程序上传给大家看看什样把解码移值到现在这个,四路学习型315m无线开关程序,上传给大家看看什样修改,上传谢谢大家

单片机源程序如下:
  1. /**************************************************************************/

  2.       //-----------------兼容2262 1527的解码实验程序----------------//

  3. //测试单片机:兼容STC全系

  4. //晶振:11.0592M (外部)

  5. //复位方式:内部复位
  6.                      
  7. //串口通讯:波特率9600/数据位8/停止位1/无校验

  8. //调试环境:KEIL4

  9. //程序功能:实现2262、1527解码,学习、自适应多阻值,片内EEPROM,存储60个遥控器数据
  10.         
  11. //          不依赖硬件,不占用硬件资源。移植更加方便

  12. //                        学习遥控器:按一下学习键,学习灯点亮,松开学习键,按动要学习的遥控器按键,学习灯熄灭,学习成功。重复上述操作可学习多个遥控器.
  13. //
  14. //          清除:按住学习键不放,直到学习灯自动熄灭,擦除成功.

  15. /**********************************************************/


  16. #include <STC15W408AS.h>
  17. #include <intrins.h>                                                        
  18. #define uchar unsigned char
  19. #define uint  unsigned int


  20. sbit RF                           =        P1^1;           //信号输入
  21. sbit LED                =        P1^0;           //学习指示灯
  22. sbit set                 =        P3^5;           //学习键                                                         
  23. sbit D0                        =        P3^6;          //解码输出
  24. sbit D1                        =        P3^7;
  25. sbit D2                        =        P3^3;
  26. sbit D3                        =        P3^2;
  27. sbit VT                        =        P1^7;         //解码指示灯                        
  28.                         

  29. bit  decode_ok;                 //解码成功
  30. bit rf_ok;               //收到有效数据
  31. bit study;         //学习标志
  32. bit jmnx;  //编码类型 0是2262,1是1527
  33. uchar da1527[2][3];  //解码过程中临时数组
  34. uchar key_d;  //遥控器按键码
  35. uchar short_k;     //窄脉冲宽度


  36. uchar idata key_number[181];                //遥控器编码数组,存放60个遥控器


  37. void delay_1ms(uint x)    //1毫秒延时
  38. {
  39.         uchar b,c;
  40.         for(x;x>0;x--)
  41.                 {
  42.                         for(b=3;b>0;b--)
  43.                                 {
  44.                                         for(c=150;c>0;c--);
  45.                                 }
  46.                 }
  47. }

  48. void delay(uint ms)//
  49. {
  50.   while(ms--)
  51.     {
  52.          ms++;

  53.          ms--;
  54.     }
  55. }

  56. //====================================================
  57. /////////片内EEPROM读写驱动程序///////////////////////////
  58. //====================================================


  59. void IAP_Disable()           //关闭IAP
  60. {
  61.     //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  62.     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  63.     IAP_CONTR = 0;      //关闭IAP 功能
  64.     IAP_CMD   = 0;      //清命令寄存器,使命令寄存器无命令,此句可不用
  65.     IAP_TRIG = 0;      //清命令触发寄存器,使命令触发寄存器无触发,此句可不用
  66.     IAP_ADDRH = 0;
  67.     IAP_ADDRL = 0;
  68. }//



  69. //读一字节,调用前需打开IAP 功能,入口:DPTR = 字节地址,返回:A = 读出字节
  70. uchar read_add(uint addr)         //读EEPROM
  71. {
  72.     IAP_DATA = 0x00;
  73.     IAP_CONTR = 0x84;         //打开IAP 功能, 设置Flash 操作等待时间
  74.     IAP_CMD = 0x01;                 //IAP/ISP/EEPROM 字节读命令

  75.     IAP_ADDRH = addr>>8;    //设置目标单元地址的高8 位地址
  76.     IAP_ADDRL = addr&0xff;    //设置目标单元地址的低8 位地址

  77.     EA = 0;
  78.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  79.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  80.     _nop_();
  81.     EA = 1;
  82.     IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  83.                     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  84.     return (IAP_DATA);
  85. }//------------------------------------------------------------------------------


  86. //字节编程,调用前需打开IAP 功能,入口:DPTR = 字节地址, A= 须编程字节的数据
  87. void write_add(uint addr,uchar ch)         //直接写EEPROM
  88. {
  89.     IAP_CONTR = 0x84;         //打开 IAP 功能, 设置Flash 操作等待时间
  90.     IAP_CMD = 0x02;                 //IAP/ISP/EEPROM 字节编程命令


  91.     IAP_ADDRH = addr>>8;    //设置目标单元地址的高8 位地址
  92.     IAP_ADDRL = addr&0xff;    //设置目标单元地址的低8 位地址

  93.     IAP_DATA = ch;                  //要编程的数据先送进IAP_DATA 寄存器
  94.     EA = 0;
  95.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  96.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  97.     _nop_();
  98.     EA = 1;
  99.     IAP_Disable(); //关闭IAP 功能, 清相关的特殊功能寄存器,使CPU 处于安全状态,
  100.                     //一次连续的IAP 操作完成之后建议关闭IAP 功能,不需要每次都关
  101. }//------------------------------------------------------------------------------
  102. //擦除扇区, 入口:DPTR = 扇区地址


  103. void Sector_Erase(uint addr)         //扇区擦除
  104. {
  105.      IAP_CONTR = 0x84;         //打开IAP 功能, 设置Flash 操作等待时间
  106.     IAP_CMD = 0x03;                 //IAP/ISP/EEPROM 扇区擦除命令

  107.     IAP_ADDRH =addr>>8;    //设置目标单元地址的高8 位地址
  108.     IAP_ADDRL =addr&0xff;    //设置目标单元地址的低8 位地址

  109.     EA = 0;
  110.     IAP_TRIG = 0x5a;   //先送 46h,再送B9h 到ISP/IAP 触发寄存器,每次都需如此
  111.     IAP_TRIG = 0xa5;   //送完 B9h 后,ISP/IAP 命令立即被触发起动
  112.     _nop_();
  113.     EA = 1;
  114. }//------------------------------------------------------------------------------



  115. //============================接收解码部分========================================//

  116. void RF_decode()         
  117. {
  118.            uchar ii=0,j=0,k=0,rep=0;
  119.             uint head_k=0;           //短脉冲宽度
  120.           uchar s;   
  121. //-------------------------------数据接收-----------------------------------------
  122.       short_k=0;
  123.           while(RF && j<250)         //检测头信号前一个高脉冲的宽度
  124.                    {
  125.                          delay(1);        
  126.                         short_k++;
  127.                  }
  128.           while(!RF)
  129.                    {
  130.                          delay(1);
  131.                         head_k++;
  132.                  } //检测头脉冲的宽度         
  133.       if(((short_k*24)<head_k) && (head_k<(short_k*38)))   //引导码宽度是窄脉冲的32倍 24/38
  134.          {        
  135.             for(rep=0;rep<2;rep++)         
  136.                {  
  137.                              for(ii=0;ii<3;ii++)//3字节
  138.                              {
  139.                                    for(k=0;k<8;k++)//每个字节8位
  140.                                       {                                      
  141.                                                     j=0;
  142.                                                         while(RF && j<245)
  143.                                                                 {
  144.                                                                         delay(1);
  145.                                                                         j++;
  146.                                                                 }//
  147.                                                if(j>(short_k-short_k/2-short_k/3)&&j<(short_k*1.96))
  148.                                                                 {
  149.                                                                         da1527[rep][ii]&=~(1<<((7-k)));
  150.                                                                 }                                    
  151.                                                         else if(j>(short_k*1.96)&&j<(short_k*5))da1527[rep][ii]|=(1<<(7-k));                                                
  152.                                                 else {return;}          //乱码退出        
  153.                                                j=0;
  154.                                                         while(!RF && j<150){delay(2);j++;}      //跳过低电平                                   
  155.                                                  }
  156.                                  }//for(ii=0;ii<12;ii++)  
  157.                    j=0;while(RF && (j<200)){delay(1);j++;}            //跳个最后一个高脉冲                           
  158.                                head_k=0;while(!RF) {delay(1);head_k++;} //检测下一个前导信号的寬度  
  159.                                if((head_k<(short_k*26)) || (head_k>(short_k*38)))  {return;} //引导码宽度是窄脉冲的32倍  //乱码退出
  160.                            }
  161.             //+++++++++++++++++++++++++2262与1527数据分离处理++++++++++++++++++++++++++++++++++++++++              
  162.                          if((da1527[0][0]==da1527[1][0]) && (da1527[0][1]==da1527[1][1]) && (da1527[0][2]==da1527[1][2]))        //两次接收到的数据相同
  163.                       {         
  164.                      uchar u,i,x;
  165.                                          rf_ok=1;
  166.                                          for(i=0;i<3;i++)  //判定2262与1527
  167.                         {
  168.                            for(u=0;u<4;u++) {if(((da1527[0][i]>>(u*2)) & 3)==2) {i=80;break;}}  //有10则为1527
  169.                                                    if(i==80) break;
  170.                         }
  171.                      if(i==80)  //1527
  172.                         {
  173.                           key_d=da1527[1][2] & 0x0f;         //分出1527的按键值
  174.                           da1527[0][2]=da1527[1][2]>>4; //分出1527的后4位地址
  175.                                                   jmnx=1;         //为0是2262,1是1527
  176.                         }
  177.                        else      //2262
  178.                          {
  179.                           key_d=0;
  180.                           for(i=0;i<4;i++){if(((da1527[0][2]>>(i*2))&3)==3) key_d|=1<<i;}   //计算出2262的按键数据                                 
  181.                           da1527[0][2]=00; //2262无后4位地址,全为0
  182.                                                   jmnx=0;         //为0是2262,1是1527
  183.                          }
  184.                                                    
  185.                                           if (!study)                //非学习状态
  186.                                                   {
  187.                                                         rf_ok=0;
  188.                                                         for(x=0;x<60;x++)
  189.                                                                    {
  190.                                                                         if((da1527[0][0]==key_number[x*3+1])&&(da1527[0][1]==key_number[x*3+2])
  191.                                                                                                                                         &&(da1527[0][2]==key_number[x*3+3]))//判断是否已学习过的编码
  192.                                                                                 {
  193.                                                                     D0=!(key_d&0x08);                //取得按键码
  194.                                                                                         D1=!(key_d&0x04);
  195.                                                                                         D2=!(key_d&0x02);
  196.                                                                                         D3=!(key_d&0x01);
  197.                                                                                                                                                                                 
  198.                                                                                         decode_ok=1;
  199.                                                                                         VT=0;                                                               
  200.                                                                                         s=100;
  201.                                                                                         break;
  202.                                                                                 }
  203.                                                                                                                
  204.                                                                 }        
  205.                                                 
  206.                                                 
  207.                                                 }

  208.                  }
  209.               
  210.          }
  211.         if(decode_ok)   //解码有效信号,类似2272 PT脚
  212.                   {
  213.                         s--;
  214.                         if(!s)
  215.                                 {
  216.                                         decode_ok=0;
  217.                                         VT=1;
  218.                                 }                                 
  219.                   }         
  220.                                  
  221.                   
  222. }

  223. void key_buffer()                  //把遥控器码从 EEPROM 复制到DATA
  224. {
  225.         uchar n;

  226.         for(n=0;n<181;n++)
  227.                 {
  228.                    key_number[n]=read_add(0x0000+n);                        
  229.                 }
  230. }

  231. void KEY_study()        //遥控器学习
  232. {        
  233.         uchar num_rf;
  234.         uint d_num;
  235.         if(study)
  236.                 {
  237.                            rf_ok=0;
  238.                         d_num=0;
  239.         
  240.                         while(!rf_ok)
  241.                                 {
  242.                                         RF_decode();
  243.                                         d_num++;
  244.                                         if(d_num>50000) break;                                                                        
  245.                                 }
  246.                         d_num=0;
  247.                         if(rf_ok==1)
  248.                                 {

  249.                                         num_rf=key_number[0];                   //取已学习的遥控器数量
  250.                                         if(num_rf>60){num_rf=0;}        //如果遥控器数量超过10个,覆盖最先学习的
  251.                                         key_number[num_rf*3+1]=da1527[0][0];
  252.                                         key_number[num_rf*3+2]=da1527[0][1];
  253.                                         key_number[num_rf*3+3]=da1527[0][2];
  254.                                         key_number[0]=num_rf+1;

  255.                                         Sector_Erase(0x0000);
  256.                                         for(num_rf=0;num_rf<181;num_rf++)
  257.                                                 {
  258.                                                         write_add(0x0000+num_rf,key_number[num_rf]);
  259.                                                         
  260.                                                 }
  261.                                         rf_ok=0;
  262.                                         LED=1;                   //学习成功                                       
  263.                                   }        
  264.                                 else
  265.                                         {
  266.                                                 rf_ok=0;

  267.                                                 for(num_rf=0;num_rf<8;num_rf++)                   //操作超时
  268.                                                         {
  269.                                                                 LED=!LED;
  270.                                                                 delay_1ms(100);                                                        
  271.                                                         }
  272.                                                  LED=1;
  273.                                        
  274.                                         }
  275.                         d_num=0;
  276.                         study=0;                 
  277.                 }
  278. }

  279. void system_res()  //系统清零           
  280. {
  281.         
  282.           Sector_Erase(0x0000);        
  283.         write_add(0x0000,0x00);        
  284.         key_buffer();               

  285. }

  286. void set_scan()          //判断学习键状态
  287. {
  288.   uchar h=0;

  289.   while(!set)         
  290.         {                        
  291.                 if(h>5)
  292.                         {
  293.                                 study=1;
  294.                                 h=0;
  295.                                 LED=0;
  296.                                 while(!set)
  297.                                         {
  298.                                           delay_1ms(100);
  299.                                           h++;
  300.                                           if(h>80)
  301.                                                   {
  302.                                                            study=0;
  303.                                                         h=0;
  304.                                                         system_res();
  305.                                                         LED=1;
  306.                                                         while(!set);
  307.                                                 }
  308.                                        
  309.                                         }
  310.                         }
  311.                  delay_1ms(100);
  312.                   h++;
  313.          }                                                                                
  314.   if(study)
  315.                 {
  316.                         KEY_study();
  317.                 }         
  318. }






  319. void system_start()   //上电初始化
  320. {        
  321.          AUXR=0xb5;   
  322.          P0=0xfe;
  323.         P1=0xff;
  324.           P3=0xff;
  325.         key_buffer();
  326. }

  327. void main()
  328. {
  329.   system_start();

  330.   while(1)
  331.         {
  332.                 RF_decode();
  333.                 set_scan();

  334.         }  

  335. }
复制代码

2262-1527解码程序.rar

52。96 KB, 下载次数: 2

四路学习型315m无线开关.rar

59.37 KB, 下载次数: 2

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 转播转播 分享分享 分享淘帖 顶 踩
沙发
yong761228 发表于 2019-9-13 22:03 | 只看该作者
我测试了一下“2262-1527解码程序”这个程序,震荡电阻4.7M 遥控器对码不成功,2.2M可以。抱歉了,我的水平有限,帮不了楼主。
板凳
yong761228 发表于 2019-9-14 07:18 | 只看该作者
楼主,“2262-1527解码程序.rar” 我设置成6M 晶振,4.7M,2.2M电阻都可以控制,“四路学习型315m无线开关.rar” 我的单片机STC15W204空间不够没法测试,它是采用外部中断来解码的。真希望有高手可以改成外部中断解码,我也谢谢。
地板
51黑科技1314 发表于 2019-9-14 17:39 | 只看该作者
我测试了一下“2262-1527解码程序”这个程序,我把晶振改成了6M 晶振,4.7M,2.2M电阻都可以控制,我用STM32L053没做出来 实在抱歉,水平有限,勿怪
5#
 楼主| ll13536121668 发表于 2019-9-14 22:05 来自手机 | 只看该作者
yong761228 发表于 2019-9-13 22:03
我测试了一下“2262-1527解码程序”这个程序,震荡电阻4.7M 遥控器对码不成功,2.2M可以。抱歉了,我的水平 ...

师傅你好:能用2262-1527解码程序的解码,修改移植到四路学习型315m开关程序吗,修改上传谢谢
6#
yong761228 发表于 2019-9-15 07:27 | 只看该作者
ll13536121668 发表于 2019-9-14 22:05
师傅你好:能用2262-1527解码程序的解码,修改移植到四路学习型315m开关程序吗,修改上传谢谢

抱歉了,没有这水平,四路学习型315m开关程序采用的是外部中断方法,只能看看哪位高人能不能把“2262-1527解码程序” 改成外部中断方法。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

|手机版|小黑屋|单片机论坛 |51Hei单片机16群 联系QQ:125739409;技术交流QQ群7344883

Powered by 单片机教程网

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