標(biāo)題: 單片機(jī)土壤濕度檢測(cè)程序 [打印本頁]
作者: mymcu123    時(shí)間: 2021-1-1 23:46
標(biāo)題: 單片機(jī)土壤濕度檢測(cè)程序
  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;

  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)//定時(shí)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. }

  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()        //結(jié)束
  68. {
  69.         sda=0;
  70.         delay();
  71.         scl=1;
  72.         delay();
  73.         sda=1;
  74.         delay();
  75. }
  76. void respons()//應(yīng)答
  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.         }

  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. }

  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]);

  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;


  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. }
復(fù)制代碼

原理圖.rar

174.7 KB, 下載次數(shù): 18, 下載積分: 黑幣 -5

程序.zip

47.63 KB, 下載次數(shù): 13, 下載積分: 黑幣 -5





歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1