欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 單片機+LCD1602顯示冷熱水調和系統Proteus仿真程序 精度為±1℃ [打印本頁]

---

作者: 飛啊豬    時間: 2019-7-11 17:53
標題: 單片機+LCD1602顯示冷熱水調和系統Proteus仿真程序 精度為±1℃
實現的功能（1）用LCD1602液晶顯示水溫、設置上下限和定時時間，（2）水溫檢測顯示范圍為00～99℃，精度為±1℃。（3）溫度預設范圍為0～99℃，當檢測溫度低于預設溫度時，開始加熱；檢測溫度高于預設溫度時，停止加熱。（4）設置4個程序按鍵。分別是設置按鍵、加鍵、減鍵、確定。（5）可以紅外遙控，通過紅外一體接收探頭接收遙控器信號，執行與主板按鍵同等功能。（6）有水位檢測功能，無水自動上水，無水不加熱。

仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機源程序如下:

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uint unsigned int
   
4. #define uchar unsigned char
   
5. 
   
6. sbit LCDRS = P1^1;        //命令數據選擇        
   
7. sbit LCDEN= P1^2;        //使能
   
8. sbit jdq= P1^0;        //加熱繼電器
   
9. sbit shui=P1^3;//加水繼電器
   
10. sbit Feng = P2^6; //蜂鳴器
    
11. //按鍵
    
12. sbit Key1=P1^4;         //設置
    
13. sbit Key2=P1^5;         //加
    
14. sbit Key3=P1^6;         //減
    
15. sbit Key4=P1^7;         //確定         
    
16. sbit shang=P3^7;//上限
    
17. sbit xia=P3^6;//下限
    
18. sbit DQ=P2^2;                                //定義DS18B20總線I/O
    
19. signed char w,bj,bjx,bjd;     //溫度值全局變量
    
20. uint c;                                           //溫度值全局變量
    
21. bit bdata flag=0,flag_BJ,flag_off=1,que;//flag：定時狀態標志位flag_BJ：報警標志位flag_off：手動關閉報警標志位que：缺水標志位
    
22. /*******遙控時間計算********/
    
23. #define Imax  14000    //此處為晶振為12時的取值,
    
24. #define Imin  8000    //如用其它頻率的晶振時,
    
25. #define Inum1 1450    //要改變相應的取值。
    
26. #define Inum2 700
    
27. #define Inum3 3000
    
28. //解碼變量
    
29. unsigned char Im[4]={0x00,0x00,0x00,0x00};
    
30. 
    
31. //全局變量
    
32. uchar f;
    
33. unsigned char m,Tc;
    
34. unsigned char IrOK;
    
35. 
    
36. uint xx=28;         //T設定下限
    
37. uint sx=37;         //T設定上限
    
38. 
    
39. int ds=0;
    
40. uchar Mode=0;
    
41. /********設置變量**********/
    
42. 
    
43. //初始畫時顯示的內容
    
44. uchar code Init1[]="Tp:00.0 C Ti:000";
    
45. uchar code Init2[]=" Up:00  Down:00 ";
    
46. /*********液晶的基本操作程序**********/
    
47. 
    
48. //LCD延時
    
49. void LCDdelay(uint z)
    
50. {
    
51.   uint x,y;
    
52.   for(x=z;x>0;x--)
    
53.     for(y=10;y>0;y--);
    
54. }
    
55. //寫命令
    
56. void write_com(uchar com)
    
57. {
    
58.   LCDRS=0;
    
59.   P0=com;
    
60.   LCDdelay(5);
    
61.   LCDEN=1;
    
62.   LCDdelay(5);
    
63.   LCDEN=0;
    
64. }
    
65. //寫數據
    
66. void write_data(uint date)
    
67. {
    
68.   LCDRS=1;
    
69.   P0=date;
    
70.   LCDdelay(5);
    
71.   LCDEN=1;
    
72.   LCDdelay(5);
    
73.   LCDEN=0;
    
74. }
    
75. /*******1602初始化程序********/
    
76. void Init1602()
    
77. {
    
78.   uchar i=0;
    
79.   uchar j=0;
    
80.   
    
81.   write_com(0x38);    //屏幕初始化
    
82.   write_com(0x0c);    //打開顯示 無光標 無光標閃爍
    
83.   write_com(0x06);    //當讀或寫一個字符是指針后一一位
    
84.   write_com(0x01);    //清屏
    
85.   write_com(0x80);    //設置位置
    
86.   
    
87.   for(i=0;i<16;i++)
    
88.   {
    
89.                 write_data(Init1[i]);
    
90.   }
    
91.   write_com(0xc0);//設置位置
    
92.   for(j=0;j<16;j++)
    
93.   {
    
94.                 write_data(Init2[j]);
    
95.   }
    
96. }
    
97. 
    
98. /*******顯示時間溫度數據程序***********/
    
99. void Display_1602(uint c,uint ds,uint sx,uint xx)
    
100. {
     
101.         //溫度顯示
     
102.         write_com(0x80+3);
     
103.         write_data('0'+c/100);
     
104.         write_data('0'+c/10%10);
     
105.         write_data('.');
     
106.         write_data('0'+c %10);
     
107.         write_data(0xdf);
     
108. 
     
109.         //定時顯示
     
110.         write_com(0x80+13);
     
111.         write_data('0'+ds/100);
     
112.         write_data('0'+ds/10%10);
     
113.         write_data('0'+ds%10);
     
114. 
     
115.         //上限顯示
     
116.         write_com(0x80+0x40+4);
     
117.         write_data('0'+sx/10%10);
     
118.         write_data('0'+sx%10);
     
119. 
     
120.         //下限顯示
     
121.         write_com(0x80+0x40+13);
     
122.         write_data('0'+xx/10%10);
     
123.         write_data('0'+xx%10);
     
124.         
     
125. }
     
126. /****字符顯示程序*****/
     
127. void Display_wd()
     
128. {
     
129.         //溫度顯示
     
130.         write_com(0x80);
     
131.         write_data('S');
     
132.         write_data('e');
     
133.         write_data('t');
     
134.         write_data(' ');
     
135.         write_data('s');
     
136.         write_data('t');
     
137.         write_data('a');
     
138.         write_data('t');
     
139.         write_data('e');        
     
140. }
     
141. 
     
142. 
     
143. void delay(uint z)
     
144. {
     
145.         uint i,j;
     
146.         for(i=0;i<z;i++)
     
147.         for(j=0;j<121;j++);
     
148. }
     
149. /*******************溫度工作程序**************************/
     
150. /*****延時子程序*****/
     
151. void Delay_DS18B20(int num)
     
152. {
     
153.   while(num--) ;
     
154. }
     
155. /*****初始化DS18B20*****/
     
156. uchar Init_DS18B20(void)
     
157. {
     
158.   unsigned char x=0;
     
159.   DQ = 1;         //DQ復位
     
160.   Delay_DS18B20(8);    //稍做延時
     
161.   DQ = 0;         //單片機將DQ拉低
     
162.   Delay_DS18B20(80);   //精確延時，大于480us
     
163.   DQ = 1;         //拉高總線
     
164.   Delay_DS18B20(14);
     
165.   x = DQ;           //稍做延時后，如果x=0則初始化成功，x=1則初始化失敗
     
166.   Delay_DS18B20(20);
     
167.   return(x);
     
168. }
     
169. /*****讀一個字節*****/
     
170. unsigned char ReadOneChar(void)
     
171. {
     
172.   unsigned char i=0;
     
173.   unsigned char dat = 0;
     
174.   for (i=8;i>0;i--)
     
175.   {
     
176.     DQ = 0;     // 給脈沖信號
     
177.     dat>>=1;
     
178.     DQ = 1;
     
179.         _nop_();
     
180.         _nop_();             // 給脈沖信號
     
181.     if(DQ)
     
182.     dat|=0x80;
     
183.     Delay_DS18B20(4);
     
184.         DQ=1;
     
185.   }
     
186.   return(dat);
     
187. }
     
188. /*****寫一個字節*****/
     
189. void WriteOneChar(unsigned char dat)
     
190. {
     
191.   unsigned char i=0;
     
192.   for (i=8; i>0; i--)
     
193.   {
     
194.     DQ = 0;
     
195.     DQ = dat&0x01;
     
196.     Delay_DS18B20(5);
     
197.     DQ = 1;
     
198.     dat>>=1;
     
199.   }
     
200. }
     
201. /*****讀取溫度*****/
     
202. unsigned int ReadTemperature(void)
     
203. {
     
204.   unsigned char a=0;
     
205.   unsigned char b=0;
     
206.   unsigned int t=0;
     
207.   float tt=0;
     
208.   Init_DS18B20();
     
209.   WriteOneChar(0xCC);  //跳過讀序號列號的操作
     
210.   WriteOneChar(0x44);  //啟動溫度轉換
     
211.   Init_DS18B20();
     
212.   WriteOneChar(0xCC);  //跳過讀序號列號的操作
     
213.   WriteOneChar(0xBE);   //讀取溫度寄存器
     
214.   a=ReadOneChar();      //讀低8位
     
215.   b=ReadOneChar();      //讀高8位
     
216.   t=b;
     
217.   t<<=8;
     
218.   t=t|a;
     
219.   tt=t*0.0625;
     
220.   t= tt*10+0.5;        //放大10倍輸出并四舍五入
     
221.   return(t);
     
222. }
     
223. 
     
224. 
     
225. /*****讀取溫度*****/
     
226. void check_wendu(void)
     
227. {
     
228.         c=ReadTemperature();                          //獲取溫度值并減去DS18B20的溫漂誤差
     
229.         w=c/10;                                                      //計算得到整數位
     
230.         if(w<0){w=0;}                                   //設置溫度顯示下限
     
231.         if(w>99){w=99;}                                   //設置溫度顯示上限   
     
232. }
     
233. 
     
234. /****************按鍵工作程序*************************/
     
235. void Key()
     
236. {
     
237.         //模式選擇
     
238.         if(Key1==0)
     
239.         {
     
240.                 while(Key1==0);
     
241.                 Feng=0;
     
242.                 Mode++;
     
243.                 Display_wd();
     
244.                 if(Mode==4)
     
245.                 {
     
246.                         Mode=1;
     
247.                         Feng=1;
     
248.                 }
     
249.                    write_com(0x38);//屏幕初始化
     
250.                    write_com(0x0d);//打開顯示 無光標 光標閃爍
     
251.                    write_com(0x06);//當讀或寫一個字符是指針后一一位
     
252.                 switch(Mode)
     
253.                 {
     
254.                         case 1:
     
255.                         {
     
256.                                 write_com(0x80+15);//位置
     
257.                                 Feng=1;
     
258.                                 break;
     
259.                         }
     
260.                         case 2:
     
261.                         {
     
262.                                 write_com(0x80+0x40+5);//位置
     
263.                                 Feng=1;
     
264.                                 break;
     
265.                         }
     
266.                         case 3:
     
267.                         {
     
268.                                 write_com(0x80+0x40+14);//位置
     
269.                                 Feng=1;
     
270.                                 break;
     
271.                         }
     
272.                 }
     
273.         }
     
274.         if(Key2==0&&Mode!=0)
     
275.         {
     
276.                 while(Key2==0);
     
277.                 Feng=0;
     
278.                 switch(Mode)
     
279.                 {
     
280.                         case 1:
     
281.                         {
     
282.                                 if(ds<999)
     
283.                                 {
     
284.                                         ds++;
     
285.                                         write_com(0x80+13);
     
286.                                         write_data('0'+ds/100);
     
287.                                         write_data('0'+ds/10%10);
     
288.                                         write_data('0'+ds%10);
     
289.                                         write_com(0x80+15);//位置
     
290.                                 }
     
291.                                 Feng=1;
     
292.                                 break;
     
293.                         }
     
294.                         case 2:
     
295.                         {
     
296.                                 if(sx<99-1)
     
297.                                 {
     
298.                                         sx++;
     
299.                                         write_com(0x80+0x40+4);
     
300.                                         write_data('0'+sx/10%10);
     
301.                                         write_data('0'+sx%10);
     
302.                                         write_com(0x80+0x40+5);//位置
     
303.                                 }
     
304.                                 Feng=1;
     
305.                                 break;                                
     
306.                         }
     
307.                         case 3:
     
308.                         {
     
309.                                 if(xx<sx-1)
     
310.                                 {
     
311.                                         xx++;
     
312.                                         write_com(0x80+0x40+13);
     
313.                                         write_data('0'+xx/10%10);
     
314.                                         write_data('0'+xx%10);
     
315.                                         write_com(0x80+0x40+14);//位置
     
316.                                 }
     
317.                                 Feng=1;
     
318.                                 break;                                
     
319.                         }               
     
320.                 }
     
321.         }
     
322.         if(Key3==0&&Mode!=0)
     
323.         {
     
324.                 while(Key3==0);
     
325.                 Feng=0;
     
326.                 switch(Mode)
     
327.                 {
     
328.                         case 1:
     
329.                         {
     
330.                                 if(ds>0)
     
331.                                 {
     
332.                                         ds--;
     
333.                                         write_com(0x80+13);
     
334.                                         write_data('0'+ds/100);
     
335.                                         write_data('0'+ds/10%10);
     
336.                                         write_data('0'+ds%10);
     
337.                                         write_com(0x80+15);//位置
     
338.                                 }
     
339.                                 Feng=1;
     
340.                                 break;
     
341.                         }
     
342.                         case 2:
     
343.                         {
     
344.                                 if(sx>xx+1)
     
345.                                 {
     
346.                                         sx--;
     
347.                                         write_com(0x80+0x40+4);
     
348.                                         write_data('0'+sx/10%10);
     
349.                                         write_data('0'+sx%10);
     
350.                                         write_com(0x80+0x40+5);//位置
     
351.                                 }
     
352.                                 Feng=1;
     
353.                                 break;                                
     
354.                         }
     
355.                         case 3:
     
356.                         {
     
357.                                 if(xx>0)
     
358.                                 {
     
359.                                         xx--;
     
360.                                         write_com(0x80+0x40+13);
     
361.                                         write_data('0'+xx/10%10);
     
362.                                         write_data('0'+xx%10);
     
363.                                         write_com(0x80+0x40+14);//位置
     
364.                                 }
     
365.                                 Feng=1;
     
366.                                 break;                                
     
367.                         }               
     
368.                 }
     
369.         }
     
370.         if(Key4==0)
     
371.         {
     
372.                 while(Key4==0);
     
373.                 Feng=0;
     
374.                 Mode=0;
     
375.             write_com(0x38);//屏幕初始化
     
376.             write_com(0x0c);//打開顯示 無光標 無光標閃爍
     
377.                 Init1602();
     
378.                 //Display_1602(c,ds,sx,xx);
     
379.                 if(ds>0)
     
380.                 {
     
381.                         flag=1;
     
382.                         jdq=1;
     
383.                         TR1=1;
     
384.                 }
     
385.                 Feng=1;
     
386.         }
     
387.                 if(IrOK==1)
     
388.                 {
     
389.                         if(Im[2]==0x0d)        //遙控設置鍵
     
390.                         {
     
391.                                 Feng=0;
     
392.                                 Mode++;
     
393.                                 Display_wd();
     
394.                                 if(Mode==4)
     
395.                                 {
     
396.                                         Mode=1;
     
397.                                         Feng=1;
     
398.                                 }
     
399.                                    write_com(0x38);//屏幕初始化
     
400.                                    write_com(0x0d);//打開顯示 無光標 光標閃爍
     
401.                                    write_com(0x06);//當讀或寫一個字符是指針后一一位
     
402.                                 switch(Mode)
     
403.                                 {
     
404.                                         case 1:
     
405.                                         {
     
406. 
     
407.                                                 write_com(0x80+15);//位置
     
408.                                                 Feng=1;
     
409.                                                 break;
     
410.                                         }
     
411.                                         case 2:
     
412.                                         {
     
413.                                                 write_com(0x80+0x40+5);//位置
     
414.                                                 Feng=1;
     
415.                                                 break;
     
416.                                         }
     
417.                                         case 3:
     
418.                                         {
     
419.                                                 write_com(0x80+0x40+14);//位置
     
420.                                                 Feng=1;
     
421.                                                 break;
     
422.                                         }
     
423.                                 }                                 
     
424.                         }
     
425.                         //+鍵
     
426.                         else if(Im[2]==0x40)
     
427.                         {
     
428.                                 if(Mode!=0)
     
429.                                 {
     
430.                                         Feng=0;
     
431.                                         switch(Mode)
     
432.                                         {
     
433.                                                 case 1:
     
434.                                                 {
     
435.                                                         if(ds<999)
     
436.                                                         {
     
437.                                                                 ds++;
     
438.                                                                 write_com(0x80+13);
     
439.                                                                 write_data('0'+ds/100);
     
440.                                                                 write_data('0'+ds/10%10);
     
441.                                                                 write_data('0'+ds%10);
     
442.                                                                 write_com(0x80+15);//位置
     
443.                                                         }
     
444.                                                         Feng=1;
     
445.                                                         break;
     
446.                                                 }
     
447.                                                 case 2:
     
448.                                                 {
     
449.                                                         if(sx<99-1)
     
450.                                                         {
     
451.                                                                 sx++;
     
452.                                                                 write_com(0x80+0x40+4);
     
453.                                                                 write_data('0'+sx/10%10);
     
454.                                                                 write_data('0'+sx%10);
     
455.                                                                 write_com(0x80+0x40+5);//位置
     
456.                                                         }
     
457.                                                         Feng=1;
     
458.                                                         break;                                
     
459.                                                 }
     
460.                                                 case 3:
     
461.                                                 {
     
462.                                                         if(xx<sx-1)
     
463.                                                         {
     
464.                                                                 xx++;
     
465.                                                                 write_com(0x80+0x40+13);
     
466.                                                                 write_data('0'+xx/10%10);
     
467.                                                                 write_data('0'+xx%10);
     
468.                                                                 write_com(0x80+0x40+14);//位置
     
469.                                                         }
     
470.                                                         Feng=1;
     
471.                                                         break;                                
     
472.                                                 }               
     
473.                                         }
     
474.                                 }
     
475.                         }
     
476.                         //-鍵
     
477.                         else if(Im[2]==0x19)
     
478.                         {
     
479.                                 if(Mode!=0)
     
480.                                 {
     
481.                                         Feng=0;
     
482.                                         switch(Mode)
     
483.                                         {
     
484.                                                 case 1:
     
485.                                                 {
     
486.                                                         if(ds>0)
     
487.                                                         {
     
488.                                                                 ds--;
     
489.                                                                 write_com(0x80+13);
     
490.                                                                 write_data('0'+ds/100);
     
491.                                                                 write_data('0'+ds/10%10);
     
492.                                                                 write_data('0'+ds%10);
     
493.                                                                 write_com(0x80+15);//位置
     
494.                                                         }
     
495.                                                         Feng=1;
     
496.                                                         break;
     
497.                                                 }
     
498.                                                 case 2:
     
499.                                                 {
     
500.                                                         if(sx>xx+1)
     
501.                                                         {
     
502.                                                                 sx--;
     
503.                                                                 write_com(0x80+0x40+4);
     
504.                                                                 write_data('0'+sx/10%10);
     
505.                                                                 write_data('0'+sx%10);
     
506.                                                                 write_com(0x80+0x40+5);//位置
     
507.                                                         }
     
508.                                                         Feng=1;
     
509.                                                         break;                                
     
510.                                                 }
     
511.                                                 case 3:
     
512.                                                 {
     
513.                                                         if(xx>0)
     
514.                                                         {
     
515.                                                                 xx--;
     
516.                                                                 write_com(0x80+0x40+13);
     
517.                                                                 write_data('0'+xx/10%10);
     
518.                                                                 write_data('0'+xx%10);
     
519.                                                                 write_com(0x80+0x40+14);//位置
     
520.                                                         }
     
521.                                                         Feng=1;
     
522.                                                         break;                                
     
523.                                                 }               
     
524.                                         }
     
525.                                 }
     
526.                         }
     
527.                         //確定鍵
     
528.                         else if(Im[2]==0x15)
     
529.                         {
     
530.                                 Feng=0;
     
531.                                 Mode=0;
     
532.                                 Init1602();
     
533.                                 if(ds>0)
     
534.                                 {
     
535.                                         flag=1;
     
536.                                         jdq=1;
     
537.                                         TR1=1;
     
538.                                 }
     
539.                                 Feng=1;
     
540.                         }
     
541.                         IrOK=0;         
     
542.                 }
     
543. }
     
544. 
     
545. /*********************報警部分程序**************************/
     
546. void Alam()
     
547. {
     
548.         if(flag_BJ==1&&flag_off==1)
     
549.         {
     
550.                 Feng=0;
     
551.                 delay(1000);
     
552.                 Feng=1;
     
553.                 flag_off=0;
     
554. //                flag_BJ=0;
     
555.         }
     
556. }
     
557. /**************************主程序******************************/
     
558. void main()
     
559. {
     
560.         Init1602();
     
561.         EA=1;       //打開中斷總開關
     
562.         IT1=1;     //下降沿有效
     
563.         EX1=1;     //外部中斷1開
     
564.         ET1=1;     //打開允許開關
     
565.         TMOD=0x11; //設置工作方式
     
566.         TL1=0x3c;
     
567.         TH1=0xb0;  //T1賦初值50ms
     
568.         TH0=0;     //T0賦初值
     
569.         TL0=0;
     
570.         TR0=0;     //t0開始計時控制
     
571.         check_wendu();
     
572.         delay(1000);
     
573.         bjd=99;
     
574.         bjx=0;                                 //這兩個變量的作用就是，防止溫度大范圍跳動造成加熱設備誤動作
     
575.         while(1)
     
576.         {        
     
577.                 check_wendu();
     
578.                 if(Mode==0)
     
579.                 {        
     
580.                         Display_1602(c,ds,sx,xx);
     
581.                         if((xia==1)&&(shang==1)) //低于下限
     
582.                         {
     
583.                                  que=1;
     
584.                                 shui=0;
     
585.                                 jdq=1;
     
586.                         }
     
587.                         else
     
588.                         {
     
589.                                 que=0;
     
590.                         }
     
591.                         if((shang==0)&&(xia==0)) //高于上限
     
592.                         {
     
593.                                 shui=1;
     
594.                                 if(flag_BJ==0)
     
595.                                 flag_BJ=1;
     
596.                         }
     
597.                         if((shang==0)&&(xia==1)) //錯誤
     
598.                         {
     
599.                                 shui=1;
     
600.                                 jdq=1;
     
601.                                 Feng=0;
     
602.                                 que=1;
     
603.                         }
     
604.                         if(flag==0)
     
605.                         {
     
606.                                 if((w<bjd)&&(w>bjx))
     
607.                                 {
     
608.                                         if(w>=sx)
     
609.                                         {
     
610.                                                 jdq=1;
     
611.                                                 if(flag_BJ==0)
     
612.                                                 flag_BJ=1;
     
613.                                         }
     
614.                                         else if((w<xx)&&(que==0))         
     
615.                                         {
     
616.                                                 jdq=0;
     
617.                                                 if(flag_BJ==0)
     
618.                                                 flag_BJ=1;
     
619.                                         }
     
620.                                         else
     
621.                                         {
     
622.                                                 flag_BJ=0;
     
623.                                                 flag_off=1;
     
624.                                         }
     
625.                                         bjd=w+5;
     
626.                                         bjx=w-5;
     
627.                                 }
     
628.                         }
     
629.                 }
     
630.                 Key();
     
631.                 Alam();
     
632.         }
     
633. }
     
634. /*****************定時器工作程序**********************/
     
635. void time1() interrupt 3//定時器T1函數
     
636. {
     
637.         uint s;
     
638.         TH1=0x3c;
     
639.         TL1=0xb0;       //重新賦初值
     
640.         s++;
     
641.         if(s==1200)            //s=20為1s鐘  1200為1分鐘
     
642.         {
     
643.                 s=0;
     
644.                 ds--;
     
645.                 if(ds==0)
     
646.                 {
     
647.                         flag=0;
     
648.                         if(w>=sx)
     
649.                         {
     
650.                                 jdq=1;
     
651.                                 if(flag_BJ==0)
     
652.                                 flag_BJ=1;
     
653.                         }
     
654.                         else if((w<xx)&&(que==0))
     
655.                         {
     
656.                                 jdq=0;
     
657.                                 if(flag_BJ==0)
     
658.                                 flag_BJ=1;
     
659.                         }
     
660.                         else
     
661.                                 {
     
662.                                         flag_BJ=0;
     
663.                                         flag_off=1;
     
664.                                 }
     
665.                         bjd=w+10;
     
666.                         bjx=w-10;
     
667.                         TR1=0;
     
668.                 }
     
669.         }
     
670. }
     
671. 
     
672. /*****************紅外解碼定時器程序****************************/
     
673. //外部中斷解碼程序_外部中斷1
     
674. void intersvr1(void) interrupt 2 using 1
     
675. {
     
676. TR0=1;
     
677. Tc=TH0*256+TL0;//提取中斷時間間隔時長
     
678. TH0=0;
     
679. TL0=0;            //定時中斷重新置零
     
680. 
     
681. if((Tc>Imin)&&(Tc<Imax))
     
682. {
     
683.         m=0;
     
684.         f=1;
     
685.         return;
     
686. }                  //找到啟始碼
     
687. if(f==1)
     
688. {
     
689.         if(Tc>Inum1&&Tc<Inum3)
     
690.     {
     
691.            Im[m/8]=Im[m/8]>>1|0x80; m++;
     
692.     }
     
693.     if(Tc>Inum2&&Tc<Inum1)
     
694.     {
     
695.       Im[m/8]=Im[m/8]>>1; m++; //取碼
     
696.            }
     
697.            if(m==32)
     
698.     {
     
699.       m=0;  
     
700.       f=0;
     
701.       if(Im[2]==~Im[3])
     
702.       {
     
703.            IrOK=1;
     
704.                    TR0=0;
     
705.            }
     
706.       else IrOK=0;   //取碼完成后判斷讀碼是否正確
     
707.     }
     
708.                     //準備讀下一碼
     
709. }
     
710. }
     

復制代碼

所有資料51hei提供下載:
水溫調試.zip (106.34 KB, 下載次數: 35)

2019-7-11 17:53 上傳

點擊文件名下載附件
proteus仿真+程序
下載積分: 黑幣 -5

---

歡迎光臨 (http://www.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影