标题: 单片机土壤湿度检测程序 [打印本页]

---

作者: mymcu123    时间: 2021-1-1 23:46
标题: 单片机土壤湿度检测程序

1. #include<reg52.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. #define  ad1_7  P1
   
5. uchar hour,min,sec,shangxian,xiaxian,sett,count,cent0=0,cent1=0;
   
6. uint mv;
   
7. 
   
8. uchar code table1[]={"  H:  :    H:  %"};
   
9. uchar code table2[]={"MV:  %     L:  %"};
   
10. sbit lcden=P2^5;
    
11. sbit lcdrw=P2^6;
    
12. sbit lcdrs=P2^7;
    
13. sbit key1=P2^0;
    
14. sbit scl=P2^1;
    
15. sbit key3=P2^2;
    
16. sbit key4=P2^3;
    
17. sbit inc=P2^2;
    
18. sbit dec=P2^3;
    
19. sbit led1=P2^4;
    
20. sbit sda=P3^2;
    
21. sbit buzzer=P3^3;
    
22. sbit led=P3^4;
    
23. sbit ADCS=P3^5;
    
24. sbit ADRD=P3^6;
    
25. sbit ADWR=P3^7;
    
26. bit flag,flag0=0;
    
27. void delay()
    
28. {;;}
    
29. void delay1(uint xs)//定时1ms
    
30. {
    
31.         uint i,j;
    
32.         for(j=xs;j>0;j--)
    
33.                 for(i=110;i>0;i--);
    
34. }
    
35. void start_adc0804(void)
    
36. {      
    
37.                  ADCS=0;                        
    
38.                  ADWR=0;
    
39.                 delay1(1);
    
40.                  ADWR=1;
    
41.                 ADCS=1;        
    
42.                 delay1(1);
    
43. }
    
44. 
    
45. read_ad()
    
46. {      
    
47.          uchar ad_data;         
    
48.          ad1_7=0xff;         
    
49.          ADCS=0;                  
    
50.          ADRD=0;                    
    
51.          delay1(1);         
    
52.          ad_data=ad1_7;         
    
53.          ADRD=1;
    
54.          ADCS=1;           
    
55.          
    
56.          return(ad_data);
    
57. }
    
58. void start()//开始
    
59. {
    
60.         sda=1;
    
61.         delay();
    
62.         scl=1;
    
63.         delay();
    
64.         sda=0;
    
65.         delay();
    
66. }
    
67. void stop()        //结束
    
68. {
    
69.         sda=0;
    
70.         delay();
    
71.         scl=1;
    
72.         delay();
    
73.         sda=1;
    
74.         delay();
    
75. }
    
76. void respons()//应答
    
77. {
    
78.         uchar i;
    
79.         scl=1;
    
80.         delay();
    
81.         while((sda==1)&&(i<250))
    
82.         i++;
    
83.         scl=0;
    
84.         delay();
    
85. }
    
86. void init()
    
87. {
    
88.         scl=1;
    
89.         sda=1;
    
90. }
    
91. void write_byte(uchar date)
    
92. {
    
93.         uchar i,temp;
    
94.         temp=date;
    
95.         scl=0;
    
96.         delay();
    
97.         for(i=0;i<8;i++)
    
98.         {
    
99.                 temp=temp<<1;
    
100.                 sda=CY;
     
101.                 delay();
     
102.                 scl=1;
     
103.                 delay();
     
104.                 scl=0;
     
105.                 delay();
     
106.         }
     
107.         sda=1;
     
108.         delay();
     
109. }
     
110. uchar read_byte()
     
111. {
     
112.         uchar i,j,k;
     
113.         scl=0;
     
114.         delay();
     
115.         sda=1;
     
116.         delay();
     
117.         for(i=0;i<8;i++)
     
118.         {
     
119.                 scl=1;
     
120.                 delay();
     
121.                 if(sda)
     
122.                         j=1;
     
123.                 else
     
124.                         j=0;
     
125.                 k=((k<<1)|j);
     
126.                 delay();
     
127.                 scl=0;
     
128.                 delay();
     
129.         }        
     
130.         return k;
     
131. }
     
132. void write_add(uchar add,uchar date)
     
133. {
     
134.         start();
     
135.         write_byte(0xa0);
     
136.         respons();
     
137.         write_byte(add);
     
138.         respons();
     
139.         write_byte(date);
     
140.         respons();
     
141.         stop();
     
142. }
     
143. uchar read_add(uchar add)
     
144. {
     
145.         uchar date;
     
146.         start();
     
147.         write_byte(0xa0);
     
148.         respons();
     
149.         write_byte(add);
     
150.         respons();
     
151.         start();
     
152.         write_byte(0xa1);
     
153.         respons();
     
154.         date=read_byte();
     
155.         stop();
     
156.         return date;        
     
157. }
     
158. void write_comm(uchar comm)
     
159. {
     
160.         lcdrs=0;
     
161.         P0=comm;
     
162.         delay1(5);//5ms
     
163.         lcden=1;
     
164.         delay1(5);//5ms
     
165.         lcden=0;
     
166. }
     
167. void write_data(uchar dat)
     
168. {
     
169.         lcdrs=1;
     
170.         P0=dat;
     
171.         delay1(5);//5ms
     
172.         lcden=1;
     
173.         delay1(5);//5ms
     
174.         lcden=0;
     
175. }                        
     
176. void init1()
     
177. {
     
178.         lcdrw=0;
     
179.         lcden=0;
     
180.         write_comm(0x38);
     
181.            write_comm(0x0c);
     
182.         write_comm(0x06);
     
183.         write_comm(0x01);
     
184.         write_comm(0x80);
     
185. }
     
186. void set_scan()
     
187. {
     
188.         if(sett)
     
189.         {
     
190.                 led1=0;
     
191.                 TR0=0;
     
192.         }
     
193.         else
     
194.         {
     
195.                 led1=1;
     
196.                 TR0=1;
     
197.         }
     
198.         if(!key1)
     
199.         {
     
200.                 delay1(5);
     
201.                 if(!key1)
     
202.                 {
     
203.                         sett++;
     
204.                         if(sett>5)
     
205.                         sett=0;        
     
206.                 }
     
207.                 while(!key1);
     
208.                 delay1(5);
     
209.                 while(!key1);
     
210.          }
     
211.         if(sett==1)
     
212.         {
     
213.                 if(!key3)
     
214.                 {
     
215.                         delay1(5);
     
216.                         if(!key3)
     
217.                         {
     
218.                                 hour++;
     
219.                                 if(hour>99)
     
220.                                 hour=0;
     
221.                         }
     
222.                         while(!key3);
     
223.                         delay1(5);
     
224.                         while(!key3);
     
225.                 }
     
226.                 if(!key4)
     
227.                 {
     
228.                         delay1(5);
     
229.                         if(!key4)
     
230.                         {
     
231.                                 if(hour==0)
     
232.                                 hour=99;
     
233.                                 else
     
234.                                 hour--;
     
235.                         }
     
236.                         while(!key4);
     
237.                         delay1(5);
     
238.                         while(!key4);
     
239.                 }
     
240.                 write_add(20,hour);
     
241.                 write_comm(0x80);         
     
242.                 write_data(0x30+hour/10);
     
243.                 write_data(0x30+hour%10);
     
244.                    write_comm(0x80+1);         
     
245.                 write_comm(0x0f);        
     
246.         }
     
247. 
     
248.            if(sett==2)
     
249.         {
     
250.                 if(!key3)
     
251.                 {
     
252.                         delay1(5);
     
253.                         if(!key3)
     
254.                         {
     
255.                                 min++;
     
256.                                 if(min==60)
     
257.                                 min=0;
     
258.                         }
     
259.                         while(!key3);
     
260.                         delay1(5);
     
261.                         while(!key3);
     
262.                 }
     
263.                 if(!key4)
     
264.                 {
     
265.                         delay1(5);
     
266.                         if(!key4)
     
267.                         {
     
268.                                 if(min==0)
     
269.                                 min=59;
     
270.                                 else
     
271.                                 min--;
     
272.                         }
     
273.                         while(!key4);
     
274.                         delay1(5);
     
275.                         while(!key4);
     
276.                 }
     
277.                 write_add(21,min);
     
278.                 write_comm(0x80+4);
     
279.                 write_data(0x30+(min/10));
     
280.                 write_data(0x30+(min%10));
     
281.                 write_comm(0x80+5);         
     
282.                 write_comm(0x0f);
     
283.         }
     
284.         if(sett==3)
     
285.         {
     
286.                 if(!key3)
     
287.                 {
     
288.                         delay1(5);
     
289.                         if(!key3)
     
290.                         {
     
291.                                 sec++;
     
292.                                 if(sec==60)
     
293.                                 sec=0;
     
294.                         }
     
295.                         while(!key3);
     
296.                         delay1(5);
     
297.                         while(!key3);
     
298.                 }
     
299.                 if(!key4)
     
300.                 {
     
301.                         delay1(5);
     
302.                         if(!key4)
     
303.                         {
     
304.                                 if(sec==0)
     
305.                                 sec=59;
     
306.                                 else
     
307.                                 sec--;
     
308.                         }
     
309.                         while(!key4);
     
310.                         delay1(5);
     
311.                         while(!key4);
     
312.                 }
     
313.                 write_add(22,sec);
     
314.                 write_comm(0x80+7);
     
315.                 write_data(0x30+(sec/10));
     
316.                 write_data(0x30+(sec%10));        
     
317.                 write_comm(0x80+8);         
     
318.                 write_comm(0x0f);
     
319.         }
     
320.         if(sett==4)
     
321.         {
     
322.                 if(!key3)
     
323.                 {
     
324.                         delay1(5);
     
325.                         if(!key3)
     
326.                         {
     
327.                                 shangxian++;
     
328.                                 if(shangxian==100)
     
329.                                 shangxian=0;
     
330.                         }
     
331.                         while(!key3);
     
332.                         delay1(5);
     
333.                         while(!key3);
     
334.                 }
     
335.                 if(!key4)
     
336.                 {
     
337.                         delay1(5);
     
338.                         if(!key4)
     
339.                         {        
     
340.                                 if(shangxian==0)
     
341.                                 shangxian=99;
     
342.                                 else
     
343.                                 shangxian--;        
     
344.                         }
     
345.                         while(!key4);
     
346.                         delay1(5);
     
347.                         while(!key4);
     
348.                 }
     
349.                 write_add(23,shangxian);
     
350.                 write_comm(0x80+13);
     
351.                 write_data(0x30+(shangxian/10));
     
352.                 write_data(0x30+(shangxian%10));        
     
353.                 write_comm(0x80+14);         
     
354.                 write_comm(0x0f);
     
355.         }
     
356.         if(sett==5)
     
357.         {
     
358.                 if(!key3)
     
359.                 {
     
360.                         delay1(5);
     
361.                         if(!key3)
     
362.                         {
     
363.                                 xiaxian++;
     
364.                                 if(xiaxian==100)
     
365.                                 xiaxian=0;
     
366.                         }
     
367.                         while(!key3);
     
368.                         delay1(5);
     
369.                         while(!key3);
     
370.                 }
     
371.                 if(!key4)
     
372.                 {
     
373.                         delay1(5);
     
374.                         if(!key4)
     
375.                         {        
     
376.                                 if(xiaxian==0)
     
377.                                 xiaxian=99;
     
378.                                 else
     
379.                                 xiaxian--;                                
     
380.                         }
     
381.                         while(!key4);
     
382.                         delay1(5);
     
383.                         while(!key4);
     
384.                 }
     
385.                 write_add(24,xiaxian);
     
386.                 write_comm(0x80+0x40+13);
     
387.                 write_data(0x30+(xiaxian/10));
     
388.                 write_data(0x30+(xiaxian%10));        
     
389.                 write_comm(0x80+0x40+14);         
     
390.                 write_comm(0x0f);
     
391.         }
     
392. }
     
393. 
     
394. void init2()
     
395. {
     
396.         uchar i;
     
397.          for(i=0;i<16;i++)
     
398.         write_data(table1[i]);
     
399.         write_comm(0x80+0x40);
     
400.         for(i=0;i<16;i++)
     
401.         write_data(table2[i]);
     
402. 
     
403.         hour=read_add(20);
     
404.         write_comm(0x80);
     
405.         write_data(0x30+(hour/10));
     
406.         write_data(0x30+(hour%10));
     
407.         min=read_add(21);
     
408.         write_comm(0x80+4);
     
409.         write_data(0x30+(min/10));
     
410.         write_data(0x30+(min%10));
     
411.         sec=read_add(22);
     
412.         write_comm(0x80+7);
     
413.         write_data(0x30+(sec/10));
     
414.         write_data(0x30+(sec%10));
     
415.         shangxian=read_add(23);
     
416.         write_comm(0x80+13);
     
417.         write_data(0x30+(shangxian/10));
     
418.         write_data(0x30+(shangxian%10));
     
419.            xiaxian=read_add(24);
     
420.         write_comm(0x80+0x40+13);
     
421.         write_data(0x30+(xiaxian/10));
     
422.         write_data(0x30+(xiaxian%10));
     
423.         mv=read_add(25);
     
424.           write_comm(0x80+0x40+7);
     
425.         write_data(0x30+(mv/10));
     
426.         write_data(0x30+(mv%10));        
     
427.         write_data(table1[15]);        
     
428. }
     
429. void daojishi()
     
430. {
     
431.         write_comm(0x80);
     
432.         write_data(0x30+(hour/10));
     
433.         write_data(0x30+(hour%10));
     
434.         write_comm(0x80+4);
     
435.         write_data(0x30+(min/10));
     
436.         write_data(0x30+(min%10));
     
437.         write_comm(0x80+7);
     
438.         write_data(0x30+(sec/10));
     
439.         write_data(0x30+(sec%10));        
     
440. }
     
441. void main()
     
442. {
     
443.         uint temp;
     
444.         //buzzer=0;
     
445.         init();
     
446.          init1();
     
447.         init2();
     
448.         TMOD=0x01;
     
449.         TH0=(65536-50000)/256;        
     
450.         TL0=(65536-50000)/256;
     
451.         EA=1;
     
452.         ET0=1;
     
453.         TR0=1;
     
454.         /*for(i=0;i<16;i++)
     
455.         {
     
456.                 write_comm(0x18);
     
457.                 delay(200);
     
458.         }*/
     
459.         sett=0;
     
460.         while(1)
     
461.         {        
     
462.                    if(!sett)
     
463.                 {
     
464.                         
     
465.                         if(flag)
     
466.                         while(1);
     
467.                            daojishi();
     
468.                         set_scan();
     
469.                         start_adc0804();
     
470.                         temp= read_ad();
     
471.                         mv=temp*(1.0/255)*100;
     
472.                         if(mv>=100)
     
473.                         mv=0;
     
474.                         else
     
475.                         mv=100-mv;
     
476. 
     
477. 
     
478.                         if((mv>=shangxian)||(mv<=xiaxian))
     
479.                         {
     
480.                                 flag0=1;
     
481.                                 led=0;
     
482.                         }
     
483.                         else
     
484.                         {
     
485.                                  flag0=0;
     
486.                                 led=1;
     
487.                         }
     
488.                         if(cent0>=12)
     
489.                         {
     
490.                                 cent0=0;
     
491.                                 write_add(25,mv);
     
492.                                 write_comm(0x80+0x40+3);
     
493.                                 write_data(0x30+(mv/10));
     
494.                                 write_data(0x30+(mv%10));        
     
495.                                 write_comm(0x0c);
     
496.                         }        
     
497.                 }
     
498.                 else if(sett)
     
499.                 {
     
500.                         set_scan();
     
501.                         cent1=0;
     
502.                          buzzer=1;
     
503.                 }
     
504.         }
     
505. }
     
506. void timer0() interrupt 1
     
507. {
     
508.         TH0=(65536-50000)/256;        
     
509.         TL0=(65536-50000)/256;
     
510.         count++;
     
511.         cent0++;
     
512.         
     
513.         if(count==20&&!sett)
     
514.         {
     
515.                 count=0;
     
516.                 if(sec==0)
     
517.                 {
     
518.                         if(min==0)
     
519.                         {
     
520.                                 if(hour==0)
     
521.                                 {
     
522.                                         flag=1;
     
523.                                         TR0=0;
     
524.                                 }
     
525.                                 else
     
526.                                 {
     
527.                                         hour--;
     
528.                                         min=59;
     
529.                                 }
     
530.                         }
     
531.                         else
     
532.                         {
     
533.                                 min--;
     
534.                                 sec=59;
     
535.                         }
     
536.                 }
     
537.                 else
     
538.                 sec--;
     
539.         }
     
540.         if(flag0==1)
     
541.         {
     
542.                 cent1++;
     
543.                 if(cent1<6)
     
544.                 buzzer=1;
     
545.                 else if(cent1<12)
     
546.                 buzzer=0;
     
547.             else
     
548.                 cent1=0;
     
549.         }
     
550.          else
     
551.          {
     
552.                  cent1=0;
     
553.                  buzzer=1;
     
554.          }
     
555.         
     
556.                
     
557. }

复制代码

原理图.rar

2021-1-1 23:46 上传

点击文件名下载附件

下载积分: 黑币 -5

174.7 KB, 下载次数: 18, 下载积分: 黑币 -5

程序.zip

2021-1-1 23:46 上传

点击文件名下载附件

下载积分: 黑币 -5

47.63 KB, 下载次数: 13, 下载积分: 黑币 -5

---

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

Powered by Discuz! X3.1