红外解码程序：格力YB0F2、YAD0F，美的R05d，其他NEC

cx_star

刷到了这个帖子都说守时的人靠谱，但首先你得有个走时精准的钟表（RX8025应用），买了RX8025改了自己的时钟，又想要一个频率计
又搜到了这个帖子：STC89C52单片机等精度频率计（带仿真），没有M币啊


发个自己改的程序，骗点打赏
共三个版本：参考版本、记录原始定时器值的第二个版本、优化ram版本，可识别格力YB0F2、YAD0F，美的R05d，其他NEC等各种红外

原始程序：格力空调遥控器(YB0F2)单片机解码程序，复制是乱码，清楚乱码后的效果：

1. /* 格力空调遥控器(YB0F2)解码      
   
2.     CUP:STC89C52RC     晶振：11.0569MHz
   
3.     直接由串口输出      波特率：57600
   
4. ************************************   说 明 **********************************************
   
5. 解码方式：
   
6. 以一个9ms的低电平和4.5ms的高电平为引导码，后跟35位二进制代码 接着0.565ms低电平和20MS高电平跟32位二进制代码
   
7. 前4个字节每个字节为8位，中间1个字节只有3位，接着为20MS高电平，跟后4个字节每个字节为8位
   
8.     以低电平为0.565ms、高电平为0.56ms、 周期为1.125ms的组合表示"0"；
   
9.     以低电平为0.565ms、高电平为1.685ms、周期为2.25ms的组合表示"1"。;
   
10. 注意：经过红外接收头解调后单片机接收到的高低电平是和遥控器发射时是相反的一个过程
    
11. * 兼容 1T-12T单片机中断方式红外接收数据，并通过串口发送
    
12. 程序编辑： lbq691477940         22/07/2011
    
13. 
    
14. */
    
15. /*******************************************************************************************/
    
16. #include "STC_NEW_8051.H"
    
17. #include "intrins.h"
    
18. #include "stdio.h"
    
19. typedef unsigned char uint8;
    
20. #define FOSC 22118400L
    
21. #define T1RE (256-FOSC/12/19200/32)
    
22. #define T0MS30 1/FOSC*12*1000*30
    
23. 
    
24. sbit Ir_Pin = P3^2;
    
25. sbit LED = P1^0;
    
26. sbit LED1 = P1^1;
    
27. sbit LED2 = P1^2;
    
28. sbit LED3 = P1^3;
    
29. uint8 Ir_Buf[9]; //用于保存解码结果
    
30. uint8 r,t;
    
31. unsigned int tttt;
    
32. 
    
33. /*******************************************************************************************
    
34. * 外部中断0初始化
    
35. /*******************************************************************************************/
    
36. void int1_init(void)
    
37. {
    
38.         IT0 = 1; //下降沿有效
    
39.         EX0 = 1;
    
40.         EA = 1;
    
41. }
    
42. void T0Init(){
    
43.         TMOD |= 0x01;//工作模式：16位重装
    
44. }
    
45. void Delay500ms()                //@22.1184MHz
    
46. {
    
47.         unsigned char i, j, k;
    
48. 
    
49.         _nop_();
    
50.         i = 8;
    
51.         j = 1;
    
52.         k = 243;
    
53.         do
    
54.         {
    
55.                 do
    
56.                 {
    
57.                         while (--k);
    
58.                 } while (--j);
    
59.         } while (--i);
    
60. }
    
61. /*******************************************************************************************
    
62. * UART初始化
    
63. /*******************************************************************************************/
    
64. void UartInit(void)                //115200bps@22.1184MHz
    
65. {
    
66.         SCON = 0x50;                //8位数据,可变波特率
    
67.         AUXR &= 0xBF;                //定时器1时钟为Fosc/12,即12T
    
68.         AUXR &= 0xFE;                //串口1选择定时器1为波特率发生器
    
69.         TMOD &= 0x0F;                //设定定时器1为16位自动重装方式
    
70.         TL1 = 0xFC;                //设定定时初值
    
71.         TH1 = 0xFF;                //设定定时初值
    
72.         ET1 = 0;                //禁止定时器1中断
    
73.         TR1 = 1;                //启动定时器1
    
74. }
    
75. 
    
76. /******************************   延时21ms子程序   ************************************/
    
77. void Delay20ms()                //@22.1184MHz
    
78. {
    
79.         unsigned char i, j;
    
80. 
    
81.         i = 72;
    
82.         j = 181;
    
83.         do
    
84.         {
    
85.                 while (--j);
    
86.         } while (--i);
    
87. }
    
88. 
    
89. /*******************************************************************************************/
    
90. /*******************************************************************************************
    
91. * UART发送一字节
    
92. /*******************************************************************************************/
    
93. 
    
94. void UART_Send_Byte_Inverted (uint8 dat)
    
95. {
    
96.         uint8 t,i;
    
97.         
    
98.         for(i=0;i<8;i++){
    
99.                 t += dat&1;
    
100.                 t <<= 1;
     
101.                 dat >>= 1;
     
102.         }
     
103.         SBUF = t;
     
104.         while (TI == 0);
     
105.                 TI = 0;
     
106. }
     
107. void UART_Send_Byte (uint8 dat)
     
108. {
     
109.         SBUF = dat;
     
110.         while (TI == 0);
     
111.                 TI = 0;
     
112. }
     
113. void UART_Send_String(uint8 *dat)
     
114. {
     
115.         while(*dat!=0)
     
116.                 UART_Send_Byte(*dat++);
     
117. }
     
118. char putchar(char c)
     
119. {
     
120.         UART_Send_Byte(c);
     
121.         return c;
     
122. }
     
123. 
     
124. /*******************************************************************************************
     
125. * 获取低电平时间/
     
126. /*******************************************************************************************/
     
127. unsigned int Ir_Get_Low()
     
128. {
     
129.         TL0 = 0;
     
130.         TH0 = 0;
     
131.         TR0 = 1;
     
132.         //while (!Ir_Pin && (TH0 & 0x80)==0);//一直计到Ir_Pin不等0与计到大于1.085*32768=35553.28us
     
133.         while (!Ir_Pin && (TH0<0xF0) )     // 1/22118400*12*0xf000 = 33333.33us
     
134.                 ;
     
135.         TR0 = 0;
     
136.         return (TH0 * 256 + TL0); //返回T1 高八位和低八位计数值
     
137. }
     
138. 
     
139. /*******************************************************************************************
     
140. * 获取高电平时间
     
141. /*******************************************************************************************/
     
142. unsigned int Ir_Get_High()
     
143. {
     
144.         TL0 = 0;
     
145.         TH0 = 0;
     
146.         TR0 = 1;
     
147.         //while (Ir_Pin && (TH0 & 0x80)==0);//一直计到Ir_Pin不等1与计到大于1.085*32768=35553.28us
     
148.         while (Ir_Pin && (TH0<0xF0) )
     
149.                 ;
     
150.         TR0 = 0;
     
151.         return (TH0 * 256 + TL0); //返回T1 高八位和低八位计数值
     
152. }
     
153. /**********************************  主函数  ****************************************/
     
154. //#define MY_DEBUG
     
155. main()
     
156. {
     
157.         int i=1;
     
158.         UartInit();
     
159.         int1_init();
     
160.         T0Init();
     
161.         while(i--){
     
162.                 Delay500ms();
     
163.                 UART_Send_String("hello\r\n");
     
164.                 LED = ~LED;
     
165.         }
     
166.         while (1){
     
167.                 #ifdef MY_DEBUG
     
168.                 if(r!=0) {
     
169.                         t = r;
     
170.                         printf("r:%bx %u\r\n",t, tttt);
     
171.                         r=0;
     
172.                 }
     
173.                 #endif
     
174.         };
     
175. }
     
176. /**************************** 外部中断0解码函数 ****************************************/
     
177. // 1/11.0569*12 = 1.085295155061545
     
178. // 1/22.1184*12 = 0.5425347222222222
     
179. 
     
180. // 8500us 8500*22.1184/12 15667.2
     
181. #define us8500 15667
     
182. // 9500us 22.1184/12*9500 17510.4
     
183. #define us9500 17510
     
184. // 4000us 22.1184/12*4000 7372.8
     
185. #define us4000 7372
     
186. // 5000us 22.1184/12*5000 9216
     
187. #define us5000 9216
     
188. //  200us 22.1184/12*200  368.64
     
189. #define us200 368
     
190. //  800us 22.1184/12*800  1474.56
     
191. #define us800 1474
     
192. // 2000us 22.1184/12*2000 3686.4
     
193. #define us2000 3686
     
194. // 1120us 22.1184/12*1120 2064.384
     
195. #define us1120 2064
     
196. // 19ms   22.1184/12*19000 35020.8
     
197. #define ms19 35020
     
198. // 21ms   22.1184/12*21000 38707.2
     
199. #define ms21 38707
     
200. 
     
201. void int1_isr() interrupt 0
     
202. {
     
203.         unsigned int temp=0;
     
204.         char i,j;
     
205.         LED1 = ~LED1;
     
206.         temp = Ir_Get_Low();
     
207.         if ((temp < us8500) || (temp > us9500))    //引导脉冲低电平8500~9500us (1/11.0569*12*8500)
     
208.         {
     
209.                 #ifdef MY_DEBUG
     
210.                 r = 1;
     
211.                 tttt = temp;
     
212.                 #endif
     
213.                 return;   //不在9ms范围则说明出错 //1.085*7833=8498us ~ 1.085*8755=9499us
     
214.         }
     
215.         temp = Ir_Get_High();
     
216.         if ((temp < us4000) || (temp > us5000))    //引导脉冲高电平4000~5000us
     
217.         {  
     
218.                 #ifdef MY_DEBUG
     
219.                 r = 2;
     
220.                 tttt = temp;
     
221.                 #endif
     
222.                 return;    //不在4ms范围则说明出错 //1.085*3686=3999us ~ 1.085*4608=4999us
     
223.         }
     
224.         /*******************************************************************************************/
     
225.         for (i = 0; i < 4; i++)      //4个字节
     
226.         {
     
227.                 for (j = 0; j < 8; j++)     //每个字节8位
     
228.                 {
     
229.                         temp = Ir_Get_Low();
     
230.                         if ((temp < us200) || (temp > us800))  //200~800us
     
231.                         {
     
232.                                 #ifdef MY_DEBUG
     
233.                                 r = 3;
     
234.                                 tttt = temp;
     
235.                                 #endif
     
236.                                 return; //不在这范围则说明出错 //1.085*200=217us ~ 1.085*800=868us
     
237.                         }
     
238.                         temp = Ir_Get_High();
     
239.                         if ((temp < us200) || (temp > us2000))  //200~2000us
     
240.                         {   
     
241.                                 #ifdef MY_DEBUG
     
242.                                 r = 4;
     
243.                                 tttt = temp;
     
244.                                 #endif
     
245.                                 return; //不在这范围则说明出错 //1.085*200=217us
     
246.                         }
     
247.                         Ir_Buf[i] >>= 1;     //先将它自动补0
     
248.                         if (temp > us1120) //1120us   //1.085*1032=1119us
     
249.                                 Ir_Buf[i] |= 0x80;    //如果大于1119us才将它设为1
     
250.                 }
     
251.         }
     
252. /**************************   第5个字节只有三位故只读其低三位即可 ************************/
     
253.         for (i = 4; i <= 4; i++)      //1个字节
     
254.         {
     
255.                 Ir_Buf[i] = 0;
     
256.                 for (j = 0; j < 3; j++)     //每个字节8位
     
257.                 {
     
258.                         temp = Ir_Get_Low();
     
259.                         if ((temp < us200) || (temp > us800))  //200~800us
     
260.                         {  
     
261.                                 #ifdef MY_DEBUG
     
262.                                 r = 5;
     
263.                                 tttt = temp;
     
264.                                 #endif
     
265.                                 return; //不在这范围则说明出错 //1.085*200 = 217us ~ 1.085*800 = 868us
     
266.                         }
     
267.                         temp = Ir_Get_High();
     
268.                         if ((temp < us200) || (temp > us2000))  //200~2000us
     
269.                         {  
     
270.                                 #ifdef MY_DEBUG
     
271.                                 r = 6;
     
272.                                 tttt = temp;
     
273.                                 #endif
     
274.                                 return; //不在这范围则说明出错 //1.085*200 = 217us ~ 1.085*2000 = 2170us
     
275.                         }
     
276.                         Ir_Buf[i] <<= 1;     //先将它自动补0
     
277.                         if (temp > us1120)  //1120us   //1.085*1032 = 1119us
     
278.                                 Ir_Buf[i] |= 0x01;    //如果大于1119us才将它设为1
     
279.                 }
     
280.         }
     
281. /*******************************************************************************************/
     
282. 
     
283.         temp = Ir_Get_Low();
     
284.         if ((temp < us200) || (temp > us800))  //200~800us
     
285.         {   
     
286.                 #ifdef MY_DEBUG
     
287.                 r = 7;
     
288.                 tttt = temp;
     
289.                 #endif
     
290.                 return; //不在565us范围则说明出错 //1.085*200 = 217us ~ 1.085*800 = 868us
     
291.         }
     
292.         //delay21ms(); //实测波形只20ms但如果只延时20ms读出会出错故延时21ms
     
293.         //Delay20ms();
     
294.         temp = Ir_Get_High();
     
295.         if ((temp < ms19) || (temp > ms21))   //19~21ms
     
296.         {
     
297.                 #ifdef MY_DEBUG
     
298.                 r = 8;
     
299.                 tttt = temp;
     
300.                 #endif
     
301.                 return;   //不在这范围则说明出错 //1.085*17498 = 18985us ~ 1.085*19354 = 20999us
     
302.         }
     
303.         /*******************************************************************************************/
     
304.         for (i = 5; i < 9; i++)       //4个字节3
     
305.         {
     
306.                 for (j = 0; j < 8; j++)     //每个字节8位8
     
307.                 {
     
308.                         temp = Ir_Get_Low();
     
309.                         if ((temp < us200) || (temp > us800))  //200~800us
     
310.                         {
     
311.                                 #ifdef MY_DEBUG
     
312.                                 r = 9;
     
313.                                 tttt = temp;
     
314.                                 #endif
     
315.                                 return; //不在565us范围则说明出错 //1.085*200 = 217us ~ 1.085*800 = 868us
     
316.                         }
     
317.                         temp = Ir_Get_High();
     
318.                         if ((temp < us200) || (temp > us2000))  //200~2000us
     
319.                         {
     
320.                                 #ifdef MY_DEBUG
     
321.                                 r = 10;
     
322.                                 tttt = temp;
     
323.                                 #endif
     
324.                                 return; //不在这范围则说明出错 //1.085*200 = 217us ~ 1.085*2000 = 2170us
     
325.                         }
     
326.                         Ir_Buf[i] >>= 1;     //先将它自动补0
     
327.                         if (temp > us1120)  //1120us   //1.085*1032 = 1119us
     
328.                                 Ir_Buf[i] |= 0x80;    //如果大于1119us才将它设为1
     
329.                 }
     
330.         }
     
331. /*******************************************************************************************/
     
332.         for(i = 0;i < 9;i++)             //通过串口将代码发出
     
333.         {
     
334.                 UART_Send_Byte_Inverted(Ir_Buf[i]);    //将9个字节的遥控键值通过串口输出
     
335.         }
     
336. }

复制代码

修改后的第一个版本（只记录定时器原始数据）：

1. #include "STC_NEW_8051.H"
   
2. #include "intrins.h"
   
3. #include "stdio.h"
   
4. typedef unsigned char uint8;
   
5. 
   
6. sbit Ir_Pin = P3^2;        // 外部中断0（INT0）
   
7. 
   
8. //YB0F2编码   9ms+4.5ms  35位(0.565ms+0.56ms/1.685)  0.565ms+20ms  32位  [0.565ms+Nms]  2+70+2+64 = 138 (+2)
   
9. //YAD0F编码   YB0F2  0.565ms+40ms  YB0F2    [0.565ms+Nms]                               138+2+138 = 278 (+2)
   
10. #define IR_BUF_SIZE 300            
    
11. xdata unsigned int Ir_Buf_PWM[IR_BUF_SIZE]; //用于保存解码结果
    
12. unsigned int BUF_i;
    
13. 
    
14. void int1_init(void)
    
15. {
    
16.     IT0 = 1; //下降沿有效
    
17.     EX0 = 1;
    
18.     EA = 1;
    
19. }
    
20. void T0Init(){
    
21.     TMOD |= 0x01;//工作模式：16位重装
    
22. }
    
23. void Delay500ms()        //@22.1184MHz
    
24. {
    
25.     unsigned char i, j, k;
    
26. 
    
27.     _nop_();
    
28.     i = 8;
    
29.     j = 1;
    
30.     k = 243;
    
31.     do
    
32.     {
    
33.         do
    
34.         {
    
35.             while (--k);
    
36.         } while (--j);
    
37.     } while (--i);
    
38. }
    
39. /*******************************************************************************************
    
40. * UART初始化
    
41. /*******************************************************************************************/
    
42. void UartInit(void)        //115200bps@11.0592MHz
    
43. {
    
44.     SCON = 0x50;        //8位数据,可变波特率
    
45.     AUXR &= 0xBF;        //定时器1时钟为Fosc/12,即12T
    
46.     AUXR &= 0xFE;        //串口1选择定时器1为波特率发生器
    
47.     TMOD &= 0x0F;        //设定定时器1为16位自动重装方式
    
48.     TL1 = 0xFE;        //设定定时初值
    
49.     TH1 = 0xFF;        //设定定时初值
    
50.     ET1 = 0;        //禁止定时器1中断
    
51.     TR1 = 1;        //启动定时器1
    
52. }
    
53. 
    
54. void UART_Send_Byte (uint8 dat)
    
55. {
    
56.     SBUF = dat;
    
57.     while (TI == 0);
    
58.         TI = 0;
    
59. }
    
60. void UART_Send_String(uint8 *dat)
    
61. {
    
62.     while(*dat!=0)
    
63.         UART_Send_Byte(*dat++);
    
64. }
    
65. char putchar(char c)
    
66. {
    
67.     UART_Send_Byte(c);
    
68.     return c;
    
69. }
    
70. 
    
71. /*******************************************************************************************
    
72. * 获取低电平时间/
    
73. /*******************************************************************************************/
    
74. unsigned int Ir_Get_Low(uint8 maxTH0)
    
75. {
    
76.     TL0 = 0;
    
77.     TH0 = 0;
    
78.     TR0 = 1;
    
79.     while (!Ir_Pin && (TH0<maxTH0) )
    
80.         ;
    
81.     TR0 = 0;
    
82.     return (TH0 * 256 + TL0);
    
83. }
    
84. 
    
85. /*******************************************************************************************
    
86. * 获取高电平时间
    
87. /*******************************************************************************************/
    
88. unsigned int Ir_Get_High(uint8 maxTH0)
    
89. {
    
90.     TL0 = 0;
    
91.     TH0 = 0;
    
92.     TR0 = 1;
    
93.     while (Ir_Pin && (TH0<maxTH0) )
    
94.         ;
    
95.     TR0 = 0;
    
96.     return (TH0 * 256 + TL0);
    
97. }
    
98. /**********************************  主函数  ****************************************/
    
99. //#define MY_DEBUG
    
100. main()
     
101. {
     
102.     int i=1;
     
103.     UartInit();
     
104.     int1_init();
     
105.     T0Init();
     
106.     BUF_i = 0;
     
107.     while(i--){
     
108.         Delay500ms();
     
109.         Delay500ms();
     
110.         UART_Send_String("hello\r\n");
     
111.     }
     
112.     while (1){
     
113.         if(BUF_i!=0){
     
114.             printf("BUF_i:%u\r\n",BUF_i);
     
115.             for(i=0;i<BUF_i;i++)
     
116.                 printf("%u ",Ir_Buf_PWM[i]);
     
117.             printf("\r\n");
     
118.             BUF_i = 0;
     
119.         }
     
120.     };
     
121. }
     
122. 
     
123. //#define FOSC_M 22.1184F
     
124. #define FOSC_M 11.0569F
     
125. // 1/11.0569*12 = 1.085295155061545
     
126. // 1/22.1184*12 = 0.5425347222222222
     
127. // max 65535/22.1184*12  35555us
     
128. // max 65535/11.0569*12  71124us
     
129. typedef unsigned int uint;
     
130. #define us9500 (uint)(9500*FOSC_M/12)
     
131. #define us8500 (uint)(8500*FOSC_M/12)
     
132. #define us5000 (uint)(5000*FOSC_M/12)
     
133. #define us4000 (uint)(4000*FOSC_M/12)
     
134. #define us2000 (uint)(2000*FOSC_M/12)
     
135. #define us200  (uint)(200*FOSC_M/12)
     
136. #define ms21   (uint)(21000*FOSC_M/12)
     
137. #define ms42   (uint)(42000*FOSC_M/12)
     
138. 
     
139. void int1_isr() interrupt 0
     
140. {
     
141.     unsigned int temp=0;
     
142.    
     
143.     if(BUF_i!=0)
     
144.         return;
     
145.    
     
146.     temp = Ir_Get_Low(us9500>>8);
     
147.     if ((temp < us8500) )   
     
148.     {
     
149.         return;   
     
150.     }
     
151.     Ir_Buf_PWM[BUF_i++] = temp;
     
152.     temp = Ir_Get_High(us5000>>8);
     
153.     if ((temp < us4000) )   
     
154.     {  
     
155.         return;   
     
156.     }
     
157.     Ir_Buf_PWM[BUF_i++] = temp;
     
158. 
     
159.     while(1){
     
160.         temp = Ir_Get_Low(us9500>>8);
     
161.         if ((temp < us200) )   
     
162.         {
     
163.             return;   
     
164.         }
     
165.         Ir_Buf_PWM[BUF_i++] = temp;
     
166.         temp = Ir_Get_High(ms42>>8);
     
167.         if ((temp < us200) )   
     
168.         {  
     
169.             return;   
     
170.         }
     
171.         Ir_Buf_PWM[BUF_i++] = temp;
     
172.     }
     
173. }

复制代码

上面一个版本挺要RAM的，又修改了一个版本：//格力
//YB0F2编码   9ms+4.5ms  35位(0.565ms+0.56ms/1.685)  0.565ms+20ms  32位  [0.565ms+Nms]  2+70+2+64 = 138 (+2)
//YAD0F编码   YB0F2  0.565ms+40ms  YB0F2    [0.565ms+Nms]                               138+2+138 = 278 (+2)
//美的
//R05d                L,A,A’,B,B’,C,C’, S, L,A,A’,B,B’,C,C’
//                        4.4ms+4.4ms 2*8*3(0.54ms+0.54ms/1.62ms） 0.54ms+5.22ms 4.4ms+4.4ms 2*8*3(0.54ms+0.54ms/1.62ms） 0.54ms+Nms
//NEC遥控器
//                        9ms低+4.5ms高  32位(0.58+0.55/1.66)  0.565ms+40ms  (9ms低+2.25ms高+0.56ms低+高 )

1. uint8 Ir_Buf_PWM[IR_BUF_SIZE]; //用于保存解码结果

复制代码

1. uint Ir_Get_Low(uint8 maxTH0)
   
2. {
   
3.         uint r;
   
4.         TL0 = 0;
   
5.         TH0 = 0;
   
6.         TR0 = 1;
   
7.         while (!Ir_Rec && (TH0<=maxTH0) )
   
8.                 ;
   
9.         TR0 = 0;
   
10.         r = TH0;
    
11.         r <<= 8;
    
12.         r += TL0;
    
13.         return r;
    
14. }
    
15. 
    
16. uint Ir_Get_High(uint8 maxTH0)
    
17. {
    
18.         uint r;
    
19.         TL0 = 0;
    
20.         TH0 = 0;
    
21.         TR0 = 1;
    
22.         while (Ir_Rec && (TH0<=maxTH0) )
    
23.                 ;
    
24.         TR0 = 0;
    
25.         r = TH0;
    
26.         r <<= 8;
    
27.         r += TL0;
    
28.         return r;
    
29. }
    
30. //#define FOSC_M 22.1184F
    
31. #define FOSC_M 11.0569F
    
32. // 1/11.0569*12 = 1.085295155061545
    
33. // 1/22.1184*12 = 0.5425347222222222
    
34. // max 65535/22.1184*12  35555us
    
35. // max 65535/11.0569*12  71124us
    
36. // 256/11.0569*12        277.8355596957556
    
37. // feff/11.0569*12  5903.9us
    
38. #define us9500 (uint)(9500*FOSC_M/12)        //8753.379166666667
    
39. #define us8500 (uint)(8500*FOSC_M/12)   //7831.970833333333
    
40. #define us6000 (uint)(6000*FOSC_M/12)
    
41. #define us5500 (uint)(5500*FOSC_M/12)
    
42. #define us5000 (uint)(5000*FOSC_M/12)
    
43. #define us4000 (uint)(4000*FOSC_M/12)
    
44. #define us2020 (uint)(2020*FOSC_M/12)     //1861.244833333333
    
45. #define us1000 (uint)(1000*FOSC_M/12)
    
46. #define us600  (uint)(600*FOSC_M/12)
    
47. #define us200  (uint)(200*FOSC_M/12)
    
48. #define ms10   (uint)(10000*FOSC_M/12)
    
49. #define ms21   (uint)(21000*FOSC_M/12)
    
50. #define ms38   (uint)(38000*FOSC_M/12)
    
51. #define ms42   (uint)(42000*FOSC_M/12)
    
52. #define ms50   (uint)(50000*FOSC_M/12)
    
53. #define ms60   (uint)(60000*FOSC_M/12)     //
    
54. 
    
55. void int1_isr() interrupt 2
    
56. {
    
57.         uint8 i=0;
    
58.         if(BUF_i!=0)
    
59.                 return;
    
60.         if(int1_err!=0)
    
61.                 return;
    
62.         IR_Low = Ir_Get_Low(us9500>>8);
    
63.         if ( IR_Low < us4000 )   
    
64.         {
    
65.                 return;   
    
66.         }
    
67.         IR_High = Ir_Get_High(us5000>>8);
    
68.         if ( IR_High < us4000 )   
    
69.         {  
    
70.                 return;   
    
71.         }
    
72.         while( BUF_i < IR_BUF_SIZE )
    
73.         {
    
74.                 IR_Low = Ir_Get_Low(us9500>>8);
    
75.                 if ((IR_Low < us200) )   
    
76.                 {
    
77.                         //DQ = ~DQ;
    
78.                         int1_err = 1;               
    
79.                         return;   
    
80.                 }
    
81.                 IR_High = Ir_Get_High(ms50>>8);
    
82.                 if ((IR_High < us200) )   
    
83.                 {
    
84.                         int1_err = 2;
    
85.                         return;   
    
86.                 }
    
87.                 if(IR_High>=ms50){   //可能为结尾或者重复编码
    
88.                         Ir_Get_High(ms60>>8);
    
89.                         if(IR_High>=ms60|0xff00){
    
90.                                 //int1_err = 3;
    
91.                                 return;      //结尾
    
92.                         }
    
93.                         //重复
    
94.                 }
    
95.                 if(IR_High>=us2020)//功能位
    
96.                 {
    
97.                         BUF_i++;
    
98.                         Ir_Buf_PWM[BUF_i] = 0;
    
99.                         i=7;
    
100.                 }
     
101.                 i++;
     
102.                 if(i>8)
     
103.                 {
     
104.                         BUF_i++;
     
105.                         Ir_Buf_PWM[BUF_i] = 0;
     
106.                         i=1;
     
107.                 }
     
108.                 Ir_Buf_PWM[BUF_i] <<= 1;
     
109.                 //Ir_send = ~Ir_send;
     
110.                 if( IR_High > (IR_Low+us600) ){
     
111.                         Ir_Buf_PWM[BUF_i] |= 0x01;
     
112.                 }
     
113.         }
     
114. }

复制代码

补充内容 (2020-8-31 14:24):
程序效果见5楼
https://www.mydigit.cn/forum.php ... 734&pid=5876234

devcang

解过几个，发现不是简单的数值，中间间隔的长短也要差不多才可以成功。

40560335

申请买过几只淘宝卖的个人DIY产品：空调来电自动开机器，使用效果还不错，可以录制各种品牌空调的遥控器编码

netbeetle

几乎所有的红外遥控都遵循一个大的格式，就是引导码+地址码+地址码反码+数据码+数据码反码的形式，当然数据的长度各不相同。用逻辑分析仪把波形读出来，很容易就分析出来了。

cx_star

写程序时的调试过程没有截图，刷回以前的程序，截个图

YAD0F：
//格力
//YB0F2编码   9ms+4.5ms  35位(0.565ms+0.56ms/1.685)  0.565ms+20ms  32位  [0.565ms+Nms]  2+70+2+64 = 138 (+2)
//YAD0F编码   YB0F2  0.565ms+40ms  YB0F2    [0.565ms+Nms]                               138+2+138 = 278 (+2)


波形图全貌



波形图第一部分YB0F2

波形图第二部分YB0F2



使用程序二串口输出



人工分析



程序三输出


输出说明：

cx_star

devcang 发表于 2020-8-28 12:38
解过几个，发现不是简单的数值，中间间隔的长短也要差不多才可以成功。 ...

有一个USB的逻辑分析仪，就容易多了

cx_star

40560335 发表于 2020-8-30 00:14
申请买过几只淘宝卖的个人DIY产品：空调来电自动开机器，使用效果还不错，可以录制各种品牌空调的遥控器编 ...

我也是想自己DIY一个类似的东西，8PIN的STC单片机，一个红外接收，一个红外发射，还带个DS18B20，以及两个按键。

cx_star

netbeetle 发表于 2020-8-31 09:10
几乎所有的红外遥控都遵循一个大的格式，就是引导码+地址码+地址码反码+数据码+数据码反码的形式，当然数据 ...

反码来反码去的就费神了，我就直接获取原始数据，然后照样发出去，不关心具体谁是谁的反码

qidao

楼主  如果能 改造 安卓 那些万能遥控 APP，  接收 遥控器信号  并 翻译显示出 编码类型 和 数据结构，  那些 带 红外遥控功能的手机 就是  随身  红外遥控 检测器了， 时常逛地摊 ，碰到满多遥控器，不知遥控代码，  有些电器原装遥控都要百元以上。

cx_star

qidao 发表于 2020-8-31 15:26
楼主  如果能 改造 安卓 那些万能遥控 APP，  接收 遥控器信号  并 翻译显示出 编码类型 和 数据结构，  那 ...

有能用的遥控器，学习红外编码，然后解码都好说，就是怕没有遥控器，这个编码库不好弄

qidao

cx_star 发表于 2020-8-31 17:42
有能用的遥控器，学习红外编码，然后解码都好说，就是怕没有遥控器，这个编码库不好弄 ...

编码库不是重点， 装个  遥控精灵 APP  选择  遥控  按发即可，

主要是 测试 未知遥控器  按键代码，
比如说能显示 NEC 编码规则和 键值 即可，  空调编码 太复杂 不用判断。