STC89C52RC单片机 学习红外线接收程序 问题

背景：开发板用红外接收三极管，信号口接P3^2（INT0）烧录入单片机之后，led出现全亮。
我的程序里确认P1=0xff，全部关闭。
换一个普通led灯程序，就能控制led灯。
第一行左边第一张图是 （ 烧录入红外线接收程序的单片机）  的（P1.0口 波形  ) ；
右边是P1口和led灯原理图；
第二行是红外线接收三极管原理图；
我想请教 出现这样的情况 的原因。

1. #include <REGX51.H>
   
2. #define uchar unsigned char
   
3. #define uint  unsigned int
   
4. 
   
5. #define NEC 32
   
6. 
   
7. sbit Echo=P3^2;
   
8. sbit buzzer=P2^3;
   
9. //uchar testtl0[33];
   
10. 
    
11. uchar n=0;
    
12. uchar t0=0;
    
13. uchar sign=0;                                        //串口可发送标志位
    
14. uchar startsign=0;                                //开始标志位
    
15. uchar receivebit=0;                                //接收到第几位
    
16. uchar stop_receive=0;                        //接收停止位
    
17. uchar stop_switch=0;                        //停止转换位
    
18. uchar success_check=0;                        //校验成功位
    
19. 
    
20. uchar t0time[33];                        //引导位+16地址位+16命令位
    
21. uchar tl0time[33];
    
22. uchar NM[4];
    
23.                                
    
24.        
    
25. void Init(void);
    
26. void InitInt0(void);
    
27. void Inittime0(void);
    
28. void Inittime1(void);
    
29. //void Delayms(uchar delayms);
    
30. //void CheckData(void);
    
31. 
    
32. void main()
    
33. {
    
34.         uchar n;
    
35.         uchar m;
    
36.         Init();
    
37.         InitInt0();
    
38.         Inittime0();
    
39.         Inittime1();
    
40.         while(1)
    
41.         {                                                                             
    
42.                                 if(stop_receive==1)
    
43.                                 {
    
44.                                         stop_receive=0;
    
45. 
    
46.                                         if(sign == 1)
    
47.                                         {
    
48.                                         ES=0;
    
49.                                         sign=0;                                  //接受中断干涉发送中断
    
50.                                         for(n=0; n<33; n++)
    
51.                                         {
    
52.                                                 SBUF=t0time[n];
    
53.                                                 while(TI == 0);
    
54.                                                 TI=0;
    
55.                                         }
    
56.                                         ES=1;
    
57.                                         }
    
58. 
    
59.                                         for(m=0; m<33; m++)
    
60.                                         {
    
61.                                                 t0time[m]=0;
    
62.                                         }
    
63.        
    
64.                            }
    
65.         }               
    
66. }
    
67. 
    
68. void Init(void)
    
69. {
    
70.         P3=0xff;       
    
71.         P1=0xff;
    
72. //        PT0=1;       //time0高优先级
    
73. }
    
74. void InitInt0(void)
    
75. {
    
76.         IT0=1;
    
77.         EX0=1;
    
78.        
    
79. }
    
80. 
    
81. void Inittime0(void)
    
82. {
    
83.         TMOD=0x22;
    
84.         TH0=6;
    
85.         TL0=6;         
    
86.         TR0=0;
    
87.         ET0=1;
    
88.         EA=1;       
    
89. }
    
90. void Inittime1(void)
    
91. {
    
92.         SM0=0;
    
93.         SM1=1;
    
94.         REN=1;
    
95.         TH1=0xfd;
    
96.         TL1=0xfd;
    
97.         ES=1;
    
98.         TR1=1;
    
99. }
    
100. 
     
101. /*void    Delayms(uchar delayms)
     
102. {
     
103.         uchar i,j;
     
104.         while(delayms--)
     
105.         {
     
106.                 for(i=4; i>0; i--)
     
107.                 for(j=0; j<50; j++);
     
108.         }
     
109. }                                 */
     
110. /*void CheckData(void)                 //地址和命令,发送时从低位开始 //数据处理
     
111. {
     
112.          uchar i=0;
     
113.          uchar n=0,m=0;
     
114.          if(stop_receive==1)          //成功接收完数据，接受完我们将他处理 //处理完之后，我们需要将结束接收标志置0
     
115.          {                                                                                //首先我们需要将两个先整合到一个数组
     
116.                         
     
117.                         for(i=1; i<33; i++)
     
118.                         {
     
119.                                 t0time[i]=t0time[i]+tl0time[i];
     
120.                         }
     
121. 
     
122.                          for(m=0; m<4; m++)                                //我们根据t0time[n]和tl0time，也就是t0的值来确认多大
     
123.                         {                                                               
     
124.                                 for(n=1; n<33; n++)
     
125.                                 {
     
126.                                          NM[m]>>=1;
     
127.                                          if(t0time[n]>4)
     
128.                                          {
     
129.                                                          NM[m]|=0x80;
     
130.                                          }
     
131.                                 }
     
132.                         }
     
133.                        
     
134.                         //开始校验
     
135.                         if(NM[0] == ~NM[1])
     
136.                         {
     
137.                                 if(NM[1] == ~NM [2])
     
138.                                 {
     
139.                                         success_check=1;
     
140.                                         stop_receive=0;                   //校验合格，可以置位0，归位，准备下一个
     
141.                                 }
     
142.                         }
     
143.                         else
     
144.                         {
     
145.                                 buzzer=1;
     
146.                         }               
     
147.          }
     
148. }                                                 */
     
149. void iint0() interrupt 0          //接收中断函数   相当于静态的连续接收  IT0=1
     
150. {
     
151.         uchar i=0;
     
152.         //下降沿
     
153.         TR0=0; //关定时
     
154.         EX0=0; //关本次中断
     
155.         if(stop_receive==0)
     
156.         {
     
157.                 if((t0>16)&&(t0<20))
     
158.                 {
     
159.                         receivebit=0;             //接收位置0  第一位开始存放
     
160.                 }
     
161.                 t0time[receivebit]=t0;  //装入t0
     
162.                 tl0time[receivebit]=TL0;
     
163.                 receivebit++;
     
164.                 t0=0;
     
165.                 TL0=6;
     
166. 
     
167.                 if(receivebit>32)
     
168.                 {
     
169.                         receivebit=0;
     
170.                         stop_receive=1;                 //停止接收标志位
     
171.                 }
     
172.         }
     
173. 
     
174.         EX0=1;
     
175.         while((Echo==0)&&(i<=65))                //560us之后会达到高电平 ，需要加条件，防卡死
     
176.         {
     
177.                  i++;
     
178.         }                        
     
179.         TR0=1;                         //根据反相码，我们计算高电平持续时间 也就是说，高电平开启定时器，低电平关闭定时器  
     
180.         //还是有影响
     
181. 
     
182. }
     
183. 
     
184. void  time0() interrupt 1           //250us
     
185. {
     
186.         t0++;
     
187. 
     
188.        
     
189. // testtl0[n]=TL0;
     
190. 
     
191. }
     
192. 
     
193. void ser() interrupt 4
     
194. {          
     
195.         RI=0;
     
196.         sign=1;
     
197. }

复制代码

1. #include <REGX51.H>
   
2. #define uchar unsigned char
   
3. #define uint  unsigned int
   
4. 
   
5. #define NEC 32
   
6. 
   
7. sbit Echo=P3^2;
   
8. sbit buzzer=P2^3;
   
9. //uchar testtl0[33];
   
10. 
    
11. uchar n=0;                                       
    
12. uint  t0=0;
    
13. uchar sign=0;                                        //串口可发送标志位
    
14. uchar allow_sign=0;                                                                         //校验合格
    
15. uchar start=0;
    
16. uchar stop=0;   
    
17. uchar stop_receive=0;                            //开始标志位
    
18. uchar receivebit=0;                                //接收到第几位
    
19. 
    
20.                        //接收停止位
    
21. uchar stop_switch=0;                        //停止转换位
    
22. uchar success_check=0;                        //校验成功位
    
23. 
    
24. uchar t0time[32];                        //引导位+16地址位+16命令位
    
25. uchar tl0time[32];
    
26. uchar NM[4];
    
27.                                 
    
28.         
    
29. void Init(void);
    
30. void InitInt0(void);
    
31. void Inittime0(void);
    
32. void Inittime1(void);
    
33. //void Delayms(uchar delayms);
    
34. uchar CheckData(void);
    
35. uchar StartStop(void);
    
36. 
    
37. void main()
    
38. {
    
39.         uchar n;
    
40.   //      uchar m;
    
41.         Init();
    
42.         InitInt0();
    
43.         Inittime0();
    
44.         Inittime1();
    
45.         while(1)
    
46.         {                                                                     
    
47.                                 if(CheckData())
    
48.                                 {
    
49.                                         if(sign == 1)
    
50.                                         {
    
51.                                         ES=0;
    
52.                                         sign=0;                                  //接受中断干涉发送中断
    
53.                                         for(n=0; n<4; n++)
    
54.                                         {
    
55.                                                 SBUF=NM[n];
    
56.                                                 while(TI == 0);
    
57.                                                 TI=0;
    
58.                                         }
    
59.                                         ES=1;
    
60.                                         }
    
61. 
    
62.                                  /*       for(m=0; m<33; m++)
    
63.                                         {
    
64.                                                 t0time[m]=0;
    
65.                                         }
    
66.                                                                                                                                                  */
    
67.                                 }
    
68.         }               
    
69. }
    
70. 
    
71. void Init(void)
    
72. {
    
73.         P3=0xff;        
    
74.         P1=0xff;
    
75.         PT0=1;       //time0高优先级
    
76. }
    
77. void InitInt0(void)
    
78. {
    
79.         IT0=1;
    
80.         EX0=1;
    
81.         
    
82. }
    
83. 
    
84. void Inittime0(void)
    
85. {
    
86.         TMOD=0x22;
    
87.         TH0=6;
    
88.         TL0=6;         
    
89.         TR0=0;
    
90.         ET0=1;
    
91.         EA=1;        
    
92. }
    
93. void Inittime1(void)
    
94. {
    
95.         SM0=0;
    
96.         SM1=1;
    
97.         REN=1;
    
98.         TH1=0xfd;
    
99.         TL1=0xfd;
    
100.         ES=1;
     
101.         TR1=1;
     
102. }
     
103. 
     
104. /*void    Delayms(uchar delayms)
     
105. {
     
106.         uchar i,j;
     
107.         while(delayms--)
     
108.         {
     
109.                 for(i=4; i>0; i--)
     
110.                 for(j=0; j<50; j++);
     
111.         }
     
112. }                                 */
     
113. uchar CheckData(void)               
     
114. {
     
115.          uchar i=0;
     
116.          uchar n=0,m=0;
     
117.          if(stop_receive==1)         
     
118.          {   
     
119.                            stop_receive=0;
     
120.                                       
     
121.               for(n=0; n<4; n++)
     
122.                           {
     
123.                                           for(m=0; m<32; m++)
     
124.                                         {
     
125.                                                 NM[n]>>=1;
     
126.                                                 if(t0time[n]*250+tl0time[n] > 1000 )
     
127.                                                 {
     
128.                                                          NM[n] |= 0x80;
     
129.                                                 }
     
130.                                         }
     
131.                           }
     
132.                           if( (NM[2] == ~NM[3]) && (NM[0] == ~NM[1]) )
     
133.                           {                                                                 
     
134.                                           return 1;
     
135.                           }
     
136.          }
     
137.                  return 0;
     
138. }                                                                                                                                       
     
139. uchar StartStop(void)
     
140. {
     
141.         uchar value=1;
     
142.         if(receivebit==0)
     
143.         {
     
144.                 t0=0;
     
145.                 TH0=6;
     
146.                 TL0=6;
     
147.                 TR0=1;
     
148. //                i=250;
     
149.                 while(Echo==0);
     
150. //                {
     
151. //                         i--;
     
152. //                }
     
153.                 TR0=0;
     
154. //                i=0;
     
155. //                start=t0;                                 // start=21,远远小于，也许是干扰
     
156.                 if((t0<30)||(t0>45))
     
157.                 {
     
158.                         TR0=0;
     
159.                         P1=0x01;
     
160.                         value=0;               
     
161.                 }
     
162. 
     
163.                
     
164.                 TH0=6;
     
165.                 TL0=6;
     
166.                 t0=0;
     
167.                 TR0=1;
     
168. //                i=250;
     
169.                 while(Echo==1);
     
170. //                {
     
171. //                        i--;
     
172. //                }
     
173.                 TR0=0;
     
174. //                i=0;
     
175. //                stop=t0;
     
176.                 if((t0<10)||(t0>28))         //  stop=10
     
177.                 {
     
178.                                 TR0=0;
     
179.                                 P1=0x02;
     
180.                                 value=0;
     
181.                                
     
182.                 }
     
183.                
     
184.         }       
     
185.         return value;
     
186. }                                                
     
187. void iint0() interrupt 0          //接收中断函数   相当于静态的连续接收  IT0=1
     
188. {         
     
189. //         uchar i=0;
     
190.          uchar value;       
     
191.      EX0=0;   
     
192.          value=StartStop();
     
193.      if(value==1)
     
194.          {
     
195.                          TR0=0;
     
196.         //                P1=0x04;
     
197.                         if(receivebit>31)
     
198.             {
     
199.                   receivebit=0;
     
200.                   stop_receive=1;                       
     
201.             }
     
202. 
     
203.                         t0time[receivebit]=t0;
     
204.                         tl0time[receivebit]=TL0;
     
205.                         receivebit++;
     
206. 
     
207.                         while(Echo==0)
     
208. //                        {
     
209. //                                i++;
     
210. //                        }
     
211. //                        i=0;
     
212.                         TR0=1;
     
213.                         t0=0;
     
214.                         TH0=6;
     
215.                         TL0=6;               
     
216.          }                                                                         
     
217.          EX0=1;
     
218. }
     
219. 
     
220. void  time0() interrupt 1           //250us
     
221. {
     
222.         t0++;
     
223. }
     
224. 
     
225. void ser() interrupt 4
     
226. {           
     
227.         RI=0;
     
228.         sign=1;
     
229. }

复制代码

这两个有关联么?

昨天的问题已经改善了。现在出现了新问题， t0的33个值看着有点规律，在循环右移。
如果加入校验代码，也校验不成功。正在努力..分析

while（（Echo==1）&&(i<=250))
{
           i++;
}
这一段，如果更改i<=250; 改为i<100;或者其他数字。
t0的值会有变化.

发射遥控，在按住连续发送时只发射引导码。
可能是这个原因。我一直是只按键1，有间隔的按。也许红外发射遥控逐渐判断到信号重复，从而减少地址码和命令码。
我看到数据有t0=2E，几乎每个都有

发送回的数据趋于正常了。
每一次按同一个键的，发送回的数据不一样。
我想是t0的32个数值，循环右移。导致NM【n]也变化。
导致按好几次按键才得到一个程序认为是正确的NM【n】.与我在示波器上观察到的波形不一样。
以下是t0的数据.可以看到,变化
07 06 98 27 D1 02 02 02 02 02 06 06 06 07 06 07 02 06 02 02 06 06 02 02 02 02 06 06 03 02 06 06
06 03 02 06 06 07 06 97 27 02 02 02 02 02 02 07 06 06 07 06 06 02 06 02 02 06 06 02 02 02 02 06
02 02 02 06 07 02 02 06 07 06 06 97 27 02 02 02 02 02 02 06 07 06 06 06 06 02 06 02 02 06 06 02
02 06 06 02 02 02 02 06 07 02 02 06 06 07 06 97 28 02 02 02 02 02 02 06 06 07 07 06 07 02 06 02
06 02 06 02 02 06 06 02 02 02 02 06 06 03 02 06 07 06 06 97 27 02 02 02 02 02 02 06 06 07 06 07
06 06 07 06 06 02 06 02 02 06 06 02 02 02 02 06 06 02 02 06 06 06 06 97 27 02 02 02 02 02 02 06
02 02 02 06 07 06 06 06 06 03 06 02 02 06 06 02 02 02 02 06 06 02 02 06 06 07 06 97 28 02 02 02
28 02 02 02 02 02 02 06 07 07 06 06 06 02 06 02 02 06 06 02 02 02 02 06 06 02 02 06 06 07 06 97
06 07 06 97 28 02 02 02 02 02 02 06 06 07 06 06 06 03 06 02 02 06 06 02 02 02 02 06 06 02 02 06
06 02 02 06 06 06 06 97 28 02 02 02 02 02 02 06 06 06 06 07 06 02 06 03 02 06 07 02 02 02 02 06
02 02 02 06 06 02 02 06 06 06 07 97 27 02 02 02 02 02 02 06 07 06 06 07 06 02 06 02 02 06 07 02
02 06 06 02 02 02 02 06 06 03 02 06 06 07 06 97 27 02 02 02 02 02 02 06 06 07 06 07 06 02 06 02
06 02 06 02 02 06 06 02 02 02 02 06 06 02 02 06 06 07 06 97 27 02 02 02 02 02 02 06 06 07 06 07
06 06 06 06 06 06 02 06 02 02 06 06 02 02 02 02 06 07 02 02 06 06 07 06 97 27 02 02 02 02 02 02
02 02 02 02 06 06 06 07 06 06 02 06 02 02 06 06 02 02 02 02 06 06 03 02 06 06 06 06 02 02 02 02
02 02 02 02 02 02 06 06 06 06 06 07 02 06 03 02 06 06 03 02 02 02 06 06 02 02 06 06 06 06 02 02

start和stop，起始码时间和结束码时间也小于9ms和4.5ms   时间短的有些离谱

t0偏移导致NM【n】数值也在变化...

新手还看不懂。

这样很悬浮啊

有没有发送程序?  发我邮箱  1798473667@qq.com  感谢  最近在做led可见光通信   很需要这方面的

有没有 发送的程序  ?  最近在做LED可见光通信的   很需要这方面的资料   发我邮箱  179843667@qq.com  万分感谢

有没发送的程序?　最近在做ｌｅｄ可见光通信　　　很需要这方面的资料　　　发我邮箱　　179843667@qq.com
  万分 感谢

不错的文件，值得收藏