精华内容
下载资源
问答
  • 本文介绍了一种新型的无线编码芯片EV1527在无线发射模块中的应用及其相应解码方法在无线接收...其次提出了两种解码方法:利用解码芯片TDH6300硬件解码、采用单片机软件解码;最后系统地阐述了这种编解码方案的应用。
  • 射频遥控芯片EV1527解码方法

    热门讨论 2011-05-21 21:19:03
    该资源介绍了EV1527的两种解码方式:硬件解码采用TDH6300实现,含硬件原理图与时序分析;软件解码可以采用单片机实现。
  • EV1527学习码解码芯片

    2016-06-23 11:14:28
    TCT6227 是针对市面上的常见的固定码遥控器的解码应用所设计的4路学习型解码IC, 兼容市面上的常见的固定码编码芯片,包括EV1527、PT2262、HX2262、SC2260、SC5211等。PT2262类型编码支持8位三态地址。
  • 基于STM32F103 的解码程序 使用定时器检测EV1527编码
  • STM8解码EV1527

    2016-01-21 11:50:28
    基于STM8解码编码芯片EV1527的信号,接受端IC使用的是SYN480,可以用其他接受IC,然后用STM8解码。代码有注释,方便查看使用修改。
  • STM32F103芯片解码EV1527,模块用的是凌承的H3V4F无线结合接收模块,源码也是来自网络用的是标准库,本人改为Hal库实现,CUBE生成代码,用的IO引脚可直观的看到,解码思想还是别人的,感谢万能的互联网,共同进步!
  • EV1527资料

    2013-04-01 10:15:15
    EV1527编码芯片的应用及其解码方法 本文介绍了一种新型的无线编码芯片EV1527在无线发射模块中的...其次提出了两种解码方法:利用解码芯片TDH6300硬件解码、采用单 片机软件解码;最后系统地阐述了这种编解码方案的应用。
  • 编码芯片EV1527射频学习

    万次阅读 2016-05-24 10:33:44
    利用解码芯片TDH6300硬件解码、采用单片机软件解码。 EV1527是一片由CMOS设计制造的可预烧内码的学习码编码芯片,由软件解码。 内码共有20位元可预烧100万组内码组合,大大降低了使用编码上重复的机率。 ...



    编码芯片EV1527:
    有两种解码方法:
    利用解码芯片TDH6300硬件解码、采用单片机软件解码。


    EV1527是一片由CMOS设计制造的可预烧内码的学习码编码芯片,由软件解码。
    内码共有20位元可预烧100万组内码组合,大大降低了使用编码上重复的机率。


    第4脚就输入相应的数据串,它通过放大器和振荡电路发射出去:
    信号的频率由第1脚上的电阻和低2引脚上的电源电压共同决定。


    振荡频率的选定


    振荡电路是无线模块的一个重要组成部分,无线发射模块和接收模块的频率必须匹配。
    EV1527可根据电压和振荡电阻的匹配情况来确定其振荡频率,电压越高,频率越大,电阻越大频率越小。


    展开全文
  • 无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 hs1527、ev1527、rt1527、fp1527、PT2262 为代表。另一种是滚动码,芯片的地址码是变化的,芯片以HS300、HS...

    1527的数据帧结构
    无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 hs1527、ev1527、rt1527、fp1527、PT2262 为代表。另一种是滚动码,芯片的地址码是变化的,芯片以HS300、HS301为代表。

    1 1527 数据帧结构
    1527 是一片由 CMOS 设计制造的可预烧内码的学习码编码IC ,由软件解码;内码共有 20 个位元可预烧 1048576 组内码组合,降低使用上编码重复的机率。
    1527 每帧数据由 24 个数据位组成,前 20 位为地址码,对于一个芯片来说,地址位的内容是固定的,是出厂前就预制好的,并且理论上每个芯片的地址码是唯一的。后面 4 位为按键码,对应芯片上的K0-K3 4 根数据线,数据线的状态不同,按键码就不同。
    在数据位之前,还有一个同步脉冲,也就是每帧数据都是从同步
    脉冲开始的。数据位的“1”和“0”是由高低电平宽度(脉冲宽度)的比例决定的。如果高电平宽度为低电平宽度的 3 倍,就表示逻辑“1”,反过来如果低电平为高电平宽度的 3 倍,就表示逻辑“0”。同步脉冲高电平和低电平的比例固定为 4:124.
    1527时序
    这里写图片描述
    这里写图片描述
    这里写图片描述

    二、中断方式的解码
    把串行输入的编码数据帧,还原成编码之前的状态,读取其中
    的地址码和按键码,称之为解码。
    数据帧都是由同步头开始,然后是 24位的数据码,并且此数据帧在遥控器按键的过程中是重复出现的,我们首先要判断同步码,判断出了同步码,就知道数据码是从那一位开始了。对于一款量产的无线遥控器来说,他的编码芯片匹配的电阻是一个固定值,也就是说它发射的数据帧的脉冲宽度是不变的,所以我们可以通过测量高低脉冲宽度的方式来分辨同步码、逻辑“1”、逻辑“0”。
    具体的方法是这样的,首先启用定时器,装入一个初值,打开
    定时器中断,让其以固定的间隔进入中断程序。在中断程序中,我们查询数据输入管脚的状态,如果为高电平,就在高电平状态累加计数,反之就在低电平状态计数,当电平发生上升沿变化的时候,判断接收到的高低电平宽度的值是否符合同步信号的要求,如果符合就进入数据位的接收,以同样的方式判断逻辑“1”或逻辑“0”。如果接受过程中出现不符合要求的电平状态,就退出接收,为了增加可靠性,我们一般要求规定时间内,成功接收到完全相同的 2 帧数据才算有效。
    接收完成后,24 个数据位被放入 3 个字节中。下一步我们要对接收到的数据进行处理,判断编码的类型,分离地址码和按键码。

    代码如下

    #include "1527.h"   
    
     /**
      * @brief  初始化控制LED的IO
      * @param  无
      * @retval 无
      */
    uint8_t RF;
    uint8_t decode_ok;            //解码成功
    uint8_t  hh_w,ll_w;           //高,低电平宽度
    uint8_t  ma_x;                //接收到第几位编码了
    uint8_t  bma1,bma2,bma3,bma4; //用于接收过程存放遥控编码,编码比较两次,这是第一次
    uint8_t  mma1,mma2,mma3,mma4;
    uint8_t mmb1,mmb2,mmb3,mmb4; // 用于接收过程存放遥控编码,第二次
    //extern uint8_t mmb1,mmb2,mmb3,mmb4;
     
    uint8_t rf_ok1,rf_ok2,rf_ok;         //解码过程中的临时接收成功标志,接收到一个完整的遥控命令后置1,通知解码程序可以解码了
    uint8_t old_rc5;             //保存上一次查询到的电平状态
    uint8_t tb_ok;               //接收到同步的马时置1   
    uint8_t D0,D1,D2,D3 ;
    uint16_t s ,s1; 
    uint8_t bt_auto;     //自动设置遥控接收波特率标志
    extern uint8_t rf_data[4];
    	
    void 1527_Init() //1527 IO口初始化
    {
    	GPIO_InitTypeDef GPIO_InitStruct;
    	NVIC_InitTypeDef NVIC_InitStructure;
    	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); 
    
    	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  // PB9 输入端
    	GPIO_InitStruct.GPIO_Pin     = GPIO_Pin_9; 
    	GPIO_InitStruct.GPIO_Mode    = GPIO_Mode_IN_FLOATING;
    	GPIO_InitStruct.GPIO_Speed   = GPIO_Speed_50MHz;
    	GPIO_Init(GPIOB, &GPIO_InitStruct);
    
    	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    	NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; 
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; 
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;  
    	NVIC_Init(&NVIC_InitStructure); 
    
    	TIM_TimeBaseStructure.TIM_Period = 100; 
    	TIM_TimeBaseStructure.TIM_Prescaler =7;                                                                                   
    	TIM_TimeBaseStructure.TIM_ClockDivision =        
    	TIM_CKD_DIV1; 
    	TIM_TimeBaseStructure.TIM_CounterMode = 
    	TIM_CounterMode_Up; 
    	TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); 
    	TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);
    	TIM_ClearFlag(TIM4,TIM_FLAG_Update);
    	TIM_Cmd(TIM4,ENABLE );  
    }
    void TIM4_IRQHandler()
    {
        if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
        {
            TIM_ClearITPendingBit(TIM4, TIM_IT_Update); 
     
            //接收数据的电平 PB9
            RF = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_9); 
            if (!RF) 
            { 
                ll_w++;   // 检测到低电平 低电平时间加1,记录本次电平状态old_rc5
                old_rc5=0; 
            }               
             else         // 检测到高电平
             { 
                hh_w++;
                if (!old_rc5)  // 检测到从低到高的跳变,已检测到一个完整(高-低)电平周期 判同步码    2/5 100/130
                {   
                    if (((hh_w>=2)&&(hh_w<=5))&&((ll_w>=100)&&(ll_w<=130))) 
                    { 
                        tb_ok = 1 ;
                        ma_x = 0;
                        bma1=0; bma2=0; bma3=0; bma4=0;    
                    }
                    else if ((tb_ok)&&((ll_w>=8)&&(ll_w<=13))) //8/13
                    {   
                        ma_x++; //已经接收到同步码,判0
                        if(ma_x>23)
                        {
                            if(!rf_ok1) //rf_ok1临时接收成功
                            {   //将接收到的编码复制到解码寄存器中 
                                mma1=bma1;
                                mma2=bma2;
                                mma3=bma3;
                                mma4=bma4; 
                                // 通知解码子程序可以解码了                                                        
                                rf_ok1=1;                    
                                tb_ok=0;
                                s=1000;                             
                                }
                                else
                                {//将接收到的编码复制到解码寄存器中  
                                    mmb1=bma1;
                                    mmb2=bma2;
                                    mmb3=bma3;
                                    mmb4=bma4;  
                                    // 通知解码子程序可以解码了                                             
                                    rf_ok2=1;                     
                                    tb_ok=0;                                                                        
                                }
                            }
                         }  
                         else if ((tb_ok)&&((ll_w>=2)&&(ll_w<=7)))   // 2/7
                         { 
                             switch (ma_x)
                             { 
                             case 0 : { bma1=bma1 | 0x80; 
                                 break; }   //遥控编码第1位
                             case 1 : { bma1=bma1 | 0x40;  
                                 break; }
                             case 2 : { bma1=bma1 | 0x20; 
                                 break; }
                             case 3 : { bma1=bma1 | 0x10; 
                                 break; }
                             case 4 : { bma1=bma1 | 0x08; 
                                 break; }
                             case 5 : { bma1=bma1 | 0x04; 
                                 break; }
                             case 6 : { bma1=bma1 | 0x02; 
                                 break; }
                             case 7 : { bma1=bma1 | 0x01; 
                                 break; }
                             case 8 : { bma2=bma2 | 0x80; 
                                 break; }
                             case 9 : { bma2=bma2 | 0x40; 
                                 break; }
                             case 10: { bma2=bma2 | 0x20; 
                                 break; }
                             case 11: { bma2=bma2 | 0x10; 
                                 break; }
                             case 12: { bma2=bma2 | 0x08; 
                                 break; }
                             case 13: { bma2=bma2 | 0x04; 
                                 break; }
                             case 14: { bma2=bma2 | 0x02; 
                                 break; }
                             case 15: { bma2=bma2 | 0x01; 
                                 break; }
                             case 16: { bma3=bma3 | 0x80; 
                                 break; }
                             case 17: { bma3=bma3 | 0x40; 
                                 break; }
                             case 18: { bma3=bma3 | 0x20; 
                                 break; }
                             case 19: { bma3=bma3 | 0x10; 
                                 break; }
                             case 20: { bma3=bma3 | 0x08; 
                                 break; }// 按键状态第1位
                             case 21: { bma3=bma3 | 0x04; 
                                 break; }
                             case 22: { bma3=bma3 | 0x02; 
                                break; }
                             case 23: { bma3=bma3 | 0x01;              
                                      if(!rf_ok1)
                                      {
                                          mma1=bma1;
                                          mma2=bma2;
                                          mma3=bma3;
                                       // mma4=bma4;                                           // 将接收到的编码复制到解码寄存器中                             
                                         rf_ok1=1;         // 通知解码子程序可以解码了
                                         tb_ok=0;
    //                                   bt_auto=0;
                                         s=1000;
                                         break;                                 
                                      }
                                      else
                                      {
                                          mmb1=bma1;
                                          mmb2=bma2;
                                          mmb3=bma3;
                                        //mmb4=bma4;               // 将再次接收到的编码复制到解码寄存器中,                             
                                        rf_ok2=1;                                      // 通知解码子程序可以解码了
                                        tb_ok=0;
                                        break;                                                                          
                                     }                                    
                             }
                        } 
                        ma_x++; 
                     }
                     else
                     {ma_x=0; tb_ok=0;bt_auto=0;bma1=0;bma2=0; bma3=0; hh_w=1;ll_w=0;}                                      //接收到不符合的高-低电平序列
                     ll_w=0;hh_w=1; 
                 }          
                 old_rc5=1;      // 记录本次电平状态
           }
           if(rf_ok1)  //规定时间内接受到2帧相同的编码数据才有效
            {
                s--;
                if(!s) rf_ok1=0;
                if(rf_ok2) 
                {
                if((mma1==mmb1)&&(mma2==mmb2)&&(mma3==mmb3))
                {
                    rf_ok=1;
                    rf_ok1=0;
                    rf_ok2=0;                    
                }
                else
                {
                    rf_ok=0;
                    rf_ok1=0;
                    rf_ok2=0;
     
                 }          
            }                   
        }
     
        if((rf_ok))      //判断是否接收成功
        {   
            //TIM_ITConfig(TIM4, TIM_IT_Update, DISABLE);
            rf_ok=0; 
            rf_data[0]=mma1;
            rf_data[1]=mma2;
            rf_data[2]=mma3;
     
            decode_ok=1;
     
            //TIM_ITConfig(TIM4  , TIM_IT_Update, ENABLE);
            }
        }
    
    }
    

     

    展开全文
  • 在STM32F103C8T6上独立代码完成对于EV1527解码芯片的控制,用代码完成编码过程,不再需要编码芯片介入。KEIL4代码完整。
  • ev1527、pt2262等433/315MHZ芯片用stc15w204s-sop8单片机解码,含源程序硬件介绍:软件介绍:单片机引脚定义:解码原理:主要代码 pt2262.c头文件 cofig.htime0中断 interrupt.ctime0中断头文件 interrupt.h子程序 ...

    硬件介绍:

    硬件,某宝上大把:
    1、433发射遥控1个,3元;
    2、433超外差接收模块1个,0.6元;
    3、stc最小系统板一个,笔者用的是STC-15W204S-SOP8最小版1.6元;
    4、TTL编程线下载1根,6元;
    我都是在某宝上买的,总价值不到12元


    软件介绍:

    自行下载:
    1、 keilC51
    2、 stc-isp-15xx-v6.87E烧写程序
    3、 串口调试工具
    4、 STC-USB驱动


    单片机引脚定义:

    引脚定义,均可以改变,自定义
    1、P3.0 RXD引脚,软件模拟串口接收,接上位机TXD
    2、P3.1 TXD引脚,软件模拟串口发送,接上位机RXD
    3、P3.2 接433模块DO输出引脚
    4、P3.3 LED指示灯
    5、P5.4 5.5空闲


    解码原理:

    略,度娘。简单来说就是检测433遥控发送的高低电平宽度,0.8-1毫秒为bit ‘1’,0.25-0.35毫秒为bit ‘1’


    最终结果:

    结果:
    烧录成功后,打开串口,波特率设置为38400,按433遥控按键,会通过串口调试工具接收到3字节的解码输出。


    主要代码 pt2262.c

    #include <STC15F104E.H>
    #include "public/inc/config.h"
    #include "public/inc/interrupt.h"
    #include "public/inc/subPG.h"
    
    //unsigned char bufSend[16] = {97,98,99,65,66,'f','g','h','i','j','k','l','m','n','o','p'};
    unsigned int buftime[40];
    unsigned char inc;
    bit dataB;
    bit T2Action;
    bit RECEIVE; //????
    
    
    void main()
    {
        uchar data1,data2,data3,counttime,i=0;
        int time;
    	int timeL;//低电平持续时间
    	int timeH; //高电平持续时间
    
        UART_INIT();	//系统初始化
    
    	YS100ms(50);
        LED=0;
    			
        while(1)
        {
            do {
                LED=0;
            }
            while(P3_2==1);
            if((P3_2==0) && (T2Action==0))      //等待低电平,低电平开始记时
            {
                AUXR &= 0XEF;
                T2H=0x00;
                T2L=0x00;
                //TF0=0;
                AUXR |= 0X10;
                T2Action=1;
                while(1)
                {
                    if((P3_2==1) && (T2Action==1))
                    {
                        AUXR &= 0XEF;
                        time=T2H*256+T2L;     //记下低电平宽度时间
                        T2Action=0;
                        T2H=0x00;
                        T2L=0x00;
                        //TF0=0;
                        AUXR |= 0X10;
    									  if((time>10000) && (time<10250))            //检测同步码约10ms
    										{
    												counttime=0;
    												time=0;
    												do {} while(P3_2==1);
    												if((P3_2==0) && (T2Action==0))     //等待第一个低电平,一有低电平马上记时
    												{
    													AUXR &= 0XEF;
    													time=T2H*256+T2L;     //记下第一个高电平宽度时间,防止误触发
    													if((time>300) && (time<450))            //检测同步码高电平约350us
    													{
    														RECEIVE=1;    //检测到同步码时 置标志位 RECEIVE=1
    														inc = 0;
    														data1=0;
    														data2=0;
    														data3=0;
    													}
    												}
    										}
                        break;
                    }
                }
            }
    /如果RECEIVE==1则同步码接收完毕,进入数据解码程序///
            if(RECEIVE==1)                    //检测到同步码后开始解码
            {
    						LED=1;                 //绿发光二极管灯亮(调试用)
                RECEIVE=0;
                while(1)
                {
                    do {} while(P3_2==1);
                    if((P3_2==0) && (T2Action==0))     //等待第一个低电平,一有低电平马上记时
                    {
                        AUXR &= 0XEF;
                        timeH=T2H*256+T2L;           //记高电平宽度时间
                        T2Action=1;
                        T2H=0x00;
                        T2L=0x00;
                        //TF0=0;
                        AUXR |= 0X10;
                        while(1)
                        {
                            if((P3_2==1) && (T2Action==1))
                            {
                                AUXR &= 0XEF;
                                timeL=T2H*256+T2L;    //记低电平宽度时间
    														//buftime[inc] = timeL;
                                T2Action=0;
                                T2H=0x00;
                                T2L=0x00;
                                //TF0=0;
                                AUXR |= 0X10;       //开始记高电平时间
                                break;
                            }
                        }
                    }
    								if(inc++ <= 23)				//24bit数据单元
    								{	
    									if((timeL>1200) || (timeL<100))		//干扰码
    									{
    										break;			
    									}
    									dataB = 0;
    									if((timeL>800) && (timeL < 1000))
    										dataB = 1;
    									if(inc < 8)
    									{
    										data1 <<= 1;
    										data1 |= dataB;									
    									}else if((inc >= 8) && (inc < 16)){
    										data2 <<= 1;
    										data2 |= dataB;
    									}else if((inc >= 16) && (inc < 24)){
    										data3 <<= 1;
    										data3 |= dataB;		
    									}
    									
    /*									for(i=0;i<inc;i++)
    									{
    										send_num2uart(66066);
    										send_num2uart(buftime[i]);
    									}*/
    								}else{
    										inc = 0;
    										send_num2uart(data1);
    										send_num2uart(data2);
    										send_num2uart(data3);
    										break;        //24位接收完毕,退出解码程序
    									}
    
                }
            }
        }
    }
    
    

    头文件 cofig.h

    #ifndef _CONFIG_H
    #define _CONFIG_H
    
    #include <STC15F104E.H>
    #define uchar unsigned char
    #define NUM_LEN 5		//数据转为字符串,字符串最长为6
    //设置通信波特率
    //#define BAUD  0xF400                  // 1200bps @ 11.0592MHz
    //#define BAUD  0xFA00                  // 2400bps @ 11.0592MHz
    //#define BAUD  0xFD00                  // 4800bps @ 11.0592MHz
    //#define BAUD  0xFE80                  // 9600bps @ 11.0592MHz
    //#define BAUD  0xFF40                  //19200bps @ 11.0592MHz
    #define BAUD  0xFFA0                  //38400bps @ 11.0592MHz
    sbit RXB = P3^0;  //p3^0为串口接收引脚 UART TX/RX port
    sbit TXB = P3^1;	//p3^1为串口发送引脚 UART TX/RX port	
    sbit LED = P3^3;	//p3^3为LED指示灯 UART TX/RX port	
    sbit P3_2 = P3^2; //p3^2为遥控数据D0输入 UART TX/RX port	
    
    extern bit T2Action;//T2定时器是否正在工作标志位
    extern bit RECEIVE; //接收无线遥控标志位
    #endif
    

    time0中断 interrupt.c

    //Timer interrupt routine for UART
    #include "../inc/config.h"
    #include "../inc/interrupt.h"
    unsigned char TBUF,RBUF;
    unsigned char TDAT,RDAT;
    unsigned char TCNT,RCNT;
    unsigned char TBIT,RBIT;
    bit TING,RING;
    bit TEND,REND;
    
    void tm0() interrupt 1
    {
    #if 0
            if (RING)
            {
                if (--RCNT == 0)
                {
                    RCNT = 3;                   //reset send baudrate counter
                    if (--RBIT == 0)
                    {
                        RBUF = RDAT;            //save the data to RBUF
                        RING = 0;               //stop receive
                        REND = 1;               //set receive completed flag
                    }
                    else
                    {
                        RDAT >>= 1;
                        if (RXB) RDAT |= 0x80;  //shift RX data to RX buffer
                    }
                }
            }
            else if (!RXB)
            {
                RING = 1;                       //set start receive flag
                RCNT = 4;                       //initial receive baudrate counter
                RBIT = 9;                       //initial receive bit number (8 data bits + 1 stop bit)
            }
    #endif
        if (--TCNT == 0)
        {
            TCNT = 3;                       //reset send baudrate counter
            if (TING)                       //judge whether sending
            {
                if (TBIT == 0)
                {
                    TXB = 0;                //send start bit
                    TDAT = TBUF;            //load data from TBUF to TDAT
                    TBIT = 9;               //initial send bit number (8 data bits + 1 stop bit)
                }
                else
                {
                    TDAT >>= 1;             //shift data to CY
                    if (--TBIT == 0)
                    {
                        TXB = 1;
                        TING = 0;           //stop send
                        TEND = 1;           //set send completed flag
                    }
                    else
                    {
                        TXB = CY;           //write CY to TX port
                    }
                }
            }
        }
    }
    

    time0中断头文件 interrupt.h

    #ifndef _INTERRUPT_H
    #define _INTERRUPT_H
    extern unsigned char TBUF,RBUF;
    extern unsigned char TDAT,RDAT;
    extern unsigned char TCNT,RCNT;
    extern unsigned char TBIT,RBIT;
    extern bit TING,RING;
    extern bit TEND,REND;
    #endif
    

    子程序 subPG.c

    #include "../inc/config.h"
    #include "../inc/subPG.h"
    #include <intrins.h>
    unsigned char string[NUM_LEN];
    
    
    /系统初始化函数///
    void UART_INIT()		
    {   
    	TMOD = 0x00;                        //初始化timer0 in 16-bit auto reload mode
        TL0 = BAUD;
    	TH0 = BAUD>>8;                      //初始化 timer0 为自动重装模式
        TR0 = 1;                            //tiemr0 start running
        ET0 = 1;                            //enable timer0 interrupt
        PT0 = 1;                            //improve timer0 interrupt priority
        EA = 1;                             //open global interrupt switch
    	T2H=0x00;
        T2L=0x00;
        AUXR |= 0X90;		//1001 0100
    	
        T2Action=0;
        RECEIVE=0;    //接收无线遥控标志位
        TING = 0;
        RING = 0;
        TEND = 1;
        REND = 0;
        TCNT = 0;
        RCNT = 0;
    }
    
    void lcd_wdat(unsigned char dat)
    {   //写入字符显示数据到LCD
        if (TEND)
        {
            TEND = 0;
            TBUF = dat;
            TING = 1;
        }
    }
    /演示100MS函数///
    void YS100ms(unsigned char n)		//@11.0592MHz
    {
        unsigned char i, j, k,l;
        for(l=n; l>0; l--) {
            _nop_();
            _nop_();
            i = 5;
            j = 52;
            k = 195;
            do
            {
                do
                {
                    while (--k);
                } while (--j);
            } while (--i);
        }
    }
    
    void num2char(long num,unsigned char* string) //一定要注意这里的字符串长度。
    {
        int i;
        i = NUM_LEN-1;    // 与这里的字符串长度相对应,从最后一个字符位开始。
        do {
            string[i] = num%10+'0';       //加上 ‘0’ 就是字符了!
            num/=10;
            i = i -1;
        } while(i>=0);
    }
    
    void send_num2uart(long num){		//发送数字到串口通信。
    		unsigned char i;
    		num2char(num,string);
    	//	YS100ms(50);
    		for(i=0; i<sizeof(string); i++)
    		{
    				while (!TEND);
    				{
    						TEND = 0;
    						TBUF = string[i];
    						TING = 1;
    				}
    		}
    }
    

    子程序头文件 subPG.h

    #ifndef _SUBPG_H
    #define _SUBPG_H
    #include "../inc/interrupt.h"
    
    extern void UART_INIT();
    extern void lcd_wdat(unsigned char dat);
    extern void YS100ms(unsigned char n);		//@11.0592MHz
    extern void num2char(long num,unsigned char* string); //一定要注意这里的字符串长度。
    extern void send_num2uart(long num);		//发送数字到串口通信。
    
    #endif
    
    展开全文
  • 基于STM32和EV1527的无线接收解码程序

    千次阅读 2018-10-07 12:58:50
    摘自: https://blog.csdn.net/Vinccent_/article/details/78955376... ... 一、1527的数据帧结构 无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 EV1527、PT22...

    摘自:

    https://blog.csdn.net/Vinccent_/article/details/78955376

    https://blog.csdn.net/hzd12368/article/details/80487849  另一参考

    一、1527的数据帧结构
    无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 EV1527、PT2262 为代表。另一种是滚动码,芯片的地址码是变化的,芯片以HS300、HS301为代表。

    1 EV1527 数据帧结构
    EV1527 是一片由 CMOS 设计制造的可预烧内码的学习码编码IC ,由软件解码;内码共有 20 个位元可预烧 1048576 组内码组合,降低使用上编码重复的机率。
    EV1527 每帧数据由 24 个数据位组成,前 20 位为地址码,对于一个芯片来说,地址位的内容是固定的,是出厂前就预制好的,并且理论上每个芯片的地址码是唯一的。后面 4 位为按键码,对应芯片上的K0-K3 4 根数据线,数据线的状态不同,按键码就不同。
    在数据位之前,还有一个同步脉冲,也就是每帧数据都是从同步
    脉冲开始的。数据位的“1”和“0”是由高低电平宽度(脉冲宽度)的比例决定的。如果高电平宽度为低电平宽度的 3 倍,就表示逻辑“1”,反过来如果低电平为高电平宽度的 3 倍,就表示逻辑“0”。同步脉冲高电平和低电平的比例固定为 4:124.
    1527时序
    这里写图片描述
    这里写图片描述
    这里写图片描述

    二、中断方式的解码
    把串行输入的编码数据帧,还原成编码之前的状态,读取其中
    的地址码和按键码,称之为解码。
    数据帧都是由同步头开始,然后是 24位的数据码,并且此数据帧在遥控器按键的过程中是重复出现的,我们首先要判断同步码,判断出了同步码,就知道数据码是从那一位开始了。对于一款量产的无线遥控器来说,他的编码芯片匹配的电阻是一个固定值,也就是说它发射的数据帧的脉冲宽度是不变的,所以我们可以通过测量高低脉冲宽度的方式来分辨同步码、逻辑“1”、逻辑“0”。
    具体的方法是这样的,首先启用定时器,装入一个初值,打开
    定时器中断,让其以固定的间隔进入中断程序。在中断程序中,我们查询数据输入管脚的状态,如果为高电平,就在高电平状态累加计数,反之就在低电平状态计数,当电平发生上升沿变化的时候,判断接收到的高低电平宽度的值是否符合同步信号的要求,如果符合就进入数据位的接收,以同样的方式判断逻辑“1”或逻辑“0”。如果接受过程中出现不符合要求的电平状态,就退出接收,为了增加可靠性,我们一般要求规定时间内,成功接收到完全相同的 2 帧数据才算有效。
    接收完成后,24 个数据位被放入 3 个字节中。下一步我们要对接收到的数据进行处理,判断编码的类型,分离地址码和按键码。

    三、程序代码

    /*main.c*/
    
    #include "stm32f10x.h"
    #include "uart.h"
    #include "led.h"
    #include "delay.h"
    #include "sys.h"
    #include "timer.h"
    
    uint8_t rf_data[4];
    extern uint8_t decode_ok;    //解码成功标志位
    extern uint8_t RF;
    
    int main(void)
    {   
        LED_Init();
        Uart_Init();
        delay_init();   //延时初始化一定要加上!!!!!!
        EV1527_GPIO_Init();
        TIM6_NVIC_Init();
        TIM6_Mode_Init();
    
        while(1)
        {
            if(decode_ok == 1)   //解码成功
            {
                switch(rf_data[2])
                {
                    case 0xf8:   //解码为0xf8,点亮LED
                    {
                        LED1 = LED_ON;
                        LED2 = LED_ON;
                        LED3 = LED_ON;
                        break;
                    }
                    case 0xf2:   //解码为0xf2,熄灭LED
                    {
                        LED1 = LED_OFF;
                        LED2 = LED_OFF;
                        LED3 = LED_OFF;
                        break;
                    }
    
                }
    
            }
    /***调试用代码,查看接收到的编码***/      
    //      printf("\r\n EV1527 \r\n");
    //      delay_ms(500);
    //      printf("i get %x  ",rf_data[0]);
    //      delay_ms(500);
    //      printf("i get %x  ",rf_data[1]);
    //      delay_ms(500);
    //      printf("i get %x  ",rf_data[2]);
    //      delay_ms(500);
    //      printf("i get %x  ",rf_data[3]);
    //      delay_ms(500);
        }
    }
    /************** END OF FILE *****************/
    
    
    /*Timer.c*/
    
    
    #include "stm32f10x.h"                  // Device header
    
    #include "timer.h"
    #include "led.h"
    #include "uart.h"
    #include "delay.h"
    
    void EV1527_GPIO_Init() //EV1527 IO口初始化
    {
        GPIO_InitTypeDef GPIO_InitStruct;
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  // PB9 输入端
        GPIO_InitStruct.GPIO_Pin     = GPIO_Pin_9; 
        GPIO_InitStruct.GPIO_Mode    = GPIO_Mode_IN_FLOATING;
        GPIO_InitStruct.GPIO_Speed   = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStruct);
    }
    
    //中断函数使用定时器6
    
    void TIM6_NVIC_Init()   //中断分组初始化
    {
    NVIC_InitTypeDef NVIC_InitStructure;    
                             NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    //TIM6中断
    NVIC_InitStructure.NVIC_IRQChannel = TIM6_IRQn; 
    //先占优先级2级
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;  
    //从优先级0级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; 
    //IRQ通道被使能
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; 
    //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器 
    NVIC_Init(&NVIC_InitStructure); 
    }
    
    void TIM6_Mode_Init()
    {    
        TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
        //使能TIM6时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);    
        //初始化定时器6
        //设定计数器自动重装值     
        TIM_TimeBaseStructure.TIM_Period = 100; 
        //时钟预分频系数 驱动计数器的时钟 CK_CNT=CK_INT/(71+1) = 1M
        //计数器计数1次时间等于1/CK_CNT = 1us
        TIM_TimeBaseStructure.TIM_Prescaler =71; 
        //设置时钟分割:TDTS = Tck_tim                                                                                   
        TIM_TimeBaseStructure.TIM_ClockDivision =        
        TIM_CKD_DIV1; 
        //TIM向上计数模式
        TIM_TimeBaseStructure.TIM_CounterMode = 
        TIM_CounterMode_Up; 
        //根据指定的参数初始化TIMx的时间基数单位
        TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure); 
        //允许更新中断 
        TIM_ITConfig(TIM6,TIM_IT_Update,ENABLE);
        TIM_ClearFlag(TIM6,TIM_FLAG_Update);
        //使能定时器6
        TIM_Cmd(TIM6,ENABLE );  
    }
    
    uint8_t RF;
    uint8_t decode_ok;            //解码成功
    uint8_t  hh_w,ll_w;           //高,低电平宽度
    uint8_t  ma_x;                //接收到第几位编码了
    uint8_t  bma1,bma2,bma3,bma4; //用于接收过程存放遥控编码,编码比较两次,这是第一次
    uint8_t  mma1,mma2,mma3,mma4;
    uint8_t mmb1,mmb2,mmb3,mmb4; // 用于接收过程存放遥控编码,第二次
    //extern uint8_t mmb1,mmb2,mmb3,mmb4;
    
    uint8_t rf_ok1,rf_ok2,rf_ok;         //解码过程中的临时接收成功标志,接收到一个完整的遥控命令后置1,通知解码程序可以解码了
    uint8_t old_rc5;             //保存上一次查询到的电平状态
    uint8_t tb_ok;               //接收到同步的马时置1   
    uint8_t D0,D1,D2,D3 ;
    uint16_t s ,s1; 
    uint8_t bt_auto;     //自动设置遥控接收波特率标志
    extern uint8_t rf_data[4];  
    
    void TIM6_IRQHandler()
    {
        if(TIM_GetITStatus(TIM6, TIM_IT_Update) != RESET)
        {
            TIM_ClearITPendingBit(TIM6, TIM_IT_Update); 
    
            //接收数据的电平 PB9
            RF = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_9); 
            if (!RF) 
            { 
                ll_w++;   // 检测到低电平 低电平时间加1,记录本 
                          // 次电平状态old_rc5
                old_rc5=0; 
            }               
             else         // 检测到高电平
             { 
                hh_w++;
                if (!old_rc5)  // 检测到从低到高的跳变,已检测
                               // 到一个完整(高-低)电平周期
                {   //判同步码    2/5 100/130
                    if (((hh_w>=2)&&(hh_w<=5))&&
                    ((ll_w>=100)&&(ll_w<=130))) 
                    { 
                        tb_ok = 1 ;
                        ma_x = 0;
                        bma1=0; bma2=0; bma3=0; bma4=0;    
                    }
                    else if ((tb_ok)&&((ll_w>=8)&&
                                    (ll_w<=13))) //8/13
                    {   
                        ma_x++; //已经接收到同步码,判0
                        if(ma_x>23)
                        {
                            if(!rf_ok1) //rf_ok1临时接收成功
                            {   //将接收到的编码复制到解码寄存器中 
                                mma1=bma1;
                                mma2=bma2;
                                mma3=bma3;
                                mma4=bma4; 
                                // 通知解码子程序可以解码了                                                        
                                rf_ok1=1;                    
                                tb_ok=0;
                                s=1000;                             
                                }
                                else
                                {//将接收到的编码复制到解码寄存器中  
                                    mmb1=bma1;
                                    mmb2=bma2;
                                    mmb3=bma3;
                                    mmb4=bma4;  
                                    // 通知解码子程序可以解码了                                             
                                    rf_ok2=1;                     
                                    tb_ok=0;                                                                        
                                }
                            }
                         }  
                         else if ((tb_ok)&&((ll_w>=2)&&
                                      (ll_w<=7)))   // 2/7
                         { 
                             switch (ma_x)
                             { 
                             case 0 : { bma1=bma1 | 0x80; 
                                 break; }   //遥控编码第1位
                             case 1 : { bma1=bma1 | 0x40;  
                                 break; }
                             case 2 : { bma1=bma1 | 0x20; 
                                 break; }
                             case 3 : { bma1=bma1 | 0x10; 
                                 break; }
                             case 4 : { bma1=bma1 | 0x08; 
                                 break; }
                             case 5 : { bma1=bma1 | 0x04; 
                                 break; }
                             case 6 : { bma1=bma1 | 0x02; 
                                 break; }
                             case 7 : { bma1=bma1 | 0x01; 
                                 break; }
                             case 8 : { bma2=bma2 | 0x80; 
                                 break; }
                             case 9 : { bma2=bma2 | 0x40; 
                                 break; }
                             case 10: { bma2=bma2 | 0x20; 
                                 break; }
                             case 11: { bma2=bma2 | 0x10; 
                                 break; }
                             case 12: { bma2=bma2 | 0x08; 
                                 break; }
                             case 13: { bma2=bma2 | 0x04; 
                                 break; }
                             case 14: { bma2=bma2 | 0x02; 
                                 break; }
                             case 15: { bma2=bma2 | 0x01; 
                                 break; }
                             case 16: { bma3=bma3 | 0x80; 
                                 break; }
                             case 17: { bma3=bma3 | 0x40; 
                                 break; }
                             case 18: { bma3=bma3 | 0x20; 
                                 break; }
                             case 19: { bma3=bma3 | 0x10; 
                                 break; }
                             case 20: { bma3=bma3 | 0x08; 
                                 break; }// 按键状态第1位
                             case 21: { bma3=bma3 | 0x04; 
                                 break; }
                             case 22: { bma3=bma3 | 0x02; 
                                break; }
                             case 23: { bma3=bma3 | 0x01;              
                                      if(!rf_ok1)
                                      {
                                          mma1=bma1;
                                          mma2=bma2;
                                          mma3=bma3;
                                       // mma4=bma4;                                           // 将接收到的编码复制到解码寄存器中                             
                                         rf_ok1=1;         // 通知解码子程序可以解码了
                                         tb_ok=0;
    //                                   bt_auto=0;
                                         s=1000;
                                         break;                                 
                                      }
                                      else
                                      {
                                          mmb1=bma1;
                                          mmb2=bma2;
                                          mmb3=bma3;
                                        //mmb4=bma4;               // 将再次接收到的编码复制到解码寄存器中,                             
                                        rf_ok2=1;                                      // 通知解码子程序可以解码了
                                        tb_ok=0;
                                        break;                                                                          
                                     }                                    
                             }
                        } 
                        ma_x++; 
                     }
                     else
                     {ma_x=0; tb_ok=0;bt_auto=0;bma1=0;bma2=0; bma3=0; hh_w=1;ll_w=0;}                                      //接收到不符合的高-低电平序列
                     ll_w=0;hh_w=1; 
                 }          
                 old_rc5=1;      // 记录本次电平状态
           }
           if(rf_ok1)  //规定时间内接受到2帧相同的编码数据才有效
            {
                s--;
                if(!s) rf_ok1=0;
                if(rf_ok2) 
                {
                if((mma1==mmb1)&&(mma2==mmb2)&&(mma3==mmb3))
                {
                    rf_ok=1;
                    rf_ok1=0;
                    rf_ok2=0;                    
                }
                else
                {
                    rf_ok=0;
                    rf_ok1=0;
                    rf_ok2=0;
    
                 }          
            }                   
        }
    
        if((rf_ok))      //判断是否接收成功
        {   
            TIM_ITConfig(TIM6, TIM_IT_Update, DISABLE);
            rf_ok=0; 
            rf_data[0]=mma1;
            rf_data[1]=mma2;
            rf_data[2]=mma3;
    
            decode_ok=1;
    
            TIM_ITConfig(TIM6  , TIM_IT_Update, ENABLE);
            }
        }
    }

    --------------------- 本文来自 Mascreda 的CSDN 博客 ,全文地址请点击:https://blog.csdn.net/Vinccent_/article/details/78955376?utm_source=copy

    展开全文
  • EV1527无线芯片的单片机解码程序,采用STC15F204E单片机,开发环境KEIL,8051内核,开发简单上手快,方便移植和修改。
  • 射频1527 解码程序

    2018-07-22 11:41:09
    无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 EV1527、PT2262 为代表。另一种是滚动码,芯片的地址码是变化的,芯片以HS300、HS301为代表。
  • STC解码EV1527含程序和原理图,含接315M接收电路,最小板原理图,led指示灯,采用480芯片接收
  • pt2262芯片解码程序,使用51单片机进行解码,能够实现更多自定义功能,完美提到pt2272,代码更改后可以适配ev1527等一系列累死的无限芯片,433Mhz的也可以,已批量生产该方案
  • 该模块采用性能稳定的超外差无线芯片,以及学习码解码芯片设计而成。是针对市面上的常见的固定码遥控器,包括PT2262、HX2262、SC2260、EV1527等的解码应用所设计的4路学习型解码模块.具高保密性,性能稳定、功耗低之...
  • STM32下315M模块的无线接收解码程序

    万次阅读 2018-05-28 20:16:22
    最近项目需要增加一个控制机器运行的紧急遥控,参考了一个大神的博客,然后我们选择了这样的遥控...其中它使用的芯片EV1527型,EV1527 每帧数据由 24 个数据位组成,前 20 位为地址码,对于一个芯片来说,地址位的...
  • 1、EV1527/PT2262 按键解码输出,并有解码有效输出端。 2、程序采用中断嵌套结构,定时时间准确,可轻松集成到您现有程序中,解码精度不受其他程序块影响。 3、通过学习键可学习40个遥控器编码,使用芯片自带EEPROM...
  • 无线RF_RX-FT60F011.rar

    2020-04-30 07:13:46
    本程序包含了对码,解码及清码完整程序.无线遥控的编码,从编码类型上来说,分为2类,一类是固定码,也就是编码芯片的地址是不变的,芯片型号以 EV1527、PT2262 为代表。
  • 这是一款工作在315Mhz频段的无线遥控门铃,根据查阅官方手册以及芯片信息,确定其采用了eV1527 百万组编码芯片。这是一款无线发码专用集成电路,采用 CMOS 工艺制造,拥有 20 位内码,可预烧 100 万组内码组合,发射...
  • 遥控开关 使用Arduino或来操作远程无线电... EV1527 / RT1527 / FP1527 / HS1527 Intertechno网点 HT6P20X 接收和解码RC代码 找出遥控器发送的代码。 使用遥控器控制Arduino。 您所需要的只是一个Arduino,一个315

空空如也

空空如也

1 2
收藏数 30
精华内容 12
关键字:

ev1527解码芯片