单片机红外遥控原理及程序(非常详细)

ID:100029 · 发表于 2015-12-22 21:43

应该说现在每一块开发板都带有红外模块，并且大都配置了相应的程序。但其实自己动手写解码程序，更能锻炼自己所学，且不谈程序写的如何，这个过程中肯定是受益良多的。现在我就把我花一下午写出的解码程序与大家分享，期待高手的光临指正。

首先，必须要了解一些基本原理。其实按下遥控器的某一个键，遥控器会发出一连串经过调制后的信号，这个信号经过红外一体化模块接收后，输出解调后的数字脉冲，每个按键对应不同的脉冲，故识别出不同的脉冲就能识别出不同的按键。

上图就是很常见的车载MP3遥控器，比较小巧，很好用。下面是红外发射和接受原理：

到此读者可能会有疑惑，那么不同的调制解调方法那么出来的脉冲规则是不一样的？是的，的确如此。

遥控发射器专用芯片很多，根据编码格式可以分成两大类，这里我们以运用比较广泛，解码比较容易的一类来加以说明，现以日本NEC的uPD6121G组成发射电路为例说明编码原理（一般家庭用的DVD、VCD、音响都使用这种编码方式）。当发射器按键按下后，即有遥控码发出，所按的键不同遥控编码也不同。这种遥控码具有以下特征：

采用脉宽调制的串行码，以脉宽为0.565ms、间隔0.56ms、周期为1.125ms的组合表示二进制的“0”；以脉宽为0.565ms、间隔1.685ms、周期为2.25ms的组合表示二进制的“1”，其波形如图所示。

如图可见，0与1前端的低电平持续都是0.56ms，那么就是后面的高电平持续时间不同，0为0.56ms，1为1.685ms，找到不同之处，编程时就有识别的依据了！

上述“0”和“1”组成的32位二进制码经38kHz的载频进行二次调制以提高发射效率，达到降低电源功耗的目的。然后再通过红外发射二极管产生红外线向空间发射，如图所示。

UPD6121G产生的遥控编码是连续的32位二进制码组，其中前16位为用户识别码，能区别不同的电器设备，防止不同机种遥控码互相干扰。该芯片的用户识别码固定为十六进制01H；后16位为8位操作码（功能码）及其反码。UPD6121G最多额128种不同组合的编码。

请看下图，来自网络：

当一个键按下超过36ms，振荡器使芯片激活，将发射一组108ms的编码脉冲,这108ms发射代码由一个引导码（9ms）,一个结果码（4.5ms）,低8位地址码（9ms~18ms）,高8位地址码（9ms~18ms）,8位数据码（9ms~18ms）和这8位数据的反码（9ms~18ms）组成。如果键按下超过108ms仍未松开，接下来发射的代码（连发码）将仅由起始码（9ms）和结束码（2.25ms）组成。（实际上人手的动作是很慢的，即使你快速的按下按键，可能对于芯片来说还是超过108ms，所以如何处理连发码是很关键的）

遥控器在按键按下后，周期性地发出同一种32位二进制码，周期约为108ms。一组码本身的持续时间随它包含的二进制“0”和“1”的个数不同而不同，大约在45～63ms之间，图为发射波形图。

下面是我写的代码，按键编码通过串口发送到电脑端：

由于时间关系，代码注释不多。

其中START_Judge()函数是判断9ms低电平，既是判断有无遥控信号。

BOOT_REPEATING_CODE_Judge()是判断是引导码还是连发码，引导码则进入接受数据环节，连发码表明数据已经接受结束。

H_L_LEVEL_Judge()是接受数据时判断高低电平。

如果乱码，请参考：

注明：以下代码为纯软件方式，没有用到中断，定时器方式，纯CPU查询，但测试结果倒也可以，至少比较稳定，得到的码值不管对不对，都是那个值。

[cpp] view plaincopy
/*------------------------------------------------------------*- 
  红外收发.C 
  ------------------------------------------------------------ 
  遥控器测试 
-*------------------------------------------------------------*/  
  
#include <reg52.h>  
  
// --- 红外接收一体化输出口 ----------------------------------  
sbit IR_Out = P3^2;  
  
bit START_Flag = 0;  
bit BOOT_REPEATING_CODE_Flag = 0;  
unsigned char DATA[4] = {0};  
bdata unsigned char TEMP_BIT;  
  
sbit B0 = TEMP_BIT^0;  
sbit B1 = TEMP_BIT^1;  
sbit B2 = TEMP_BIT^2;  
sbit B3 = TEMP_BIT^3;  
sbit B4 = TEMP_BIT^4;  
sbit B5 = TEMP_BIT^5;  
sbit B6 = TEMP_BIT^6;  
sbit B7 = TEMP_BIT^7;  
  
// --- 有无遥控信号判断函数 ----------------------------------  
bit START_Judge();  
  
// --- 连发码判断函数 ----------------------------------------  
bit BOOT_REPEATING_CODE_Judge();  
  
// --- "0"和"1"识别 ------------------------------------------  
bit H_L_LEVEL_Judge();  
  
// --- 串口初始化 --------------------------------------------  
void UART_Initial();  
  
void DELAY_Us(unsigned int Us)  
{  
    unsigned int x;  
    for(x = 0; x <= (Us/200-1); x++);  
}  
void DELAY_Ms(unsigned int Ms)  
{  
    unsigned int x,y;  
    for(x = 0; x <= (Ms-1); x++)  
    {  
        for(y = 0; y <= 120; y++);  
    }  
}  
  
void main()  
{  
    unsigned char i;  
    UART_Initial();  
    IR_Out = 1;  
    while(1)  
    {         
        START_Flag = START_Judge();  
        BOOT_REPEATING_CODE_Flag = BOOT_REPEATING_CODE_Judge();  
        if ( START_Flag && !BOOT_REPEATING_CODE_Flag )  
        {             
            for(i =0;i <4; i++)  
            {                 
                B0 = H_L_LEVEL_Judge();  
                B1 = H_L_LEVEL_Judge();  
                B2 = H_L_LEVEL_Judge();  
                B3 = H_L_LEVEL_Judge();  
                B4 = H_L_LEVEL_Judge();  
                B5 = H_L_LEVEL_Judge();  
                B6 = H_L_LEVEL_Judge();  
                B7 = H_L_LEVEL_Judge();                               
                DATA[i] = TEMP_BIT;  
            }  
            for(i =0;i <4; i++)  
            {  
                SBUF = DATA[i];  
                while( TI == 0 );  
                TI = 0;  
            }  
        }  
    }  
}  
  
void UART_Initial()  
{  
    SCON = 0x50;            // SCON: 模式 1, 8-bit UART, 使能接收  
  
    TMOD |= 0x20;           // TMOD: timer 1, mode 2, 8-bit reload  
  
    TH1 = 0xFD;             // TH1: reload value for 9600 baud @  
                            // 11.0592MHz   
    TR1 = 1;                // TR1: timer 1 run  
  
    EA = 0;                 // 关闭总中断  
    ES = 0;                 // 关闭串口中断  
}  
      
  
bit START_Judge()  
{  
    bit TEMP_Flag = 1;  
    unsigned char i = 0;  
  
    //在正常无遥控信号时，一体化红外接收头输出是高电平，程序一直在循环。  
    while ( IR_Out == 1);  
  
    //重复10次，目的是检测在6876~8352微秒内如果出现高电平就退出解码程序  
    for(i =0;i <9; i++)  
    {  
        DELAY_Us(800);      // 测试实际延时约为764~928us  
        if ( IR_Out == 1 )  
        {  
            TEMP_Flag = 0;  
            break;  
        }  
    }  
      
    return TEMP_Flag;  
}  
  
bit BOOT_REPEATING_CODE_Judge()  
{  
    bit TEMP_Flag = 1;  
    while( IR_Out == 0 ) ;  // 等待高电平避开9毫秒低电平引导脉冲  
  
    DELAY_Ms(1);            // 测试实际延时约为1.007ms   
    DELAY_Ms(1);            // 测试实际延时约为1.007ms   
    DELAY_Us(200);          // 0.086ms  
    DELAY_Us(200);          // 0.086ms    
    DELAY_Us(200);          // 0.086ms  
                            // 共计2.272ms      
  
    if( IR_Out == 0 )  
    {  
        TEMP_Flag = 1;      // 是连发码  
    }  
    else  
    {  
        TEMP_Flag = 0;      // 不是连发码，而是引导码  
    }  
    return TEMP_Flag;  
}  
bit H_L_LEVEL_Judge()  
{  
    while( IR_Out == 0 );   // 等待地址码第一位的高电平信号  
    DELAY_Us(800);          // 测试实际延时约为764~928us  
    if ( IR_Out == 1)  
    {  
        DELAY_Ms(1);        // 测试实际延时约为1.007ms   
        return 1;  
    }  
    else  
    {  
        return 0;  
    }  
} 

 
 
编辑如下：
01 FE 8B 74 --- 01 FE 8D 72 --- 01 FE 8F 70
01 FE 89 76 --- 01 FE 81 7E --- 01 FE 87 78
01 FE 0F F0 --- 01 FE 2B D4 --- 01 FE 13 EC
01 FE 2D D2 --- 01 FE 33 CC --- 01 FE 1B E4
01 FE 19 E6 --- 01 FE 31 CE --- 01 FE BD 42
01 FE 11 EE --- 01 FE 39 C6 --- 01 FE B5 4A
以上为对应按键的编码。
过程中存在问题：
一是如何有效的识别引导码和连发码，因为这个能直接影响到长时间按键，单片机的响应与否。这个问题，貌似我以解决，就是长时间按键后，单片机识别一次按键后，如果还是同一按键，就不与理睬。
还有一个问题就是，如果连续按下两次按键，该程序能够识别出，但是如果间隔很短，第二下按键的编码容易出错，容易变成这样：
03 FE 8B 74.。。。就是第一个字节出现误差，这个问题现在还未来得及解决。
还有就是本程序对于延时函数的精度要求很高，因为本身处理的脉冲就是MS级别的。所以需要严格的测试延时函数的实际延时时间：
 
以上的代码，可以看出许多问题，软件延时不准确，大量的“while( IR_Out == 0 ) ;”代码，抗干扰能力弱，容易进入死循环。
下面介绍的这种解码方法，利用外部中断触发程序，定时器定时（但没有设置定时中断程序，即判断TF的值确定定时结束），在代码过程中，开头的一个7.93ms延时，足以滤掉不合法的红外信号。应该说效率质量更高的。
代码注释很详细，在此不在细述：
[cpp] view plaincopy
/*------------------------------------------------------------*- 
  IR_Decoder.C (v1.00) 
  ------------------------------------------------------------ 
  名称：遥控器红外解码，PO口接LED，显示功能码以供查看 
  编写：mhjerry 
  日期：20011.7 
  内容：按遥控器上的按键，会在PO口LED上显示 
-*------------------------------------------------------------*/  
#include "reg52.h"  
  
// 此口为红外信号输入MCU口  
sbit IR_Out = P3^2;   
  
// 主程序运行标志位,运行主程序时LED灭，运行中断程序时LED亮    
sbit IR_Flag = P3^1;  
  
// LED显示口  
#define LED_Port P1  
  
// 用于存放按键码值，初始化为0000 0000这样接受数据时可以只考虑1了   
unsigned char dat[4] = {0,0,0,0};  
  
  
/*............................................................*/  
void main()  
{  
    IR_Out = 1;     // 此口为MCU输入口，故需要置1  
    IR_Flag = 1;    // 灭LED灯  
    TMOD = 0x01;    // 定时器0，方式1  
    IT0 = 1;        // 外部中断0，下降沿触发  
    EX0 = 1;        // 准许外部中断  
    EA = 1;         // CPU准许中断  
  
    while(1)  
    {  
        IR_Flag = 1;// 执行主程序时,LED灯灭  
    }  
}  
/*------------------------------------------------------------*-  
  函数名称：Int0() 
  函数输入：无(容许中断时，外部触发) 
  函数输出：无 
  函数说明：外部中断0中断处理 
-*------------------------------------------------------------*/  
void Int0() interrupt 0  
{  
    unsigned char i,j;  
    EX0 = 0;            // 关闭外部中断0  
    IR_Flag = 0;        // 执行中断程序时,LED灯亮  
    i = 10;             // 0.793ms延时，运行10次  
    while( --i )  
    {  
        // 定时0.793ms,延时0.793ms*10=7.93ms  
        TH0 = 0xfc;  
        TL0 = 0xe7;  
        TR0 = 1;  
        while( !TF0 );  
        TF0 = 0;  
        TR0 = 0;  
          
        // 这7.93ms期间只要IR_Out变高电平,就非合法的红外信号，跳出  
        if( IR_Out )  
        {  
            EX0 = 1;    // 准许中断  
            return ;  
        }  
    }  
      
    // 程序进行到这里，表明是合法的红外信号(利用9ms判断)  
    while( !IR_Out );   // 等待9ms低电平过去  
      
    // 程序进行到这里，表明经过9ms低电平  
    TH0 = 0xf6;  
    TL0 = 0xff;  
    TR0 = 1;  
    while( !TF0 );  
    TF0 = 0;  
    TR0 = 0;            // 延时2.305ms  
      
    // IR_Out 为低表明是连发码，不予理睬，跳出  
    if( !IR_Out )  
    {  
        EX0=1;  
        return;  
    }  
  
    // 程序进行到这里，表明是引导码，等待4.5ms高电平的过去  
    while( IR_Out );      
      
    // 开始接收用户码  
    for(i=0; i<4; i++)  
    {  
        for(j=0; j<8; j++)  
        {  
            while( !IR_Out );   // 等待低电平过去  
            dat[i] >>= 1;     // 把上次的数据位右移一位  
  
            TH0 = 0xfc;  
            TL0 = 0xe7;  
            TR0 = 1;  
            while( !TF0 );  
            TR0=0;  
            TF0=0;              //延时0.793ms   
              
            // 若为数据"1"，则延时后IR_Out为高电平  
            if( IR_Out )   
            {  
                dat[i] |= 0x80;     // 所有数据位1放最高位  
                while( IR_Out );    // 等待高电平过去  
            }  
        }  
    }     
    LED_Port = dat[2];  
    EX0=1;      // 开中断  
    return;  
}  
/*------------------------------------------------------------*- 
  ---- END OF FILE ------------------------------------------- 
-*------------------------------------------------------------*/  

ID:161497 · 发表于 2017-1-24 09:52

讲得很详细这些资料在哪里下载？

ID:161497 · 发表于 2017-1-24 09:52

资料在哪里下载

ID:165041 · 发表于 2017-2-17 09:40

第61行下面应该是为低电平就跳出.

ID:165041 · 发表于 2017-2-17 12:30

还有在while（--i）之前加个低电平判断，大哥啊，我还是个新手呢，根据你的逻辑写的PIC的，找了好久才找到这两个BUG；
最后还是要非常感谢哥们的分享！

ID:165262 · 发表于 2017-2-18 16:26

学习了!

ID:166593 · 发表于 2017-2-25 15:54

只看懂了cpu延时的程序，有个疑问希望能帮忙解决一下：
在判断是引导码还是连发码的函数里，如果是引导码延时2.272ms后还有约2ms的高电平啊？如果直接进入数据接收函数不会出现误差么？

ID:74784 · 发表于 2017-2-26 22:41

有50462发射芯片的解码不？

ID:130231 · 发表于 2017-3-17 15:26

不错哦

ID:147518 · 发表于 2017-7-11 18:28

学习了，虽看不懂但也赞了

ID:174969 · 发表于 2017-8-19 05:24

很好的资料，算是我学习红外遥控的第一篇

ID:229128 · 发表于 2017-12-11 13:23

“有无遥控信号判断函数” 这个不是很懂有这方面的资料不？

ID:278860 · 发表于 2018-1-28 19:41

牛的一匹

ID:164089 · 发表于 2018-1-31 21:56

资料很好傻

ID:164089 · 发表于 2018-1-31 21:57

程序还有点问题，正在研究。

ID:287608 · 发表于 2018-3-5 07:56

写的很多，只可惜看不懂，学会了再来下载吧

ID:291105 · 发表于 2018-3-14 21:57

这个那么多，要慢慢看了

ID:84997 · 发表于 2018-3-15 09:40

非常好的文章，学习了

ID:91280 · 发表于 2018-4-13 20:52

好东西，学习了

ID:85743 · 发表于 2018-4-18 23:49

学习了,谢谢楼主分享

ID:313033 · 发表于 2018-4-21 14:27

学习到了，单片机小白目前看不懂

ID:313821 · 发表于 2018-4-22 16:33

找到了组织

ID:308180 · 发表于 2018-4-27 16:10

很棒，学习中断很有用

ID:111025 · 发表于 2018-5-10 17:34

学习了！！！

ID:369787 · 发表于 2018-7-11 22:07

还是不懂

ID:327464 · 发表于 2018-7-15 03:58

有死循环的概率，最好加个超时判断

ID:267435 · 发表于 2018-7-18 09:54

讲得很细致资料在哪里下载？

ID:374177 · 发表于 2018-7-18 16:10

看到有更简结的C程序，我哪天对比一下功能。

ID:375003 · 发表于 2018-7-19 18:44

我做的仿真遥控器
PIC12f509仿真空调摇控器

#include "pic12f509.h"

//#include<htc.h>
//  _CONFIG (0x02); //表示用内部的RC震荡器;
// 配置文件在编程器写入的时候指定选项
//**************************************************
//                      __________
//             VDD-| 1          8 |-VSS
//             GP5-| 2          7 |-GP0/DAT
//             GP4-| 3          6 |-GP1/CLK
//  GP3/RMCLR--| 4          5 |-GP2
//                      |_________|
//                12F508
//***************************************************
//按键必须用以下三个脚,不然睡眠后不能唤醒;
//发射二极管正极接电源,负极经100欧电阻接5脚;
#define uchar unsigned char
#define uint unsigned int
#define IR_out  GP2
#define pwr_KEY GP1
#define up_KEY  GP3
#define down_KEY GP0

union//定义一个可以位操作的结构体
{
struct{
   unsigned b0:1;
   unsigned b1:1;
   unsigned b2:1;
   unsigned b3:1;
   unsigned b4:1;
   unsigned b5:1;
   unsigned b6:1;
   unsigned b7:1;
   }oneBit;
   unsigned char allBits;
}myFlag;

#define wHB myFlag.oneBit.b7
#define wBYT myFlag.allBits

const uchar chuai[]={0x41,0x49,0x45,0x4d,0x43,0x4b,0x47};//26度到32度
static bit key;
uchar ii;

#define H 1
#define L 0

void init()
{
TRISGPIO=0b11111011;//只有GP2输出;
OPTION=0b00001000;//TIM0不用分频器0x80;引脚变化可以唤醒,开上拉
OSCCAL=0b00000000;//晶振频率不校正.
}

void dly(uint Delay) /*延时t/0.5ms*/
  {
uchar i=50;
while(--Delay)while(--i);
}

start()
{
uint i=342;
  while(i--)//输出9ms负脉冲;
{ IR_out=L;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H;    //输出正脉冲
}
i=171;
while(i--)//输出4.5ms正脉冲;
{ IR_out=H;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H; //输出正脉冲
}
}
output_0()
{
  uint i=19;
  while(i--)//输出9ms负脉冲;
{ IR_out=L;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H;    //输出正脉冲
}
i=26;
while(i--)//输出4.5ms正脉冲;
{ IR_out=H;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H; //输出正脉冲
}
}
output_1()
{
  uint i=19;
  while(i--)//输出9ms负脉冲;
{ IR_out=L;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H;    //输出正脉冲
}
i=66;
while(i--)//输出4.5ms正脉冲;
{ IR_out=H;ii=2;//输出负脉冲
   while(--ii);
   IR_out=H; //输出正脉冲
}
}
void main()
{
uchar dat3=0,dat4=0,zz=0,zr=0;
uchar dat1=0,dat2=0;
init();
uchar nFUN;//定义成局部变量复位不会清零;
GPIO=0XFF; //IO口全是高电平;
if(nFUN>6)nFUN=6;//如果值不确定,初始化成6;
IR_out=1;//关输出三极管;
dat1=0XC1;dat2=0x60;
while(1){
      wBYT=dat1;key=0;
      IR_out=1;
if(pwr_KEY==0){dly(10);if(pwr_KEY==0){while(pwr_KEY==0);key=1;}
         dat3=0x20;dat4=0x41;nFUN=0;}//电源26度开机；复位nFUN.
if(up_KEY==0){dly(10);if(up_KEY==0){while(up_KEY==0);key=1;}
      dat3=0;if(nFUN<6)nFUN++;dat4=chuai[nFUN];}//温度加；参数100延时时间21ms
if(down_KEY==0){dly(10);if(down_KEY==0){while(down_KEY==0);key=1;}
         dat3=0;if(nFUN>0)nFUN--;dat4=chuai[nFUN];}//温度减；参数100延时时间21ms
if(key)
{
      start();
      wBYT=dat1;
      for(zz=0;zz<=6;zz++)
      {

         if(zz==1)wBYT=dat2;
         if(zz==2)wBYT=dat3;
         if(zz==3)wBYT=dat4;
         if(zz==4)wBYT=0x00;
         if(zz==5)wBYT=0x00;
         if(zz==6){key=0;output_0();break;}
         for(zr=0;zr<8;zr++)
         {
            if(wHB)output_1();
            else output_0();
            wBYT<<=1;
         }

      }

}
#asm
      SLEEP
#endasm
  }
}

ID:261485 · 发表于 2018-7-21 09:16

我学这个很久了，就是不懂遥控小车的话，前进后退，转弯的程序，应该放在哪里才能被发送到小车。比如按遥控器的1是前进，那应该怎么写，写在那个函数里。我看了很多，都不同，就把我弄懵了，希望大神给我哦讲解下，配个例子。。。谢谢！！！！！！！！！！！

ID:6985 · 发表于 2018-7-31 12:04

顶一下，不错

ID:392786 · 发表于 2018-9-3 11:04

很详细，虽然看不太懂。

ID:332225 · 发表于 2018-9-4 09:16

好厉害！

ID:251401 · 发表于 2018-10-21 16:53

能写出发射和接收的数据编码的不同就好了。

ID:247813 · 发表于 2018-10-21 20:49

很详细，虽然看不太懂。

ID:223688 · 发表于 2018-10-22 08:40

很详细

ID:337913 · 发表于 2018-11-3 16:42

厉害呀，大佬

ID:326450 · 发表于 2018-11-4 18:40

有详细的资料和电路么？

ID:152589 · 发表于 2018-11-27 08:50

赞一个

ID:352449 · 发表于 2019-5-12 17:07

还是有嗲看不懂

帐号		自动登录	找回密码
密码			立即注册

单片机红外遥控原理及程序(非常详细)

评分

评分