最近在项目中添加了使用红外遥控的功能，可以在产品不打开盖的情况下修改参数。下面简单介绍一下基于NXP的LPC1752实现红外遥控的过程。

使用的红外接收器型号是ROHM的RPM7238-H8R，该型号的载波频率是 37.9KHZ。红外遥控分为两种编码方式：PWM编码（脉宽调制）和PPM编码（脉冲位置调制）。该型号采用的是PPM方式。关于这两种方式的不同，可以在网上搜索一下。PPM遥控编码脉冲由前导码、16位地址码（8位地址码、8 位地址码的反码）和16位操作码（8位操作码、8位操作码的反码）组成。

PPM通过脉冲串之间的时间间隔来实现信号的调制。逻辑“0”是由0.56ms的38KHZ载波和0.560ms的无 载波间隔组成；逻辑“1”是由0.56ms的38KHZ载波和1.68ms的无载波间隔组成；结束位是0.56ms的38K载波。

硬件原理图

红外接收器的输出引脚接到LPC1752的P0.3口，使用3.3V供电。下图是RPM7238与LPC1752的连接图。

红外接收器接收到红外线信号后，经过内部的放大、检波、整型后滤除了37.9KHz的载波，输出接收到的信号。下图是红外接收器的内部原理框图。

输出的有用信号与原PPM编码信号相反，如下图接收到的波形与对应输出波形：

程序介绍

项目中使用LPC1752的P0.3口连接到红外接收器，因此设定P0.3为输入引脚。每隔20uS读取红外接收器的引脚状态，RPM7238没有接收到红外信号时输出高电平，接收到红外信号的引导程序后，输出低电平，然后进入解码函数。

解码过程中共有六种状态：

1. typedef enum _IR_STATE {
   
2.         IR_STATE_IDLE,
   
3.         IR_STATE_BOOT,
   
4.         IR_STATE_RECV_HIGH,
   
5.         IR_STATE_RECV_LOW,
   
6.         IR_STATE_RECV_OK,
   
7.         IR_STATE_ERROR
   
8. } IR_STATE;

复制代码

IR_STATE_IDLE：空闲状态，等待接收红外遥控的引导程序

IR_STATE_BOOT：引导程序处理，如果引导程序持续时间4.5ms，则转到接收程序。如果持续时间是2.25ms，则判定为重复信号。

IR_STATE_RECV_HIGH：接收数据的高电平处理，等待数据的低电平

IR_STATE_RECV_LOW：接收数据的低电平处理，如果低电平持续时间等于1.5ms，则接收的数据为'1'，如果持续的时间为0.5ms，则接收的数据为'0';

IR_STATE_RECV_OK:接收数据完成，置位标志位IRKey_Recv_Finished。

IR_STATE_ERROR：数据处理过程中出错，返回空闲状态。

以下代码是解码函数：

1. void ReadIRKeyState()
   
2. {
   
3.         switch(IR_Recv_State)
   
4.         {
   
5.         case IR_STATE_IDLE: // idle, wait for boot code
   
6.                 if( LPC_GPIO0->FIOPIN & (1ul << PIN_IR_KEY))
   
7.                 {
   
8.                         if( IRKey_Pin_Value_Count >= 425 )
   
9.                         {
   
10.                                 IR_Recv_State = IR_STATE_BOOT;
    
11.                                 IRKey_Pin_Value_Count = 0;
    
12.                         }
    
13.                         else
    
14.                         {
    
15.                                 if( IRKey_Pin_Value_Count != 0 )
    
16.                                 {
    
17.                                         IRKey_Pin_Value_Count = 0;
    
18.                                         IRKey_Recv_Count = 0;
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.                 else
    
23.                 {
    
24.                         if( IRKey_Pin_Value_Count <= 1000)
    
25.                                 IRKey_Pin_Value_Count++;
    
26.                 }
    
27.                 break;
    
28.         case IR_STATE_BOOT: // boot code
    
29.                 if( LPC_GPIO0->FIOPIN & (1ul << PIN_IR_KEY))
    
30.                 {
    
31.                         IRKey_Pin_Value_Count++;
    
32.                         if( IRKey_Pin_Value_Count >= 250 )
    
33.                         {
    
34.                                 IR_Recv_State = IR_STATE_IDLE;
    
35.                                 IRKey_Pin_Value_Count = 0;
    
36.                         }
    
37.                 }
    
38.                 else
    
39.                 {
    
40.                         // check boot code either recv data or repeat code
    
41.                         if(IRKey_Pin_Value_Count >= 200 && IRKey_Pin_Value_Count < 250)
    
42.                         {
    
43.                                 IRKey_Recv_State = 1;
    
44.                                 IR_Recv_State = IR_STATE_RECV_LOW;
    
45.                                 IRKey_Recv_Number = 0;
    
46.                                 IRKey_Pin_Value_Count = 0;
    
47.                                 IRKey_Recv_Count = 0;
    
48.                         }
    
49.                         else if(IRKey_Pin_Value_Count >= 85 && IRKey_Pin_Value_Count < 200)
    
50.                         {
    
51.                                 IRKey_Recv_Ready = 1;
    
52. 
    
53.                                 if( IRKey_Recv_Count < 1000 )
    
54.                                         IRKey_Recv_Count ++;
    
55.                         }
    
56.                         else
    
57.                         {
    
58.                                 IR_Recv_State = IR_STATE_IDLE;
    
59.                                 IRKey_Pin_Value_Count = 0;
    
60.                         }
    
61.                 }
    
62.                 break;
    
63.         case IR_STATE_RECV_LOW: // recv data low
    
64.                 if( LPC_GPIO0->FIOPIN & (1ul << PIN_IR_KEY))
    
65.                 {
    
66.                         if( IRKey_Pin_Value_Count >= 10 )
    
67.                         {
    
68.                                 IR_Recv_State = IR_STATE_RECV_HIGH;
    
69.                                 IRKey_Pin_Value_Count = 0;
    
70.                         }
    
71.                         else
    
72.                         {
    
73.                                 IR_Recv_State = IR_STATE_IDLE;
    
74.                                 IRKey_Pin_Value_Count = 0;
    
75.                         }
    
76.                 }
    
77.                 else
    
78.                 {
    
79.                         IRKey_Pin_Value_Count++;
    
80.                         if(IRKey_Pin_Value_Count >= 100 )
    
81.                         {
    
82.                                 IR_Recv_State = IR_STATE_IDLE;
    
83.                                 IRKey_Pin_Value_Count = 0;
    
84.                         }
    
85.                 }
    
86.                 break;
    
87.         case IR_STATE_RECV_HIGH: // recv high
    
88.                 if( LPC_GPIO0->FIOPIN & (1ul << PIN_IR_KEY))
    
89.                 {
    
90.                         IRKey_Pin_Value_Count++;
    
91.                         if(IRKey_Pin_Value_Count >= 100 )
    
92.                         {
    
93.                                 IR_Recv_State = IR_STATE_IDLE;
    
94.                                 IRKey_Pin_Value_Count = 0;
    
95.                         }
    
96.                 }
    
97.                 else
    
98.                 {
    
99.                         if( IRKey_Recv_State == 1)
    
100.                         {
     
101.                                 IRKey_Recv_Value <<= 1;
     
102.                                 if(IRKey_Pin_Value_Count >= 50 && IRKey_Pin_Value_Count < 85)
     
103.                                         IRKey_Recv_Value += 1;
     
104.                                 else if(IRKey_Pin_Value_Count >= 10 && IRKey_Pin_Value_Count < 50)
     
105.                                         IRKey_Recv_Value += 0;
     
106. 
     
107.                                 IRKey_Recv_Number++;
     
108.                                 if( IRKey_Recv_Number >= 32)
     
109.                                         IR_Recv_State = IR_STATE_RECV_OK;
     
110.                                 else
     
111.                                 {
     
112.                                         IR_Recv_State = IR_STATE_RECV_LOW;
     
113.                                         IRKey_Pin_Value_Count = 0;
     
114.                                 }
     
115.                         }
     
116.                         else
     
117.                         {
     
118.                                 IR_Recv_State = IR_STATE_IDLE;
     
119.                                 IRKey_Pin_Value_Count = 0;
     
120.                         }
     
121.                 }
     
122.                 break;
     
123.         case IR_STATE_RECV_OK:
     
124.                 IRKey_Recv_Finished = 1;
     
125.                 IR_Recv_State = IR_STATE_IDLE;
     
126.                 IRKey_Pin_Value_Count = 0;
     
127.                 break;
     
128.         }
     
129. }

复制代码

主函数每次查询该标志位，如果为1，则进入键值处理函数。接收数据的后16位是具体的键值。

1. void IRKey_Recv_App()
   
2. {
   
3.         uint8_t Key_value;
   
4.         uint8_t Recv_buf, Recv_buf_reverse;
   
5. 
   
6.         if(IRKey_Recv_Finished == 1)
   
7.         {
   
8.                 IRKey_Recv_Finished = 0;
   
9. 
   
10.                 Recv_buf = IRKey_Recv_Value >> 24;
    
11.                 Recv_buf_reverse = (IRKey_Recv_Value >> 16) & 0xFF;
    
12. //                if(Recv_buf == (uint8_t)~Recv_buf_reverse)
    
13.                 if(Recv_buf == 0xE1 && Recv_buf_reverse == 0xA2)
    
14.                 {
    
15.                         Recv_buf = IRKey_Recv_Value >> 8;
    
16.                         Recv_buf_reverse = IRKey_Recv_Value & 0xFF;
    
17.                         if( Recv_buf == (uint8_t)~Recv_buf_reverse)
    
18.                         {
    
19.                                 Key_value = Recv_buf;
    
20.                         }
    
21.                 }
    
22.         }
    
23. }

复制代码