1. #include<at89x52.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. 
   
5. sbit IR = P3^2;
   
6. sbit P34 = P3^4;//为数码管位选
   
7. sbit PWM = P2^7;
   
8. 
   
9. uint LowTime;//低电平时间
   
10. uint HighTime;//高电平时间
    
11. uchar Code;//累积一个八位数据帧
    
12. uchar a[4];//接受4组八位数据帧
    
13. uchar light = 0x00;//亮度
    
14. uchar TH = 0xf4;
    
15. uchar code table[] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80};//共阳数码管0-8编码
    
16. 
    
17. void intialise (void);
    
18. 
    
19. void main (void)
    
20. {
    
21.         EA = 1;
    
22.         PX1 = 1;
    
23. 
    
24.     IT0 = 1;
    
25.         IT1 = 1;
    
26.         EX0 = 1;    //用作外部信号感受//接受红外接受管引脚的信号电平
    
27.         EX1 = 1;    //因为初始化的时候的时候，亮度为0，不需要零点信号的时间
    
28. 
    
29.         TMOD = 0x11;//最高为9ms的计时，还是比较大，必须用定时方式1
    
30.         ET1 = 1;
    
31. 
    
32.         P34 = 0;//数码管位数
    
33.         P0 = table[light];
    
34.         PWM = 0;
    
35.         while (1);
    
36. }
    
37. void External0 (void) interrupt 0 using 0//外部中断0
    
38. {
    
39. //        EA = 0;//一旦有下降沿立即触发了中断，进来后就关闭中断功能，因为此时要对发来的数据进行分析，不能再接受二次红外的中断，只解码当前的信号。此时P3.2作为输入引脚。
    
40.         TH0 = 0;//定时器T0高八位置零
    
41.         TL0 = 0;//定时器T0低八位置零
    
42.         TR0 = 1;//开启定时器，此定时器不会用作中断
    
43.         while (IR == 0);//如果一直是9ms的低电平就一直等待，给引导码的低电平计时
    
44.         TR0 = 0;//引导码的低电平结束后就关闭定时器T0，计时结束
    
45.         LowTime = TH0*256 + TL0;//保存引导码的低电平时间
    
46. 
    
47.         TH0 = 0;//定时器T0高八位置零
    
48.         TL0 = 0;//定时器T0低八位置零
    
49.         TR0 = 1;//开启定时器，此定时器不会用作中断
    
50.         while (IR == 1);//如果一直是4.5ms的高电平就一直等待，给引导码的高电平计时
    
51.         TR0 = 0;//引导码的高电平结束后就关闭定时器T0，计时结束
    
52.         HighTime = TH0*256 + TL0;//保存引导码的高电平时间
    
53.        
    
54.         if ((LowTime>7000)&&(LowTime<9000)&&(HighTime>3000)&&(HighTime<5000))//理论值:LowTime = 9000/1.085 = 8294;区间定为：8300-500 = 7800,8300+500 = 8800。HighTime = 4500/1.085 = 4147;区间定为：4100-500 = 3600,4100+500 = 4600。
    
55.         //判断出他是引导码就开始解码，否则放弃，然后到最后开启中断，等待下次中断的触发
    
56.         {
    
57.                 uchar i;
    
58.                 uchar j;
    
59.                 for (i=0; i<4; i++)//连续读取四个8位数据（用户码、用户码重复码、数据码、数据码反码）
    
60.                 {
    
61.                         for (j=0; j<8; j++)//处理每个码的八位数字
    
62.                         {
    
63.                                 Code = Code >> 1;//Code是用来装8位的二进制数，而且没有符号，右移后做高位补0，保证了确定这一位后， 后面的数据能写入这一位，（这也是为什么要将它放在循环的最开始而不是最后，如果最后的话最高位就必然是空）；右移空出的一位放数据，所以每次来的数据是放在最高位的，而发送时是先发低位数据，最后结果就会把最低位放到最右边，取出整体的值就会是一个解好码的值
    
64.                                 
    
65.                                 TH0 = 0;
    
66.                                 TL0 = 0;
    
67.                                 TR0 = 1;
    
68.                                 while (IR == 0);//低电平计时等待
    
69.                                 TR0 = 0;
    
70.                                 LowTime = TH0*256 + TL0;//保存编码的低电平时间
    
71. 
    
72.                                 TH0 = 0;
    
73.                                 TL0 = 0;
    
74.                                 TR0 = 1;
    
75.                                 while (IR == 1);//高电平计时等待
    
76.                                 TR0 = 0;
    
77.                                 HighTime = TH0*256 + TL0;//保存编码的高电平时间
    
78. 
    
79.                                 if ((HighTime>4000)&&(HighTime<6000))//如果成立，表明是 "0"，理论值：565/1.085 = 520；
    
80.                                         Code = Code & 0x7f;//Code的最高位和"0"与，Code的其他低位全部和"1"与，这些位是不会改变的，而最高位肯定是"0"
    
81.                                 if ((HighTime>9000)&&(HighTime<11000))//如果成立，表明是"1",理论值：1685/1.085 = 1553；
    
82.                                         Code = Code | 0x80;//Code的最高位和"1"或，Code的其他低位全部和"0"或，这些位是不会改变的，而最高位肯定是"1"
    
83.                         }
    
84.                         a[i] = Code;//每接受了一个数据帧，就要把这个数据保存起来
    
85.                 }//置此32位数据接受完成
    
86.                 if (a[0] == 0x01&&a[1] == 0x01&&a[2] == ~a[3])//校验
    
87.                 {
    
88.                         light = a[2];
    
89.                         P0 = table[light];
    
90.                 }
    
91.         }
    
92. //        EA = 1;//数据处理结束了；需要开启中断功能，以便下一次中断的触发
    
93. }
    
94. void External1 (void) interrupt 2 using 1 //过零信号的中断处理
    
95. {  
    
96.         PWM = 0;
    
97.         if (light == 8 || light == 0)
    
98.         {
    
99.                 EX1 = 0;
    
100.                 ET1 = 0;
     
101.                 if (light == 8)
     
102.                         PWM = 1;
     
103.         }
     
104.         else
     
105.         {
     
106.                 EX1 = 1;
     
107.                 ET1 = 1;
     
108.                 switch (light)
     
109.                 {
     
110.                         case 0x01:TH1 = 0XC4;
     
111.                                           break;
     
112.                         case 0x02:TH1 = 0XCA;
     
113.                                           break;
     
114.                         case 0x03:TH1 = 0XD0;
     
115.                                           break;
     
116.                         case 0x04:TH1 = 0XDC;
     
117.                                           break;
     
118.                         case 0x05:TH1 = 0XE8;
     
119.                                           break;
     
120.                         case 0x06:TH1 = 0XEE;
     
121.                                           break;
     
122.                         case 0x07:TH1 = 0XF4;
     
123.                                           break;
     
124.                 }
     
125.                 TL1 = 0X00;
     
126.                 TR1 = 1;
     
127.         }
     
128. }
     
129. void Timer1 (void) interrupt 3 using 2
     
130. {
     
131.         PWM = 1;
     
132.         TR1 = 0;  //关闭定时器，下一个零点时才开始计时
     
133. }
     

复制代码