一个简单的单片机温度报警系统程序

单片机源程序如下:

1. #include <reg51.h>
   
2. #include <intrins.h>
   
3. #include <stdio.h>
   
4. 
   
5. typedef unsigned int uint;
   
6. typedef unsigned char uchar;
   
7. 
   
8. /********************引脚定义********************/
   
9. #define LCD_DATA P0
   
10. sbit LCD_RS = P2^0;
    
11. sbit LCD_RW = P2^1;
    
12. sbit LCD_EN = P2^2;
    
13. sbit KEY_1 = P1^7;                        //功能键
    
14. sbit KEY_2 = P1^4;                        //减少键
    
15. sbit KEY_3 = P1^2;                        //增加按键
    
16. sbit DS18B20 = P2^6;
    
17. /************************************************/
    
18. 
    
19. /********************全局变量********************/
    
20. #define KeyTime 200                                        //200 * 1ms = 200ms
    
21. #define DispTime 100                                //100 * 1ms = 100ms
    
22. #define UartTime 150                                //150 * 1ms = 150ms
    
23. volatile uchar KEY_1ms = 0;
    
24. volatile uchar Disp_1ms = 0;
    
25. volatile uchar Uart_1ms = 0;
    
26. volatile uchar Menu = 0;                //0(显示当前温度), 1(设置最低温度), 2(设置最低温度)
    
27. volatile int MaxTemp = 40;
    
28. volatile int MinTemp = -10;
    
29. volatile float Temperature = 0;
    
30. /************************************************/
    
31. 
    
32. /********************函数声明********************/
    
33. void Delay_us(uchar x);
    
34. void Delay_ms(uchar x);
    
35. void Timer0Init(void);
    
36. void KEY_Proc(void);
    
37. void DispTemp(void);
    
38. void LCD_WriteCommand(uchar com);
    
39. void LCD_WriteData(uchar dat);
    
40. void LCD_Init(void);
    
41. void LCD_Show_Home(void);
    
42. void LCD_Show_Setting(void);
    
43. void DS18B20_Init(void);
    
44. uchar DS18B20_ReadByte(void);
    
45. void DS18B20_WriteByte(uchar dat);
    
46. float DS18B20_ReadTmp(void);
    
47. void UartInit(void);
    
48. void Uart_Proc(void);
    
49. /************************************************/
    
50. 
    
51. /*********************主函数*********************/
    
52. int main(void)
    
53. {
    
54.         LCD_Init();
    
55.         Temperature = DS18B20_ReadTmp();
    
56.         Delay_ms(200);
    
57.         Delay_ms(200);
    
58.         UartInit();
    
59.         Timer0Init();
    
60.         LCD_Show_Home();
    
61.         while(1)
    
62.         {
    
63.                 DispTemp();
    
64.                 KEY_Proc();
    
65.                 Uart_Proc();
    
66.         }
    
67. }
    
68. /************************************************/
    
69. 
    
70. /*****************延时函数******************/
    
71. void Delay_us(uchar x)                //@12.000MHz
    
72. {
    
73.         while(x--)
    
74.         {
    
75.                 _nop_();
    
76.                 _nop_();
    
77.                 _nop_();
    
78.                 _nop_();
    
79.         }
    
80. }
    
81. 
    
82. void Delay_ms(uchar x)                //@12.000MHz
    
83. {
    
84.         uchar i, j;
    
85.         while(x--)
    
86.         {
    
87.                 _nop_();
    
88.                 _nop_();
    
89.                 i = 12;
    
90.                 j = 169;
    
91.                 do
    
92.                 {
    
93.                         while (--j);
    
94.                 } while (--i);
    
95.         }
    
96. }
    
97. /************************************************/
    
98. 
    
99. /*******************计数器0模块*******************/
    
100. void Timer0Init(void)
     
101. {
     
102.         TMOD |= 0x01;        //选择为定时器0模式，工作方式1，仅用TR0打开启动。
     
103.         TH0 = 0xFC;                //给定时器赋初值，定时1ms
     
104.         TL0 = 0x18;        
     
105.         ET0 = 1;                        //打开定时器0中断允许
     
106.         EA = 1;                                //打开总中断
     
107.         TR0 = 1;                        //打开定时器
     
108. }
     
109. 
     
110. void Timer0(void) interrupt 1
     
111. {
     
112.         TH0 = 0xFC;                //给定时器赋初值，定时1ms
     
113.         TL0 = 0x18;
     
114.         KEY_1ms ++;
     
115.         Disp_1ms ++;
     
116.         Uart_1ms ++;
     
117. }
     
118. /************************************************/
     
119. 
     
120. /*****************按键模块******************/
     
121. void KEY_Proc(void)
     
122. {
     
123.         if (KEY_1ms >= KeyTime)
     
124.         {
     
125.                 KEY_1ms = 0;
     
126.                 if (KEY_1 == 0)
     
127.                 {
     
128.                         Menu ++;
     
129.                         LCD_Show_Setting();
     
130.                         if (Menu == 3)
     
131.                         {
     
132.                                 Menu = 0;
     
133.                                 LCD_Show_Home();
     
134.                         }
     
135.                 }
     
136.                 else if (KEY_2 == 0)
     
137.                 {
     
138.                         if (Menu == 1)
     
139.                         {
     
140.                                 MinTemp --;
     
141.                         }
     
142.                         else if (Menu == 2)
     
143.                         {
     
144.                                 MaxTemp --;
     
145.                                 if ((MaxTemp - 1) == MinTemp)
     
146.                                 {
     
147.                                         MaxTemp ++;
     
148.                                 }
     
149.                         }
     
150.                 }
     
151.                 else if (KEY_3 == 0)
     
152.                 {
     
153.                         if (Menu == 1)
     
154.                         {
     
155.                                 MinTemp ++;
     
156.                                 if ((MaxTemp - 1) == MinTemp)
     
157.                                 {
     
158.                                         MinTemp --;
     
159.                                 }
     
160.                         }
     
161.                         else if (Menu == 2)
     
162.                         {
     
163.                                 MaxTemp ++;
     
164.                         }
     
165.                 }
     
166.         }
     
167. }
     
168. /************************************************/
     
169. 
     
170. /*****************温度显示函数******************/
     
171. void DispTemp(void)
     
172. {
     
173.         if (Disp_1ms >= DispTime)
     
174.         {
     
175.                 uchar i;
     
176.                 uchar Disp[6] = "      ";
     
177.                 uchar Disp1[4] = "    ";
     
178.                 Disp_1ms = 0;
     
179.                 if (Menu == 0)
     
180.                 {
     
181.                         LCD_WriteCommand(0xC7);
     
182.                         Temperature = DS18B20_ReadTmp();
     
183.                         sprintf(Disp, "%.1f", Temperature);
     
184.                         for(i=0; i<6; i++)
     
185.                         {
     
186.                                 LCD_WriteData(Disp[i]);
     
187.                         }
     
188.                 }
     
189.                 else if (Menu == 1)
     
190.                 {
     
191.                         LCD_WriteCommand(0x80);
     
192.                         LCD_WriteData('>');
     
193.                         LCD_WriteCommand(0xC0);
     
194.                         LCD_WriteData(' ');
     
195.                         LCD_WriteCommand(0x8B);
     
196.                         sprintf(Disp, "%d", MinTemp);
     
197.                         for(i=0; i<4; i++)
     
198.                         {
     
199.                                 LCD_WriteData(Disp[i]);
     
200.                         }
     
201.                 }
     
202.                 else if (Menu == 2)
     
203.                 {
     
204.                         LCD_WriteCommand(0x80);
     
205.                         LCD_WriteData(' ');
     
206.                         LCD_WriteCommand(0xC0);
     
207.                         LCD_WriteData('>');
     
208.                         LCD_WriteCommand(0xCB);
     
209.                         sprintf(Disp, "%d", MaxTemp);
     
210.                         for(i=0; i<4; i++)
     
211.                         {
     
212.                                 LCD_WriteData(Disp[i]);
     
213.                         }
     
214.                 }
     
215.         }
     
216. }
     
217. /************************************************/
     
218. 
     
219. /*******************LCD模块*******************/
     
220. void LCD_WriteCommand(uchar com)
     
221. {
     
222.         LCD_EN = 0;     //使能
     
223.         LCD_RS = 0;                  //选择发送命令
     
224.         LCD_RW = 0;                   //选择写入
     
225.         
     
226.         LCD_DATA = com; //放入命令
     
227.         Delay_us(1);                //等待数据稳定
     
228. 
     
229.         LCD_EN = 1;            //写入时序
     
230.         Delay_us(5);          //保持时间
     
231.         LCD_EN = 0;
     
232. }
     
233.            
     
234.            
     
235. void LCD_WriteData(uchar dat)
     
236. {
     
237.         LCD_EN = 0;                        //使能清零
     
238.         LCD_RS = 1;                        //选择输入数据
     
239.         LCD_RW = 0;                        //选择写入
     
240. 
     
241.         LCD_DATA = dat; //写入数据
     
242.         Delay_us(1);
     
243. 
     
244.         LCD_EN = 1;           //写入时序
     
245.         Delay_us(5);          //保持时间
     
246.         LCD_EN = 0;
     
247. }
     
248. 
     
249. void LCD_Init(void)
     
250. {
     
251.          LCD_WriteCommand(0x38);  //开显示
     
252.         LCD_WriteCommand(0x0C);  //开显示不显示光标
     
253.         LCD_WriteCommand(0x06);  //写一个指针加1
     
254.         LCD_WriteCommand(0x01);  //清屏
     
255.         LCD_WriteCommand(0x80);  //设置数据指针起点
     
256. }
     
257. 
     
258. void LCD_Show_Home(void)
     
259. {
     
260.         uchar i;
     
261.         uchar Disp[16];
     
262.         LCD_WriteCommand(0x80);
     
263.         sprintf(Disp, " Current Temp:  ");
     
264.         for(i=0; i<16; i++)
     
265.         {
     
266.                 LCD_WriteData(Disp[i]);
     
267.         }
     
268.         LCD_WriteCommand(0xC0);
     
269.         sprintf(Disp, " Temp:        C ");
     
270.         for(i=0; i<16; i++)
     
271.         {
     
272.                 LCD_WriteData(Disp[i]);
     
273.         }
     
274.         LCD_WriteCommand(0xCD);
     
275.         LCD_WriteData(0xDF);
     
276. }
     
277. 
     
278. void LCD_Show_Setting(void)
     
279. {
     
280.         uchar i;
     
281.         uchar Disp[16];
     
282.         LCD_WriteCommand(0x80);
     
283.         sprintf(Disp, " Min Temp: %d   ", MinTemp);
     
284.         for(i=0; i<16; i++)
     
285.         {
     
286.                 LCD_WriteData(Disp[i]);
     
287.         }
     
288.         LCD_WriteCommand(0xC0);
     
289.         sprintf(Disp, " Max Temp: %d   ", MaxTemp);
     
290.         for(i=0; i<16; i++)
     
291.         {
     
292.                 LCD_WriteData(Disp[i]);
     
293.         }
     
294. }
     
295. /************************************************/
     
296. 
     
297. /*******************DS18B20模块*******************/
     
298. void DS18B20_Init(void)
     
299. {
     
300.         DS18B20 = 1;
     
301.         Delay_us(1);
     
302.         DS18B20 = 0;
     
303.         Delay_us(40);
     
304.         DS18B20 = 1;
     
305.         Delay_us(11);
     
306. }
     
307. 
     
308. uchar DS18B20_ReadByte(void)
     
309. {
     
310.          uchar i,dat=0;
     
311.         DS18B20 = 1;
     
312.         for(i=0;i<8;i++)
     
313.         {
     
314.                 DS18B20 = 1;
     
315.                 Delay_us(1);
     
316.                  DS18B20 = 0;
     
317.                 dat >>= 1;
     
318.                 DS18B20 = 1;
     
319.                 if(DS18B20)
     
320.                         dat |= 0X80;
     
321.                 Delay_us(2);
     
322.         }
     
323.         return dat;
     
324. }
     
325. 
     
326. void DS18B20_WriteByte(uchar dat)
     
327. {
     
328.          uchar i;
     
329.         for(i=0;i<8;i++)
     
330.         {
     
331.                  DS18B20 = 0;
     
332.                 DS18B20 = dat& 0x01;
     
333.                 Delay_us(2);
     
334.                 DS18B20 = 1;
     
335.                 dat >>= 1;
     
336.         }
     
337.         Delay_us(2);
     
338. }
     
339. 
     
340. float DS18B20_ReadTmp(void)
     
341. {
     
342.         float Temp;
     
343.         uint Temp_Value[]={0, 0};
     
344.         DS18B20_Init();
     
345.         DS18B20_WriteByte(0xCC);
     
346.         DS18B20_WriteByte(0x44);
     
347.         Delay_us(20);
     
348.         DS18B20_Init();
     
349.         DS18B20_WriteByte(0xCC);
     
350.         DS18B20_WriteByte(0xBE);
     
351.         Temp_Value[0] = DS18B20_ReadByte();
     
352.         Temp_Value[1] = DS18B20_ReadByte();
     
353.         if((Temp_Value[1]&0xF8)==0xF8)
     
354.         {
     
355.                 Temp = -1 * (128 - 0.0625 * (Temp_Value[0] | ((Temp_Value[1]&0x07)<<8)));
     
356.         }
     
357.         else
     
358.         {
     
359.                 Temp = 0.0625 * (Temp_Value[0] | ((Temp_Value[1]&0x07)<<8));
     
360.         }
     
361.         return Temp;
     
362. }
     
363. /************************************************/
     
364. 
     
365. /*******************串口通信模块*******************/
     
366. void UartInit(void)
     
367. {
     
368.         SCON = 0x50;                //设置为工作方式1
     
369.         TMOD |= 0x20;                //设置计数器工作方式2
     
370.         PCON = 0x80;                //波特率加倍
     
371.         TH1=0xF3;                                //计数器初始值设置，注意波特率是4800的
     
372.         TL1=0xF3;
     
373. //        ES=1;                                                //打开接收中断
     
374. //        EA=1;                                                //打开总中断
     
375.         TR1=1;                                        //打开计数器
     
376. }
     
377. 
     
378. void Uart_Proc(void)
     
379. {
     
380. //        if (Uart_1ms >= UartTime)
     
381. //        {
     
382. //                Uart_1ms = 0;
     
383.                 if (Temperature < MinTemp)
     
384.                 {
     
385.                         SBUF = 'A';
     
386.                         while(!TI);
     
387.                         TI = 0;
     
388.                 }
     
389.                 else if (Temperature > MaxTemp)
     
390.                 {
     
391.                         SBUF = 'B';
     
392.                         while(!TI);
     
393.                         TI = 0;
     
394.                 }
     
395.                 else
     
396.                 {
     
397.                         SBUF = 'O';
     
398.                         while(!TI);
     
399.                         TI = 0;
     
400.                 }
     
401. //        }
     
402. }
     

复制代码

Proteus仿真工程下载: TemperatureMonitor-master.rar (223.29 KB, 下载次数: 31)

2021-12-21 20:54 上传

点击文件名下载附件
下载积分: 黑币 -5