求大神帮忙看看单片机代码哪里错了，万分感谢，比较急

1. #include<reg51.h>
   
2. #include<intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. uchar temp,num,klnum;
   
6. uchar code table[]={"18B20 OKTL"};
   
7. char shangxiaxian[2]={-10,10};
   
8. char a;
   
9. sbit k1=P1^0;
   
10. sbit k2=P1^1;
    
11. sbit k3=P1^2;
    
12. sbit k4=P1^3;
    
13. sbit LCD_RW=P2^5;
    
14. sbit lcdrs=P2^6;
    
15. sbit lcden=P2^7;
    
16. sbit Beep=P3^0;
    
17. sbit led=P3^1;
    
18. sbit DQ=P3^7;    /*液晶显示屏的延时程序*/
    
19. void delay(uint z)
    
20. {
    
21. uint x,y;
    
22. for(x=z;x>0;x--)
    
23.     for(y=110;y>0;y--);
    
24. }                 /*温度传感器的延时程序*/
    
25. void Delay1(uint y)
    
26. {
    
27. uint x;
    
28. for( ;y>0; y--)
    
29.   {
    
30.    for(x=110;x>0;x--);
    
31.   }
    
32. }                 /*蜂鸣器，18B20写数据函数的延时程序*/
    
33. void delay2(uint a)
    
34. {
    
35. while(--a);
    
36. }                                       /*温度传感器初始化函数*/
    
37. void init_18B20()
    
38. {
    
39. DQ=1;
    
40. delay2(8);
    
41. DQ=0;
    
42. delay2(90);
    
43. DQ=1;
    
44. _nop_();
    
45. _nop_();
    
46. delay2(100);
    
47. DQ=1;
    
48. }                  /*温度传感器写字节命令函数*/
    
49. void DS18B20xiezijie(uchar date)
    
50. {
    
51. uchar i;
    
52. for(i=0;i<8;i++)
    
53.   {
    
54.    DQ=0;                                      //在写入一位数据之前先把总线拉低
    
55.          DQ=date&0x01;                   //写入一个数据，从最低位开始写
    
56.          delay2(5);                               //延时
    
57.          DQ=1;                                      //将总线拉高，等待第二位数据写入
    
58.          date>>=1;                              //右移一位，写入第二位数据
    
59.          }
    
60. }                                                          /*温度传感器读字节命令函数*/
    
61. uchar DS18B20duzijie()
    
62. {
    
63. uchar i,dat=0;
    
64. DQ=1;
    
65. _nop_();
    
66. for(i=0;i<8;i++)
    
67.   {
    
68.    DQ=0;                  //先将总线拉低
    
69.          _nop_();
    
70.          _nop_();
    
71.          dat>>=1;
    
72.          DQ=1;                                      //然后释放总线
    
73.          _nop_();                         //延时一下等待数据稳定
    
74.          _nop_();                        
    
75.          if(DQ)
    
76.          dat|=0x80;                             //读取数据，从最低位开始读取
    
77.          delay2(30);                             //读取完之后等待一下，再接着读取下一个数
    
78.          DQ=1;
    
79.   }
    
80. return dat;                        //返回所读到的温度
    
81. }                                                        /*写温度转换命令函数*/
    
82. void DS18B20ChangTemp()
    
83. {
    
84. init_18B20();
    
85. Delay1(1);
    
86. DS18B20xiezijie(0xcc);   //跳过ROM操作命令
    
87. DS18B20xiezijie(0x44);   //温度转换命令
    
88. }                                                          /*读温度命令函数*/
    
89. void DS18B20ReadTempCom()
    
90. {
    
91. init_18B20();
    
92. Delay1(1);
    
93. DS18B20xiezijie(0xcc);   //跳过ROM操作命令
    
94. DS18B20xiezijie(0xbe);   //发送读取温度命令
    
95. }                                                          /*读温度函数*/
    
96. int DS18B20ReadTemp()
    
97. {
    
98.   inttemp=0;
    
99.   uchartmh,tml;
    
100. DS18B20ChangTemp();           //先写入转换命令
     
101. DS18B20ReadTempCom();     //然后等待转换完成后发送读取温度命令
     
102. tml=DS18B20duzijie();             //读取温度值共16位，先读低字节
     
103. tmh=DS18B20duzijie();           //再读高字节
     
104. temp=tmh;
     
105. temp<<=8;
     
106. temp|=tml;
     
107. return temp;                              /*液晶屏写指令函数*/
     
108. }
     
109. void write_com(uchar com)
     
110. {
     
111. lcdrs=0;
     
112. lcden=0;
     
113. LCD_RW=0;
     
114. P0=com;
     
115. delay(5);
     
116. lcden=1;
     
117. delay(5);
     
118. lcden=0;
     
119. }                                                          /*液晶屏写指令函数*/
     
120. void write_com2(int com)
     
121. {
     
122. lcdrs=0;
     
123. LCD_RW=0;
     
124. lcden=0;
     
125. delay(5);
     
126. P0=com;
     
127. delay(5);
     
128. lcden=1;
     
129. delay(5);
     
130.   lcden=0;
     
131. P0=(com&0x0f)<<4;
     
132. delay(5);
     
133. lcden=1;
     
134. delay(5);
     
135. lcden=0;
     
136. }                                                          /*液晶屏写数据命令函数*/
     
137. void write_data(char date)
     
138. {
     
139. lcdrs=1;
     
140. LCD_RW=0;
     
141. lcden=0;
     
142. P0=date;
     
143. delay(5);
     
144. lcden=1;
     
145. delay(5);
     
146. lcden=0;
     
147. lcdrs=1;
     
148. LCD_RW=0;
     
149. lcden=0;
     
150. P0=(date&0x0f)<<4;       //一次写入4位
     
151. delay(5);
     
152. lcden=1;
     
153. delay(5);
     
154. lcden=0;
     
155. }                                                          /*液晶屏初始化函数*/
     
156. void init()
     
157. {
     
158. lcden=0;
     
159. write_com(0x28);
     
160. write_com2(0x28);
     
161. write_com2(0x0c);
     
162. write_com2(0x06);
     
163. write_com2(0x01);
     
164. write_com2(0x80);
     
165. }                                                          /*报警上下线处理函数*/
     
166. void write_hl(uchar add,char date)
     
167. {
     
168. uchar bai,shi,ge;
     
169. if(date<0){date=-date;}
     
170. bai=date/100;
     
171. shi=date%100/10;
     
172. ge=date%100%10;
     
173. write_com2(0x80+0x40+add);
     
174. write_date(0x30+bai);
     
175. write_date(0x30+shi);
     
176. write_date(0x30+ge);
     
177. }                                                        /*报警上下线处理函数*/
     
178. void write_hl1(uchar add,char date)
     
179. {
     
180. uchar bai,shi,ge;
     
181. if(date<0){date=-date;}
     
182. bai=date/100;
     
183. shi=date%100/10;
     
184. ge=date%100%10;
     
185. write_com2(0x80+add);
     
186. write_date(0x30+bai);
     
187. write_date(0x30+shi);
     
188. write_date(0x30+ge);
     
189. }                                                        /*液晶屏显示函数，显示温度值*/
     
190. void Lcdxianshi(int temp)
     
191. {
     
192. uchar sz[4]={0,0,0,0};
     
193. unsigned char datas[]={0,0,0,0,0}; //定义数组
     
194. float tp;
     
195. if(temp<0)                //当温度值为负数
     
196. {
     
197. write_com2(0x80+0x40);    //写地址80表示初始地址
     
198. write_data('-');          //显示负
     
199. temp=temp-1; //因为读取的温度是实际温度的补码，所以减一，再取反求出原码
     
200. temp=~temp;
     
201. tp=temp;
     
202. temp=tp*0.0625*100+0.5
     
203. }
     
204. else
     
205. {
     
206.   write_com2(0x80+0x40);  //写地址80表示初始地址
     
207.   write_data('+');                    //显示正
     
208.   tp=temp;  //因为数据处理有小数点，所以将温度赋给一个浮点型变量，如果温度是正，那么正数的原码就是补码本身
     
209.   temp=tp*0.0625*100+0.5;
     
210.   }
     
211. datas[0]=temp/1000;                       //百位
     
212. datas[1]=tem%10000/1000;          //十位
     
213. datas[2]=temp%1000/100;       //个位
     
214. datas[3]=temp%100/10;                          //小数
     
215. write_com2(0x80+0x40+1);
     
216. write_data('0'+datas[0]);
     
217. write_com2(0x80+0x40+2);
     
218. write_data('0'+datas[1]);
     
219. write_com2(0x80+0x40+3);
     
220. write_data('0'+datas[2]);
     
221. write_com2(0x80+0x40+4);
     
222. write_data('.');
     
223. write_com2(0x80+0x40+5);
     
224. write_data('0'+datas[3]);
     
225. a=(datas[0]*100+datas[1]*10+datas[2]);  //用于温度的比较值
     
226. write_hl(13,shangxiaxian[1]);  //显示报警上限
     
227. write_hl1(13,shangxiaxian[0]);      //显示报警下限
     
228. }                                                                         /*按键处理函数，用于设置温度报警值*/
     
229. void key()
     
230. {
     
231. if(k1==0)
     
232.   {
     
233.   delay(5);
     
234.   if(k1==0)  //温度报警下限加
     
235.    {
     
236.     shangxiaxian[0]++;
     
237.           if(shangxiaxian[0]==127)
     
238.           shangxiaxian[0]=126;
     
239.           write_hl1(13,shangxiaxian[0]);
     
240.          }
     
241.    }
     
242.     if(k2==0)  //温度报警下限减
     
243.             {
     
244.               delay(5);
     
245.                     if(k2==0)
     
246.                     {
     
247.                      shangxiaxian[0]--;
     
248.                      if(shangxiaxian[0]==-56)
     
249.                      shangxiaxian[0]=-55;
     
250.                      write_hl1(13,shangxiaxian[0]);
     
251.                     }
     
252.                    }
     
253.           if(k3==0)  //温度报警上限加
     
254.             {
     
255.              delay(5);
     
256.                    if(k3==0)
     
257.                     {
     
258.                       shangxiaxian[1]++;
     
259.                       if(shangxiaxian[1]==127)
     
260.                       shangxiaxian[1]=126;
     
261.                       write_hl(13,shangxiaxian[1]);
     
262.                      }
     
263.                    }
     
264.                     if(k4==0)  //温度报警上限减
     
265.                     {
     
266.                      delay(5);
     
267.                      if(k4==0)
     
268.                      {
     
269.                       shangxiaxian[1]--;
     
270.                       if(shangxiaxian[1]==-56)
     
271.                       shangxiaxian[1]=-55;
     
272.                       write_hl(13,shangxiaxian[1]);
     
273.                      }
     
274.                     }
     
275.          }
     
276. void main()
     
277. {
     
278. intb;
     
279. init();
     
280. led=0;
     
281. for(num=0;num<11;num++)   //让液晶屏显示“18B20 OK TL”
     
282. {
     
283. write_data(table[num]);
     
284. delay(20);
     
285.   }
     
286. write_com2(0x80+0x40+9);
     
287. write_data('T');
     
288. write_com2(0x80+0x40+10);
     
289. write_data('H');
     
290. while(1)
     
291.   {
     
292.    key();
     
293.          Lcdxianshi(Ds18B20ReadTemp());
     
294.          delay(100);
     
295.          if(shangxiaxian[0]<0)
     
296.          {
     
297.            write_com2(0x80+12);
     
298.            write_data('-');
     
299.          }
     
300.   else
     
301.    {
     
302.     write_com2(0x80+12);
     
303.           write_data('+');
     
304.          }
     
305.    if(shangxiaxian[1]<0)
     
306.          {
     
307.          write_com2(0x80+0x40+12);
     
308.          write_data('-');
     
309.     }
     
310.          else
     
311.          {
     
312.          write_com2(0x80+0x40+12);
     
313.          write_data('+');
     
314.          }
     
315.            if(a>shangxiaxian[1])    //判断温度值与报警值的大小
     
316.            {
     
317.              write_com2(0x80+0x40+6);
     
318.                    write_data('<');
     
319.                    write_com2(0x80+0x40+7);
     
320.                    write_data('L');
     
321.            }
     
322.           if(a>=shangxiaxian[0]&&a<=shangxiaxian[1]) //判断温度值与报警值的大小
     
323.            {
     
324.              write_com2(0x80+0x40+6);
     
325.                    write_data('');
     
326.                    write_com2(0x80+0x40+7);
     
327.                    write_data('！');
     
328.            }
     
329.           if(a>shangxiaxian[0]||a>shangxiaxian[1])  //如果温度值在报警值之外，蜂鸣器响
     
330.            {
     
331.              for(b=0;b<1000;b++)
     
332.                      {Beep=1;led=1;
     
333.                       delay2(20);
     
334.                       Beep=0;led=0;
     
335.                       delay0(20);
     
336.                       }
     
337.                    }
     
338.          }
     
339. }
     
340. 
     
341. 
     
342. 
     
343. 
     

复制代码

错误很多，基本都是抄写错误。大小写错误、中文符号错误、丢分号，缺空格等等。现已通过编译。

1. #include<reg51.h>
   
2. #include<intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. uchar temp,num,klnum;
   
6. uchar code table[]={"18B20 OKTL"};
   
7. char shangxiaxian[2]={-10,10};
   
8. char a;
   
9. sbit k1=P1^0;
   
10. sbit k2=P1^1;
    
11. sbit k3=P1^2;
    
12. sbit k4=P1^3;
    
13. sbit LCD_RW=P2^5;
    
14. sbit lcdrs=P2^6;
    
15. sbit lcden=P2^7;
    
16. sbit Beep=P3^0;
    
17. sbit led=P3^1;
    
18. sbit DQ=P3^7;    /*液晶显示屏的延时程序*/
    
19. void delay(uint z)
    
20. {
    
21.         uint x,y;
    
22.         for(x=z;x>0;x--)
    
23.                 for(y=110;y>0;y--);
    
24. }
    
25. /*温度传感器的延时程序*/
    
26. void Delay1(uint y)
    
27. {
    
28.         uint x;
    
29.         for( ;y>0; y--)
    
30.         {
    
31.                 for(x=110;x>0;x--);
    
32.         }
    
33. }
    
34. /*蜂鸣器，18B20写数据函数的延时程序*/
    
35. void delay2(uint a)
    
36. {
    
37.         while(--a);
    
38. }
    
39. /*温度传感器初始化函数*/
    
40. void init_18B20()
    
41. {
    
42.         DQ=1;
    
43.         delay2(8);
    
44.         DQ=0;
    
45.         delay2(90);
    
46.         DQ=1;
    
47.         _nop_();
    
48.         _nop_();
    
49.         delay2(100);
    
50.         DQ=1;
    
51. }
    
52. /*温度传感器写字节命令函数*/
    
53. void DS18B20xiezijie(uchar date)
    
54. {
    
55.         uchar i;
    
56.         for(i=0;i<8;i++)
    
57.         {
    
58.                 DQ=0;                                      //在写入一位数据之前先把总线拉低
    
59.                 DQ=date&0x01;                   //写入一个数据，从最低位开始写
    
60.                 delay2(5);                               //延时
    
61.                 DQ=1;                                      //将总线拉高，等待第二位数据写入
    
62.                 date>>=1;                              //右移一位，写入第二位数据
    
63.         }
    
64. }                                                          /*温度传感器读字节命令函数*/
    
65. uchar DS18B20duzijie()
    
66. {
    
67.         uchar i,dat=0;
    
68.         DQ=1;
    
69.         _nop_();
    
70.         for(i=0;i<8;i++)
    
71.         {
    
72.                 DQ=0;                  //先将总线拉低
    
73.                 _nop_();
    
74.                 _nop_();
    
75.                 dat>>=1;
    
76.                 DQ=1;                                      //然后释放总线
    
77.                 _nop_();                         //延时一下等待数据稳定
    
78.                 _nop_();                        
    
79.                 if(DQ)
    
80.                 dat|=0x80;                             //读取数据，从最低位开始读取
    
81.                 delay2(30);                             //读取完之后等待一下，再接着读取下一个数
    
82.                 DQ=1;
    
83.         }
    
84.         return dat;                        //返回所读到的温度
    
85. }                                                        /*写温度转换命令函数*/
    
86. void DS18B20ChangTemp()
    
87. {
    
88.         init_18B20();
    
89.         Delay1(1);
    
90.         DS18B20xiezijie(0xcc);   //跳过ROM操作命令
    
91.         DS18B20xiezijie(0x44);   //温度转换命令
    
92. }                                                          /*读温度命令函数*/
    
93. void DS18B20ReadTempCom()
    
94. {
    
95.         init_18B20();
    
96.         Delay1(1);
    
97.         DS18B20xiezijie(0xcc);   //跳过ROM操作命令
    
98.         DS18B20xiezijie(0xbe);   //发送读取温度命令
    
99. }                                                          /*读温度函数*/
    
100. int DS18B20ReadTemp()
     
101. {
     
102.         int temp=0;
     
103.         uchar tmh,tml;
     
104.         DS18B20ChangTemp();           //先写入转换命令
     
105.         DS18B20ReadTempCom();     //然后等待转换完成后发送读取温度命令
     
106.         tml=DS18B20duzijie();             //读取温度值共16位，先读低字节
     
107.         tmh=DS18B20duzijie();           //再读高字节
     
108.         temp=tmh;
     
109.         temp<<=8;
     
110.         temp|=tml;
     
111.         return temp;                              /*液晶屏写指令函数*/
     
112. }
     
113. void write_com(uchar com)
     
114. {
     
115.         lcdrs=0;
     
116.         lcden=0;
     
117.         LCD_RW=0;
     
118.         P0=com;
     
119.         delay(5);
     
120.         lcden=1;
     
121.         delay(5);
     
122.         lcden=0;
     
123. }                                                          /*液晶屏写指令函数*/
     
124. void write_com2(int com)
     
125. {
     
126.         lcdrs=0;
     
127.         LCD_RW=0;
     
128.         lcden=0;
     
129.         delay(5);
     
130.         P0=com;
     
131.         delay(5);
     
132.         lcden=1;
     
133.         delay(5);
     
134.         lcden=0;
     
135.         P0=(com&0x0f)<<4;
     
136.         delay(5);
     
137.         lcden=1;
     
138.         delay(5);
     
139.         lcden=0;
     
140. }                                                          /*液晶屏写数据命令函数*/
     
141. void write_data(char date)
     
142. {
     
143.         lcdrs=1;
     
144.         LCD_RW=0;
     
145.         lcden=0;
     
146.         P0=date;
     
147.         delay(5);
     
148.         lcden=1;
     
149.         delay(5);
     
150.         lcden=0;
     
151.         lcdrs=1;
     
152.         LCD_RW=0;
     
153.         lcden=0;
     
154.         P0=(date&0x0f)<<4;       //一次写入4位
     
155.         delay(5);
     
156.         lcden=1;
     
157.         delay(5);
     
158.         lcden=0;
     
159. }                                                          /*液晶屏初始化函数*/
     
160. void init()
     
161. {
     
162.         lcden=0;
     
163.         write_com(0x28);
     
164.         write_com2(0x28);
     
165.         write_com2(0x0c);
     
166.         write_com2(0x06);
     
167.         write_com2(0x01);
     
168.         write_com2(0x80);
     
169. }                                                          /*报警上下线处理函数*/
     
170. void write_hl(uchar add,char date)
     
171. {
     
172.         uchar bai,shi,ge;
     
173.         if(date<0){date=-date;}
     
174.         bai=date/100;
     
175.         shi=date%100/10;
     
176.         ge=date%100%10;
     
177.         write_com2(0x80+0x40+add);
     
178.         write_data(0x30+bai);
     
179.         write_data(0x30+shi);
     
180.         write_data(0x30+ge);
     
181. }                                                        /*报警上下线处理函数*/
     
182. void write_hl1(uchar add,char date)
     
183. {
     
184.         uchar bai,shi,ge;
     
185.         if(date<0){date=-date;}
     
186.         bai=date/100;
     
187.         shi=date%100/10;
     
188.         ge=date%100%10;
     
189.         write_com2(0x80+add);
     
190.         write_data(0x30+bai);
     
191.         write_data(0x30+shi);
     
192.         write_data(0x30+ge);
     
193. }                                                        /*液晶屏显示函数，显示温度值*/
     
194. void Lcdxianshi(int temp)
     
195. {
     
196.         uchar sz[4]={0,0,0,0};
     
197.         unsigned char datas[]={0,0,0,0,0}; //定义数组
     
198.         float tp;
     
199.         if(temp<0)                //当温度值为负数
     
200.         {
     
201.                 write_com2(0x80+0x40);    //写地址80表示初始地址
     
202.                 write_data('-');          //显示负
     
203.                 temp=temp-1; //因为读取的温度是实际温度的补码，所以减一，再取反求出原码
     
204.                 temp=~temp;
     
205.                 tp=temp;
     
206.                 temp=tp*0.0625*100+0.5;
     
207.         }
     
208.         else
     
209.         {
     
210.                 write_com2(0x80+0x40);  //写地址80表示初始地址
     
211.                 write_data('+');                    //显示正
     
212.                 tp=temp;  //因为数据处理有小数点，所以将温度赋给一个浮点型变量，如果温度是正，那么正数的原码就是补码本身
     
213.                 temp=tp*0.0625*100+0.5;
     
214.         }
     
215.         datas[0]=temp/10000;                       //百位
     
216.         datas[1]=temp%10000/1000;          //十位
     
217.         datas[2]=temp%1000/100;       //个位
     
218.         datas[3]=temp%100/10;                          //小数
     
219.         write_com2(0x80+0x40+1);
     
220.         write_data('0'+datas[0]);
     
221.         write_com2(0x80+0x40+2);
     
222.         write_data('0'+datas[1]);
     
223.         write_com2(0x80+0x40+3);
     
224.         write_data('0'+datas[2]);
     
225.         write_com2(0x80+0x40+4);
     
226.         write_data('.');
     
227.         write_com2(0x80+0x40+5);
     
228.         write_data('0'+datas[3]);
     
229.         a=(datas[0]*100+datas[1]*10+datas[2]);  //用于温度的比较值
     
230.         write_hl(13,shangxiaxian[1]);  //显示报警上限
     
231.         write_hl1(13,shangxiaxian[0]);      //显示报警下限
     
232. }                                                                         /*按键处理函数，用于设置温度报警值*/
     
233. void key()
     
234. {
     
235.         if(k1==0)
     
236.         {
     
237.                 delay(5);
     
238.                 if(k1==0)  //温度报警下限加
     
239.                 {
     
240.                         shangxiaxian[0]++;
     
241.                         if(shangxiaxian[0]==127)
     
242.                                 shangxiaxian[0]=126;
     
243.                         write_hl1(13,shangxiaxian[0]);
     
244.                 }
     
245.         }
     
246.         if(k2==0)  //温度报警下限减
     
247.         {
     
248.                 delay(5);
     
249.                 if(k2==0)
     
250.                 {
     
251.                         shangxiaxian[0]--;
     
252.                         if(shangxiaxian[0]==-56)
     
253.                                 shangxiaxian[0]=-55;
     
254.                         write_hl1(13,shangxiaxian[0]);
     
255.                 }
     
256.         }
     
257.         if(k3==0)  //温度报警上限加
     
258.         {
     
259.                 delay(5);
     
260.                 if(k3==0)
     
261.                 {
     
262.                         shangxiaxian[1]++;
     
263.                         if(shangxiaxian[1]==127)
     
264.                                 shangxiaxian[1]=126;
     
265.                         write_hl(13,shangxiaxian[1]);
     
266.                 }
     
267.         }
     
268.         if(k4==0)  //温度报警上限减
     
269.         {
     
270.                 delay(5);
     
271.                 if(k4==0)
     
272.                 {
     
273.                         shangxiaxian[1]--;
     
274.                         if(shangxiaxian[1]==-56)
     
275.                                 shangxiaxian[1]=-55;
     
276.                         write_hl(13,shangxiaxian[1]);
     
277.                 }
     
278.         }
     
279. }
     
280. void main()
     
281. {
     
282.         int b;
     
283.         init();
     
284.         led=0;
     
285.         for(num=0;num<11;num++)   //让液晶屏显示“18B20 OK TL”
     
286.         {
     
287.                 write_data(table[num]);
     
288.                 delay(20);
     
289.         }
     
290.         write_com2(0x80+0x40+9);
     
291.         write_data('T');
     
292.         write_com2(0x80+0x40+10);
     
293.         write_data('H');
     
294.         while(1)
     
295.         {
     
296.                 key();
     
297.                 Lcdxianshi(DS18B20ReadTemp());
     
298.                 delay(100);
     
299.                 if(shangxiaxian[0]<0)
     
300.                 {
     
301.                         write_com2(0x80+12);
     
302.                         write_data('-');
     
303.                 }
     
304.                 else
     
305.                 {
     
306.                         write_com2(0x80+12);
     
307.                         write_data('+');
     
308.                 }
     
309.                 if(shangxiaxian[1]<0)
     
310.                 {
     
311.                         write_com2(0x80+0x40+12);
     
312.                         write_data('-');
     
313.                 }
     
314.                 else
     
315.                 {
     
316.                         write_com2(0x80+0x40+12);
     
317.                         write_data('+');
     
318.                 }
     
319.                 if(a>shangxiaxian[1])    //判断温度值与报警值的大小
     
320.                 {
     
321.                         write_com2(0x80+0x40+6);
     
322.                         write_data('<');
     
323.                         write_com2(0x80+0x40+7);
     
324.                         write_data('L');
     
325.                 }
     
326.                 if(a>=shangxiaxian[0]&&a<=shangxiaxian[1]) //判断温度值与报警值的大小
     
327.                 {
     
328.                         write_com2(0x80+0x40+6);
     
329.                         write_data(' ');
     
330.                         write_com2(0x80+0x40+7);
     
331.                         write_data('!');
     
332.                 }
     
333.                 if(a>shangxiaxian[0]||a>shangxiaxian[1])  //如果温度值在报警值之外，蜂鸣器响
     
334.                 {
     
335.                         for(b=0;b<1000;b++)
     
336.                         {
     
337.                                 Beep=1;led=1;
     
338.                                 delay2(20);
     
339.                                 Beep=0;led=0;
     
340.                                 delay(20);
     
341.                         }
     
342.                 }
     
343.         }
     
344. }
     
345. 
     

复制代码

软件会提示错误在哪一行，其实 还是要自己学会去调试，刚开始先写一些简单一点的代码会容易一点

随风飘远 发表于 2020-6-26 10:08
软件会提示错误在哪一行，其实 还是要自己学会去调试，刚开始先写一些简单一点的代码会容易一点

请问您有时间帮我看一下这个错误怎么改吗？