标题: 菜鸡求助:单片机手动加热保温电路怎么改自动加热保温?附程序 [打印本页]

---

作者: Ficus    时间: 2022-3-10 16:43
标题: 菜鸡求助:单片机手动加热保温电路怎么改自动加热保温?附程序
目前实现功能：开始仿真时是保温状态，按下加热键就是加热状态，再按加热键就会保温到设置保温的温度，按设置键可以设置保温温度，检测液位，加热至100℃和到保温温度报警
想要实现功能：开始仿真时是保温状态，按下加热键能先加热至100℃，自动保温到设置保温的温度，按设置键可以设置保温温度，检测液位，加热至100℃和到保温温度报警
感谢各位大佬、大神！
电路图


加热


保温



单片机程序如下：

1. #include <reg51.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char           //宏定义
   
4. #define LCD1602 P0
   
5. sbit SET=P3^1;                            //定义调整键
   
6. sbit DEC=P2^1;                            //定义减少键
   
7. sbit ADD=P2^0;                            //定义增加键
   
8. sbit BUZZ=P3^6;                            //定义蜂鸣器
   
9. sbit ALAM=P1^2;                                //定义灯光报警        保温制冷报警
   
10. sbit ALAM1=P1^4;                        //保温加热报警
    
11. sbit ALAM2=P1^6;                        //加热报警
    
12. sbit DQ=P3^7;                             //定义DS18B20总线I/O
    
13. sbit RS = P2^7;
    
14. sbit EN = P2^6;
    
15. sbit key1=P1^0;                           //定义液位最高位
    
16. sbit key2=P1^1;                           //定义液位最低位
    
17. bit shanshuo_st;                            //闪烁间隔标志
    
18. bit beep_st;                                     //蜂鸣器间隔标志
    
19. uchar x=0;                                      //计数器
    
20. uchar code tab1[]={"Now Tem:   .  C "};
    
21. uchar code tab2[]={"Set Tem:   C    "};
    
22. uint c;
    
23. uchar Mode=0;                             //状态标志
    
24. signed char T=90;                  //设置报警温度，默认值为90
    
25. //============================================================================================
    
26. //====================================DS18B20=================================================
    
27. //============================================================================================
    
28. /*****延时子程序*****/
    
29. void Delay_DS18B20(int num)
    
30. {
    
31.     while(num--) ;
    
32. }
    
33. void delay(uint xms)//延时函数，有参函数
    
34. {
    
35.         uint x,y;
    
36.         for(x=xms;x>0;x--)
    
37.         for(y=110;y>0;y--);
    
38. }
    
39. /*****初始化DS18B20*****/
    
40. void Init_DS18B20(void)
    
41. {
    
42.     unsigned char x=0;
    
43.     DQ = 1;         //DQ复位
    
44.     Delay_DS18B20(8);    //稍做延时
    
45.     DQ = 0;         //单片机将DQ拉低
    
46.     Delay_DS18B20(80);   //精确延时，大于480us
    
47.     DQ = 1;         //拉高总线
    
48.     Delay_DS18B20(14);
    
49.     x = DQ;           //稍做延时后，如果x=0则初始化成功，x=1则初始化失败
    
50.     Delay_DS18B20(20);
    
51. }
    
52. /*****读一个字节*****/
    
53. unsigned char ReadOneChar(void)
    
54. {
    
55.     unsigned char i=0;
    
56.     unsigned char dat = 0;
    
57.     for (i=8;i>0;i--)
    
58.     {
    
59.         DQ = 0;     // 给脉冲信号
    
60.         dat>>=1;
    
61.         DQ = 1;     // 给脉冲信号
    
62.         if(DQ)
    
63.         dat|=0x80;
    
64.         Delay_DS18B20(4);
    
65.     }
    
66.         return(dat);
    
67. }
    
68. /*****写一个字节*****/
    
69. void WriteOneChar(unsigned char dat)
    
70. {
    
71.     unsigned char i=0;
    
72.     for (i=8; i>0; i--)
    
73.     {
    
74.         DQ = 0;
    
75.         DQ = dat&0x01;
    
76.         Delay_DS18B20(5);
    
77.         DQ = 1;
    
78.         dat>>=1;
    
79.     }
    
80. }
    
81. /*****读取温度*****/
    
82. unsigned int ReadTemperature(void)
    
83. {
    
84.     unsigned char a=0;
    
85.     unsigned char b=0;
    
86.     unsigned int t=0;
    
87.     float tt=0;
    
88.     Init_DS18B20();
    
89.     WriteOneChar(0xCC);  //跳过读序号列号的操作
    
90.     WriteOneChar(0x44);  //启动温度转换
    
91.     Init_DS18B20();
    
92.     WriteOneChar(0xCC);  //跳过读序号列号的操作
    
93.     WriteOneChar(0xBE);  //读取温度寄存器
    
94.     a=ReadOneChar();     //读低8位
    
95.     b=ReadOneChar();    //读高8位
    
96.     t=b;
    
97.     t<<=8;
    
98.     t=t|a;
    
99.     tt=t*0.0625;
    
100. // t= tt*10+0.5;     //放大10倍输出并四舍五入
     
101.     t= tt*10+0.5;
     
102.     return(t);
     
103. }
     
104. /*****读取温度*****/
     
105. void check_wendu(void)
     
106. {
     
107.     c=ReadTemperature()-5;                          //获取温度值并减去DS18B20的温漂误差
     
108.         if(c>1200)
     
109.         {
     
110.             c=1200;
     
111.         }
     
112. }
     
113. /********液晶写入指令函数与写入数据函数，以后可调用**************/
     
114. void write_1602com(uchar com)//****液晶写入指令函数****
     
115. {
     
116.     RS=0;//数据/指令选择置为指令
     
117. //        rw=0; //读写选择置为写
     
118.         LCD1602=com;//送入数据
     
119.         delay(1);
     
120.         EN=1;//拉高使能端，为制造有效的下降沿做准备
     
121.         delay(1);
     
122.         EN=0;//en由高变低，产生下降沿，液晶执行命令
     
123. }
     
124. void write_1602dat(uchar dat)//***液晶写入数据函数****
     
125. {
     
126.         RS=1;//数据/指令选择置为数据
     
127.      //        rw=0; //读写选择置为写
     
128.         LCD1602=dat;//送入数据
     
129.         delay(1);
     
130.         EN=1; //en置高电平，为制造下降沿做准备
     
131.         delay(1);
     
132.         EN=0; //en由高变低，产生下降沿，液晶执行命令
     
133. }
     
134. void lcd_init()//***液晶初始化函数****
     
135. {
     
136.         uchar a;
     
137.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
     
138.         write_1602com(0x0c);//开显示不显示光标
     
139.         write_1602com(0x06);//整屏不移动，光标自动右移
     
140.         write_1602com(0x01);//清显示
     
141. 
     
142.         write_1602com(0x80);//日历显示固定符号从第一行第1个位置之后开始显示
     
143.         for(a=0;a<16;a++)
     
144.         {
     
145.             write_1602dat(tab1[a]);//向液晶屏写日历显示的固定符号部分
     
146.                 delay(3);
     
147.         }
     
148.         write_1602com(0x80+0x40);//时间显示固定符号写入位置，从第2个位置后开始显示
     
149.         for(a=0;a<16;a++)
     
150.         {
     
151.                 write_1602dat(tab2[a]);//写显示时间固定符号，两个冒号
     
152.                 delay(3);
     
153.         }
     
154. 
     
155. }
     
156. void display()
     
157. {
     
158.     if(Mode==0)
     
159.         {
     
160.             write_1602com(0x80+8);                                  //显示当前温度         小数点前的数字
     
161.                 write_1602dat(c/1000+0x30);
     
162.                 write_1602dat((c%1000)/100+0x30);
     
163.                 write_1602dat(((c%1000)%100)/10+0x30);
     
164. 
     
165.                 write_1602com(0x80+12);                                         //小数点后的数字
     
166.                 write_1602dat(((c%1000)%100)%10+0x30);
     
167. 
     
168.                 write_1602com(0x80+13);                                //°
     
169.                 write_1602dat(0xdf);
     
170. 
     
171.             write_1602com(0x80+0x40+8);                 //显示设置温度
     
172.                 write_1602dat(T/10+0x30);
     
173.                 write_1602dat(T%10+0x30);
     
174.                 write_1602dat(0xdf);
     
175.         }
     
176. }
     
177. //=====================================================================================
     
178. /*****按键程序*****/
     
179. void KEY()
     
180. {
     
181.                         //功能键
     
182.     if(SET==0)
     
183.         {
     
184.             BUZZ=0;
     
185.                 delay(10);
     
186.                 if(SET==0)
     
187.                 {
     
188.                     Mode++;
     
189.                         if(Mode==2)
     
190.                         Mode=0;
     
191.                         BUZZ=1;
     
192.                 }
     
193.                 while(SET==0)
     
194.                 {
     
195.                     if(Mode==0)
     
196.                         {
     
197.                         //        write_1602com(0x80+0x40+6);
     
198.                             write_1602com(0x0c);
     
199.                         }
     
200.                         else if(Mode==1)
     
201.                         {
     
202.                             write_1602com(0x80+0x40+9);
     
203.                             write_1602com(0x0f);
     
204.                         }
     
205. 
     
206.                 }
     
207.         }
     
208.         //增加
     
209.         if(ADD==0&&Mode==1)
     
210.         {
     
211.             BUZZ=0;
     
212.                 delay(10);
     
213.                 if(ADD==0)
     
214.                 {
     
215.                     T++;
     
216.                         if(T>=99)
     
217.                         T=99;
     
218.                         write_1602com(0x80+0x40+8);
     
219.                         write_1602dat(T/10+0x30);
     
220.                         write_1602dat(T%10+0x30);
     
221.                         write_1602com(0x80+0x40+9);
     
222.                         BUZZ=1;
     
223.                 }
     
224.                 while(ADD==0);
     
225.         }
     
226.         //减少
     
227.         if(DEC==0&&Mode==1)
     
228.         {
     
229.             BUZZ=0;
     
230.                 delay(10);
     
231.                 if(DEC==0)
     
232.                 {
     
233.                         T--;
     
234.                         write_1602com(0x80+0x40+8);
     
235.                         write_1602dat(T/10+0x30);
     
236.                         write_1602dat(T%10+0x30);
     
237.                         write_1602com(0x80+0x40+9);
     
238.                         BUZZ=1;
     
239.                 }
     
240.                 while(DEC==0);
     
241.         }
     
242. }
     
243. /*****保温子程序*****/
     
244. void Alarm()
     
245. {
     
246.         if(x>=10){beep_st=~beep_st;x=0;}
     
247.         if(Mode==0)
     
248.         {
     
249.             if((c/10)>=T)
     
250.                 {
     
251.                     ALAM=0;
     
252.                         ALAM1=1;
     
253.                         ALAM2=1;
     
254.                         if(beep_st==1)
     
255.                         BUZZ=0;
     
256.                         else
     
257.                         BUZZ=1;
     
258.                 }
     
259.                 else
     
260.                 {
     
261.                     BUZZ=1;
     
262.                         ALAM=1;
     
263.                         ALAM1=0;
     
264.                         ALAM2=1;
     
265.                 }
     
266.         }
     
267. }
     
268. /*****加热子程序*****/
     
269. void Heating()
     
270. {
     
271.     if(x>=10){beep_st=~beep_st;x=0;}
     
272.     if(Mode==0)
     
273.         {
     
274.             if((c/10)>=100)        //温度到达100停止加热
     
275.                 {
     
276.                     ALAM=0;
     
277.                         ALAM1=1;
     
278.                     ALAM2=1;
     
279.                      if(beep_st==1)
     
280.                         BUZZ=0;
     
281.                         else
     
282.                         BUZZ=1;
     
283.                 }
     
284.                 else
     
285.                 {
     
286.                         BUZZ=1;
     
287.                         ALAM=1;
     
288.                         ALAM1=1;
     
289.                         ALAM2=0;
     
290.                 }
     
291.     }
     
292. }
     
293. /*****中断*****/
     
294. void init()
     
295. {
     
296.     EA=1;
     
297.         EX0=1;EX1=1;
     
298.         PX0=0;PX1=1;
     
299.         IT0=0;IT1=0;
     
300. }

复制代码

51hei图片_20220310130940.png (75.86 KB, 下载次数: 36)

下载附件

2022-3-10 13:25 上传

下载.png (92.25 KB, 下载次数: 19)

下载附件

2022-3-10 14:15 上传

下载 (1).png (91.78 KB, 下载次数: 28)

下载附件

2022-3-10 14:15 上传

程序和仿真.zip

2022-3-10 13:33 上传

点击文件名下载附件

108.4 KB, 下载次数: 4

---

作者: rundstedt    时间: 2022-3-10 17:43
仿真不出来，做实际电路吧！

---

作者: lkc8210    时间: 2022-3-10 22:18
以下是原整代码
在while(1)中套while(1)是什么鬼写法？
定时器0没有初始化
定时器0中断中的代码是放着好看的吧？

1. #include <reg51.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char           //宏定义
   
4. #define LCD1602 P0
   
5. sbit SET=P3^1;                            //定义调整键
   
6. sbit DEC=P2^1;                            //定义减少键
   
7. sbit ADD=P2^0;                            //定义增加键
   
8. sbit BUZZ=P3^6;                            //定义蜂鸣器
   
9. sbit ALAM=P1^2;                                //定义灯光报警
   
10. sbit ALAM1=P1^4;
    
11. sbit ALAM2=P1^6;
    
12. sbit DQ=P3^7;                             //定义DS18B20总线I/O
    
13. sbit RS = P2^7;
    
14. sbit EN = P2^6;
    
15. sbit key1=P1^0;
    
16. sbit key2=P1^1;
    
17. bit shanshuo_st;                            //闪烁间隔标志
    
18. bit beep_st;                                     //蜂鸣器间隔标志
    
19. uchar x=0;                                      //计数器
    
20. 
    
21. sbit led1=P2^0;
    
22. sbit led2=P2^1;
    
23. sbit led3=P2^2;
    
24. sbit led4=P2^3;
    
25. sbit motor=P2^4;
    
26. 
    
27. uchar code tab1[]= {"Now Tem:   .  C "};
    
28. uchar code tab2[]= {"Set Tem:   C    "};
    
29. uint c;
    
30. uchar Mode=0;                             //状态标志
    
31. signed char T=90;                  //设置报警温度，默认值为90
    
32. 
    
33. 
    
34. //============================================================================================
    
35. //====================================DS18B20=================================================
    
36. //============================================================================================
    
37. /*****延时子程序*****/
    
38. void Delay_DS18B20(int num)
    
39. {
    
40.     while(num--) ;
    
41. }
    
42. void delay(uint xms)//延时函数，有参函数
    
43. {
    
44.     uint x,y;
    
45.     for(x=xms; x>0; x--)
    
46.         for(y=110; y>0; y--);
    
47. }
    
48. /*****初始化DS18B20*****/
    
49. void Init_DS18B20(void)
    
50. {
    
51.     unsigned char x=0;
    
52.     DQ = 1;         //DQ复位
    
53.     Delay_DS18B20(8);    //稍做延时
    
54.     DQ = 0;         //单片机将DQ拉低
    
55.     Delay_DS18B20(80);   //精确延时，大于480us
    
56.     DQ = 1;         //拉高总线
    
57.     Delay_DS18B20(14);
    
58.     x = DQ;           //稍做延时后，如果x=0则初始化成功，x=1则初始化失败
    
59.     Delay_DS18B20(20);
    
60. }
    
61. /*****读一个字节*****/
    
62. unsigned char ReadOneChar(void)
    
63. {
    
64.     unsigned char i=0;
    
65.     unsigned char dat = 0;
    
66.     for (i=8; i>0; i--)
    
67.     {
    
68.         DQ = 0;     // 给脉冲信号
    
69.         dat>>=1;
    
70.         DQ = 1;     // 给脉冲信号
    
71.         if(DQ)
    
72.             dat|=0x80;
    
73.         Delay_DS18B20(4);
    
74.     }
    
75.     return(dat);
    
76. }
    
77. /*****写一个字节*****/
    
78. void WriteOneChar(unsigned char dat)
    
79. {
    
80.     unsigned char i=0;
    
81.     for (i=8; i>0; i--)
    
82.     {
    
83.         DQ = 0;
    
84.         DQ = dat&0x01;
    
85.         Delay_DS18B20(5);
    
86.         DQ = 1;
    
87.         dat>>=1;
    
88.     }
    
89. }
    
90. /*****读取温度*****/
    
91. unsigned int ReadTemperature(void)
    
92. {
    
93.     unsigned char a=0;
    
94.     unsigned char b=0;
    
95.     unsigned int t=0;
    
96.     float tt=0;
    
97.     Init_DS18B20();
    
98.     WriteOneChar(0xCC);  //跳过读序号列号的操作
    
99.     WriteOneChar(0x44);  //启动温度转换
    
100.     Init_DS18B20();
     
101.     WriteOneChar(0xCC);  //跳过读序号列号的操作
     
102.     WriteOneChar(0xBE);  //读取温度寄存器
     
103.     a=ReadOneChar();     //读低8位
     
104.     b=ReadOneChar();    //读高8位
     
105.     t=b;
     
106.     t<<=8;
     
107.     t=t|a;
     
108.     tt=t*0.0625;
     
109. // t= tt*10+0.5;     //放大10倍输出并四舍五入
     
110.     t= tt*10+0.5;
     
111.     return(t);
     
112. }
     
113. 
     
114. /*****读取温度*****/
     
115. void check_wendu(void)
     
116. {
     
117.     c=ReadTemperature()-5;                          //获取温度值并减去DS18B20的温漂误差
     
118.     if(c>1200)
     
119.     {
     
120.         c=1200;
     
121.     }
     
122. }
     
123. 
     
124. /********液晶写入指令函数与写入数据函数，以后可调用**************/
     
125. 
     
126. void write_1602com(uchar com)//****液晶写入指令函数****
     
127. {
     
128.     RS=0;//数据/指令选择置为指令
     
129. //        rw=0; //读写选择置为写
     
130.     LCD1602=com;//送入数据
     
131.     delay(1);
     
132.     EN=1;//拉高使能端，为制造有效的下降沿做准备
     
133.     delay(1);
     
134.     EN=0;//en由高变低，产生下降沿，液晶执行命令
     
135. }
     
136. 
     
137. 
     
138. void write_1602dat(uchar dat)//***液晶写入数据函数****
     
139. {
     
140.     RS=1;//数据/指令选择置为数据
     
141. //        rw=0; //读写选择置为写
     
142.     LCD1602=dat;//送入数据
     
143.     delay(1);
     
144.     EN=1; //en置高电平，为制造下降沿做准备
     
145.     delay(1);
     
146.     EN=0; //en由高变低，产生下降沿，液晶执行命令
     
147. }
     
148. 
     
149. 
     
150. void lcd_init()//***液晶初始化函数****
     
151. {
     
152.     uchar a;
     
153.     write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
     
154.     write_1602com(0x0c);//开显示不显示光标
     
155.     write_1602com(0x06);//整屏不移动，光标自动右移
     
156.     write_1602com(0x01);//清显示
     
157. 
     
158.     write_1602com(0x80);//日历显示固定符号从第一行第1个位置之后开始显示
     
159.     for(a=0; a<16; a++)
     
160.     {
     
161.         write_1602dat(tab1[a]);//向液晶屏写日历显示的固定符号部分
     
162.         delay(3);
     
163.     }
     
164.     write_1602com(0x80+0x40);//时间显示固定符号写入位置，从第2个位置后开始显示
     
165.     for(a=0; a<16; a++)
     
166.     {
     
167.         write_1602dat(tab2[a]);//写显示时间固定符号，两个冒号
     
168.         delay(3);
     
169.     }
     
170. 
     
171. }
     
172. 
     
173. void display()
     
174. {
     
175.     if(Mode==0)
     
176.     {
     
177.         write_1602com(0x80+8);
     
178.         write_1602dat(c/1000+0x30);
     
179.         write_1602dat((c%1000)/100+0x30);
     
180.         write_1602dat(((c%1000)%100)/10+0x30);
     
181. 
     
182.         write_1602com(0x80+12);
     
183.         write_1602dat(((c%1000)%100)%10+0x30);
     
184. 
     
185.         write_1602com(0x80+13);
     
186.         write_1602dat(0xdf);
     
187. 
     
188.         write_1602com(0x80+0x40+8);
     
189.         write_1602dat(T/10+0x30);
     
190.         write_1602dat(T%10+0x30);
     
191.         write_1602dat(0xdf);
     
192.     }
     
193. }
     
194. //=====================================================================================
     
195. 
     
196. /*****按键程序*****/
     
197. void KEY()
     
198. {
     
199.     //功能键
     
200.     if(SET==0)
     
201.     {
     
202.         BUZZ=0;
     
203.         delay(10);
     
204.         if(SET==0)
     
205.         {
     
206.             Mode++;
     
207.             if(Mode==2)
     
208.                 Mode=0;
     
209.             BUZZ=1;
     
210.         }
     
211.         while(SET==0)
     
212.         {
     
213.             if(Mode==0)
     
214.             {
     
215.                 //        write_1602com(0x80+0x40+6);
     
216.                 write_1602com(0x0c);
     
217.             }
     
218.             else if(Mode==1)
     
219.             {
     
220.                 write_1602com(0x80+0x40+9);
     
221.                 write_1602com(0x0f);
     
222.             }
     
223. 
     
224.         }
     
225.     }
     
226.     //增加
     
227.     if(ADD==0&&Mode==1)
     
228.     {
     
229.         BUZZ=0;
     
230.         delay(10);
     
231.         if(ADD==0)
     
232.         {
     
233.             T++;
     
234.             if(T>=99)
     
235.                 T=99;
     
236.             write_1602com(0x80+0x40+8);
     
237.             write_1602dat(T/10+0x30);
     
238.             write_1602dat(T%10+0x30);
     
239.             write_1602com(0x80+0x40+9);
     
240.             BUZZ=1;
     
241.         }
     
242.         while(ADD==0);
     
243.     }
     
244.     //减少
     
245.     if(DEC==0&&Mode==1)
     
246.     {
     
247.         BUZZ=0;
     
248.         delay(10);
     
249.         if(DEC==0)
     
250.         {
     
251.             T--;
     
252.             write_1602com(0x80+0x40+8);
     
253.             write_1602dat(T/10+0x30);
     
254.             write_1602dat(T%10+0x30);
     
255.             write_1602com(0x80+0x40+9);
     
256.             BUZZ=1;
     
257.         }
     
258.         while(DEC==0);
     
259.     }
     
260. }
     
261. 
     
262. /*****报警子程序*****/
     
263. void Alarm()
     
264. {
     
265.     if(x>=10) {
     
266.         beep_st=~beep_st;
     
267.         x=0;
     
268.     }
     
269.     if(Mode==0)
     
270.     {
     
271.         if((c/10)>=T)
     
272.         {
     
273.             ALAM=0;
     
274.             ALAM1=1;
     
275.             ALAM2=1;
     
276.             if(beep_st==1)
     
277.                 BUZZ=0;
     
278.             else
     
279.                 BUZZ=1;
     
280.         }
     
281.         else
     
282.         {
     
283.             BUZZ=1;
     
284.             ALAM=1;
     
285.             ALAM1=0;
     
286.             ALAM2=1;
     
287.         }
     
288.     }
     
289. }
     
290. 
     
291. /*****加热子程序*****/
     
292. void Heating()
     
293. {
     
294.     if(x>=10) {
     
295.         beep_st=~beep_st;
     
296.         x=0;
     
297.     }
     
298.     if(Mode==0)
     
299.     {
     
300.         if((c/10)>=100)
     
301.         {
     
302.             ALAM=0;
     
303.             ALAM1=1;
     
304.             ALAM2=1;
     
305.             if(beep_st==1)
     
306.                 BUZZ=0;
     
307.             else
     
308.                 BUZZ=1;
     
309.         }
     
310.         else
     
311.         {
     
312.             BUZZ=1;
     
313.             ALAM=1;
     
314.             ALAM1=1;
     
315.             ALAM2=0;
     
316.         }
     
317.     }
     
318. }
     
319. 
     
320. /*****中断*****/
     
321. void init()
     
322. {
     
323.     EA=1;
     
324.     EX0=1;
     
325.     EX1=1;
     
326.     PX0=0;
     
327.     PX1=1;
     
328.     IT0=0;
     
329.     IT1=0;
     
330. }
     
331. 
     
332. /*****主函数*****/
     
333. void main()
     
334. {
     
335.     while(1)
     
336.     {
     
337.         P1=0xFC;
     
338.         if(key1==0&&key2==0)
     
339.         {
     
340.             ALAM=0;
     
341.             ALAM1=0;
     
342.             ALAM2=0;
     
343.         }
     
344.         else if(key1==1&&key2==1)
     
345.         {
     
346.             uint z;
     
347.             delay(1);
     
348.             lcd_init();
     
349.             delay(1);
     
350.             init();
     
351.             for(z=0; z<100; z++)
     
352.             {
     
353.                 check_wendu();
     
354.                 delay(1);
     
355.             }
     
356.             while(1)
     
357.             {
     
358.                 display();
     
359.                 KEY();
     
360.                 Alarm();
     
361.                 check_wendu();
     
362.             }
     
363.         }
     
364.         else if(key1==0&&key2==1)
     
365.         {
     
366.             ALAM=0;
     
367.             ALAM1=0;
     
368.             ALAM2=0;
     
369.         }
     
370.         else if(key1==1&&key2==0)
     
371.         {
     
372.             uint z;
     
373.             delay(1);
     
374.             lcd_init();
     
375.             delay(1);
     
376.             init();
     
377.             for(z=0; z<100; z++)
     
378.             {
     
379.                 check_wendu();
     
380.                 delay(1);
     
381.             }
     
382.             while(1)
     
383.             {
     
384.                 display();
     
385.                 KEY();
     
386.                 Alarm();
     
387.                 check_wendu();
     
388.             }
     
389.         }
     
390.     }
     
391. }
     
392. 
     
393. /*****定时器0中断服务程序*****/
     
394. void init0() interrupt 1
     
395. {
     
396.     uchar k;
     
397.     EX0=0;
     
398.     for(k=0; k<2; k++)
     
399.     {
     
400.         uint z;
     
401.         delay(1);
     
402.         lcd_init();
     
403.         delay(1);
     
404.         init();
     
405.         for(z=0; z<100; z++)
     
406.         {
     
407.             display();
     
408.             delay(1);
     
409.             KEY();
     
410.             delay(1);
     
411.             Heating();
     
412.             delay(1);
     
413.             check_wendu();
     
414.             delay(1);
     
415.             display();
     
416.             delay(1);
     
417.             KEY();
     
418.             delay(1);
     
419.             EX0=1;
     
420.         }
     
421.     }
     
422. }

复制代码

---

作者: Ficus    时间: 2022-3-11 09:02

lkc8210 发表于 2022-3-10 22:18
以下是原整代码
在while(1)中套while(1)是什么鬼写法？
定时器0没有初始化

感谢帮助！不好意思！注释写错了！那个应该是中断初始化和外部中断0中断服务程序 我昨天要改一下的不小心发出去了

---

作者: lkc8210    时间: 2022-3-11 14:36

Ficus 发表于 2022-3-11 09:02
感谢帮助！不好意思！注释写错了！那个应该是中断初始化和外部中断0中断服务程序 我昨天要改一下的不小心 ...

不只注释写错了
中断号也错了
interrupt 1是定时器0的中断
interrupt 0才是外中断0的

而且中断里要干的事也太多了吧？

你的外中断设定是低电平触发
结合你的按键电路
R8把外中断0引脚接地了
你的程序就不断在外中断中循环了

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1