设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机的蔬菜大棚温湿度智能控制系统程序设计
返回列表 发新帖
查看: 7550|回复: 9
收起左侧

基于51单片机的蔬菜大棚温湿度智能控制系统程序设计

  [复制链接]
ID:395590 发表于 2019-11-25 19:02 | 显示全部楼层 |阅读模式
基于51单片机的蔬菜大棚温湿度智能控制系统设计模块使用：使用dht11、74hc595数码管模块、继电器模块
任务
1）根据检测到的温湿度信息控制通风与加热；
2）采用MCU、温湿度传感器、继电器、按键、数码管等；
3）通过按键设定大棚温湿度报警值；
4）上传信息到PC机；
5）当温度或适度超限时用继电器控制小灯状态模拟相应动作的发生。

230204B72FC083DD0A1F32DEA2FF975A.jpg 51.png

单片机源程序如下:
  1. ////////////////////////////////////////////////////10.3            17:58////////////////////////////////////////////////////////
  2. #include <reg52.h> //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义
  3. #include <intrins.h>
  4. #include <math.h>
  5. #define uchar unsigned char
  6. #define uint unsigned int       
  7. sbit RS = P1^0;   //定义端口
  8. sbit RW = P1^1;
  9. sbit EN = P2^5;
  10. sbit DU = P2^0;
  11. sbit WE = P2^1;
  12. sbit Data = P3^6;//定义数据线


  15. uchar rec_dat[19];   //用于显示的接收数据数组

  17. #define RS_CLR RS=0
  18. #define RS_SET RS=1

  20. #define RW_CLR RW=0
  21. #define RW_SET RW=1

  23. #define EN_CLR EN=0
  24. #define EN_SET EN=1

  26. #define DataPort P0


  29. void cmg88()//关数码管，点阵函数
  30. {
  31. DU=1;  
  32. P0=0X00;
  33. DU=0;
  34. }
  35. /*------------------------------------------------
  36. uS延时函数，含有输入参数 unsigned char t，无返回值
  37. unsigned char 是定义无符号字符变量，其值的范围是
  38. 0~255 这里使用晶振12M，精确延时请使用汇编,大致延时
  39. 长度如下 T=tx2+5 uS
  40. ------------------------------------------------*/
  41. void DelayUs2x(unsigned char t)
  42. {   
  43. while(--t);
  44. }
  45. /*------------------------------------------------
  46. mS延时函数，含有输入参数 unsigned char t，无返回值
  47. unsigned char 是定义无符号字符变量，其值的范围是
  48. 0~255 这里使用晶振12M，精确延时请使用汇编
  49. ------------------------------------------------*/
  50. void DelayMs(unsigned char t)
  51. {
  52.      
  53. while(t--)
  54. {
  55.      //大致延时1mS
  56.      DelayUs2x(245);
  57.          DelayUs2x(245);
  58. }
  59. }

  61. //              判忙函数
  62. bit LCD_Check_Busy(void)
  63. {
  64. DataPort= 0xFF;
  65. RS_CLR;
  66. RW_SET;
  67. EN_CLR;
  68. _nop_();
  69. EN_SET;
  70. return (bit)(DataPort & 0x80);
  71. }
  72. //             写入命令函数
  73. void LCD_Write_Com(unsigned char com)
  74. {  
  75. while(LCD_Check_Busy()); //忙则等待
  76. RS_CLR;
  77. RW_CLR;
  78. EN_SET;
  79. DataPort= com;
  80. _nop_();
  81. EN_CLR;
  82. }
  83. //             写入数据函数
  84. void LCD_Write_Data(unsigned char Data)
  85. {
  86. while(LCD_Check_Busy()); //忙则等待
  87. RS_SET;
  88. RW_CLR;
  89. EN_SET;
  90. DataPort= Data;
  91. _nop_();
  92. EN_CLR;
  93. }

  95. //               清屏函数
  96. void LCD_Clear(void)
  97. {
  98. LCD_Write_Com(0x01);
  99. DelayMs(5);
  100. }
  101. //             写入字符串函数
  102. void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s)
  103. {     
  104. if (y == 0)
  105.         {     
  106.          LCD_Write_Com(0x80 + x);     //表示第一行
  107.         }
  108. else
  109.         {      
  110.         LCD_Write_Com(0xC0 + x);      //表示第二行
  111.         }        
  112. while (*s)
  113.         {     
  114. LCD_Write_Data( *s);     
  115. s ++;     
  116.         }
  117. }
  118.    //           写入字符函数
  119. void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data)
  120. {     
  121. if (y == 0)
  122.         {     
  123.         LCD_Write_Com(0x80 + x);     
  124.         }   
  125. else
  126.         {     
  127.         LCD_Write_Com(0xC0 + x);     
  128.         }        
  129. LCD_Write_Data( Data);  
  130. }
  131. //             初始化函数
  132. void LCD_Init(void)
  133. {
  134.    LCD_Write_Com(0x38);    /*显示模式设置*/
  135.    DelayMs(5);
  136.    LCD_Write_Com(0x38);
  137.    DelayMs(5);
  138.    LCD_Write_Com(0x38);
  139.    DelayMs(5);
  140.    LCD_Write_Com(0x38);  
  141.    LCD_Write_Com(0x08);    /*显示关闭*/
  142.    LCD_Write_Com(0x01);    /*显示清屏*/
  143.    LCD_Write_Com(0x06);    /*显示光标移动设置*/
  144.    DelayMs(5);
  145.    LCD_Write_Com(0x0C);    /*显示开及光标设置*/
  146.    }
  147.    

  149. /*------------------------------------------------
  150.               DHT11延时函数
  151. ------------------------------------------------*/
  152. void DHT11_delay_us(uchar n)
  153. {
  154.     while(--n);
  155. }

  157. void DHT11_delay_ms(uint z)
  158. {
  159.    uint i,j;
  160.    for(i=z;i>0;i--)
  161.       for(j=110;j>0;j--);
  162. }
  163. /*------------------------------------------------
  164.               DHT11开始信号
  165. ------------------------------------------------*/
  166. void DHT11_start()
  167. {
  168.    Data=1;
  169.    DHT11_delay_us(2);
  170.    Data=0;
  171.    DHT11_delay_ms(20);   //延时18ms以上
  172.    Data=1;
  173.    DHT11_delay_us(30);
  174. }
  175. //             接收八位二进制
  176. uchar DHT11_rec_byte()      //接收一个字节
  177. {
  178.    uchar i,dat=0;
  179.   for(i=0;i<8;i++)    //从高到低依次接收8位数据
  180.    {         
  181.       while(!Data);   ////等待50us低电平过去
  182.       DHT11_delay_us(8);     //延时60us，如果还为高则数据为1，否则为0
  183.       dat<<=1;           //移位使正确接收8位数据，数据为0时直接移位
  184.       if(Data==1)    //数据为1时，使dat加1来接收数据1
  185.          dat+=1;
  186.       while(Data);  //等待数据线拉低   
  187.     }  
  188.     return dat;
  189. }
  190. //              接收40bit数据

  192. void DHT11_receive()      //接收40位的数据
  193. {
  194.     uchar R_H,R_L,T_H,T_L,RH,RL,TH,TL,revise;
  195.     DHT11_start();

  197.     if(Data==0)
  198.     {
  199.        
  200.         while(Data==0);   //等待拉高     
  201.                
  202.         DHT11_delay_us(40);  //拉高后延时80us
  203.         R_H=DHT11_rec_byte();    //接收湿度高八位  
  204.         R_L=DHT11_rec_byte();    //接收湿度低八位  
  205.         T_H=DHT11_rec_byte();    //接收温度高八位  
  206.         T_L=DHT11_rec_byte();    //接收温度低八位
  207.         revise=DHT11_rec_byte(); //接收校正位
  208.                          
  209.         DHT11_delay_us(25);    //结束

  211.         if((R_H+R_L+T_H+T_L)==revise)      //校正
  212.         {
  213.             RH=R_H;
  214.             RL=R_L;
  215.             TH=T_H;
  216.             TL=T_L;
  217.         }
  218.         /*数据处理，方便显示*/
  219.         rec_dat[0]='0'+(RH/10);
  220.         rec_dat[1]='0'+(RH%10);
  221.                 rec_dat[2] =' ';
  222.                 rec_dat[3] = 'R' ;
  223.                 rec_dat[4] = 'H';
  224.         rec_dat[5]=' ';
  225.         rec_dat[6]=' ';
  226.         rec_dat[7]=' ';
  227.         rec_dat[8]=' ';
  228.         rec_dat[9]='0'+(TH/10);
  229.         rec_dat[10]='0'+(TH%10);
  230.                 rec_dat[11] =' ';
  231.                 rec_dat[12] = 'C';
  232.                 rec_dat[13] = ' ' ;
  233.         rec_dat[14]=' ';
  234.                 rec_dat[15] =(RH/10);
  235.                 rec_dat[16] =(RH%10);
  236.                 rec_dat[17] =(TH/10) ;
  237.         rec_dat[18]=(TH%10);
  238.     }
  239. }
  240. /////////////////数码管///////////////////////////////////////////////

  242.   
  243. unsigned char code fseg[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
  244. unsigned char code segbit[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
  245. unsigned char  disbuf[8]={0,0,0,0,0,0,0,0};
  246. unsigned char code LED_0F[];                // LED字模表

  248. sbit DIO = P1^0;                                //串行数据输入
  249. sbit rclck  = P1^1;                                //时钟脉冲信号——上升沿有效
  250. sbit SCLK = P1^2;                                //打入信号————上升沿有效

  252. //-----------------------------------------------------------------------------
  253. // 全局变量
  254. uchar LED[8];        //用于LED的8位显示缓存
  255.   


  258. unsigned char code LED_0F[] =
  259. {// 0         1          2           3        4         5          6           7        8         9          A           b        C    d          E    F    -
  260.         0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf
  261. };

  263. void LED_OUT(uchar X)
  264. {
  265.         uchar i;
  266.         for(i=8;i>=1;i--)
  267.         {
  268.                 if (X&0x80) DIO=1; else DIO=0;
  269.                 X<<=1;
  270.                 SCLK = 0;
  271.                 SCLK = 1;
  272.         }
  273. }  

  275. void LED8_Display (void)
  276. {
  277.         unsigned char code *led_table;          // 查表指针
  278.         uchar i;
  279.         //显示第1位
  280.         led_table = LED_0F + LED[0];
  281.         i = *led_table;

  283.         LED_OUT(i);                       
  284.         LED_OUT(0x01);               

  286.         rclck = 0;
  287.         rclck = 1;
  288.         //显示第2位
  289.         led_table = LED_0F + LED[1];
  290.         i = *led_table;

  292.         LED_OUT(i);               
  293.         LED_OUT(0x02);               

  295.         rclck = 0;
  296.         rclck = 1;
  297.         //显示第3位
  298.         led_table = LED_0F + LED[2];
  299.         i = *led_table;

  301.         LED_OUT(i);                       
  302.         LED_OUT(0x04);       

  304.         rclck = 0;
  305.         rclck = 1;
  306.         //显示第4位
  307.         led_table = LED_0F + LED[3];
  308.         i = *led_table;

  310.         LED_OUT(i);                       
  311.         LED_OUT(0x08);               

  313.         rclck = 0;
  314.         rclck = 1;
  315.                 led_table = LED_0F + LED[4];
  316.         i = *led_table;
  317.         LED_OUT(i);                       
  318.         LED_OUT(0x10);       
  319.         rclck = 0;
  320.         rclck = 1;         
  321.                  
  322.                 //显示第6位
  323.         led_table = LED_0F + LED[5];
  324.         i = *led_table;

  326.         LED_OUT(i);                       
  327.         LED_OUT(0x20);       

  329.         rclck = 0;
  330.         rclck = 1;
  331.                  //显示第7位
  332.         led_table = LED_0F + LED[6];
  333.         i = *led_table;

  335.         LED_OUT(i);                       
  336.         LED_OUT(0x40);       

  338.         rclck = 0;
  339.         rclck = 1;         
  340.                          //显示第8位
  341.         led_table = LED_0F + LED[7];
  342.         i = *led_table;

  344.         LED_OUT(i);               
  345.         LED_OUT(0x80);       

  347.         rclck = 0;
  348.         rclck = 1;
  349.         }


  352. void LED2_Display (uchar *wei)
  353. {
  354.         unsigned char code *led_table;          // 查表指针
  355.         uchar i;
  356. if(wei==1)
  357. {
  358.         //显示第1位
  359.         led_table = LED_0F + LED[0];
  360.         i = *led_table;

  362.         LED_OUT(i);                       
  363.         LED_OUT(0x01);               

  365.         rclck = 0;
  366.         rclck = 1;
  367.         //显示第2位
  368.         led_table = LED_0F + LED[1];
  369.         i = *led_table;

  371.         LED_OUT(i);               
  372.         LED_OUT(0x02);               

  374.         rclck = 0;
  375.         rclck = 1;
  376. }
  377. if(wei==2)
  378. {
  379.         //显示第3位
  380.         led_table = LED_0F + LED[2];
  381.         i = *led_table;

  383.         LED_OUT(i);                       
  384.         LED_OUT(0x04);       

  386.         rclck = 0;
  387.         rclck = 1;
  388.         //显示第4位
  389.         led_table = LED_0F + LED[3];
  390.         i = *led_table;

  392.         LED_OUT(i);                       
  393.         LED_OUT(0x08);               

  395.         rclck = 0;
  396.         rclck = 1;
  397. }
  398. if(wei==3)
  399. {
  400.         led_table = LED_0F + LED[4];
  401.         i = *led_table;
  402.         LED_OUT(i);                       
  403.         LED_OUT(0x10);       
  404.         rclck = 0;
  405.         rclck = 1;         
  406.                  
  407.                 //显示第6位
  408.         led_table = LED_0F + LED[5];
  409.         i = *led_table;

  411.         LED_OUT(i);                       
  412.         LED_OUT(0x20);       

  414.         rclck = 0;
  415.         rclck = 1;
  416. }
  417.         if(wei==4)
  418. {
  419.                  //显示第7位
  420.         led_table = LED_0F + LED[6];
  421.         i = *led_table;

  423.         LED_OUT(i);                       
  424.         LED_OUT(0x40);       

  426.         rclck = 0;
  427.         rclck = 1;         
  428.                          //显示第8位
  429.         led_table = LED_0F + LED[7];
  430.         i = *led_table;

  432.         LED_OUT(i);               
  433.         LED_OUT(0x80);       

  435.         rclck = 0;
  436.         rclck = 1;
  437. }
  438. }
  439. uchar wendu;
  440.   uchar shidu;
  441.   void shumaguan_show(void)
  442. {
  443.            LED[1]=rec_dat[15];
  444.           LED[0]=rec_dat[16];
  445.          shidu=rec_dat[15]*10+rec_dat[16];
  446.         LED[7]=rec_dat[17];
  447.         LED[6]=rec_dat[18];
  448.          wendu=rec_dat[17]*10+rec_dat[18];
  449.         LED[2]=16;
  450.         LED[3]=16;
  451.         LED[4]=16;
  452.         LED[5]=16;
  453.         LED8_Display ();
  454.   
  455. }
  456.     //////////////////////////////////////////////////////////////////////////
  457. sbit Beep=P2^2;                   //设置蜂鸣器引脚

  459. sbit K1=P2^3;
  460. sbit K2=P2^4;
  461. sbit K3=P2^5;
  462. sbit K4=P2^6;
  463. sbit K5=P2^7;
  464. void key_init(void)
  465. {
  466. K1=1;
  467. K2=1;
  468. K3=1;
  469. K4=1;
  470. }
  471. uchar an=0;
  472. uchar move=0;
  473.   void caidan(void)
  474.   {
  475.            if(K1==0&&an==0)
  476.         {
  477.                  DelayMs(10);                                                  // 去除按键按下的抖动
  478.                 while(!K1);                                         // 等待按键释放
  479.                 DelayMs(10);                                                  // 去除按键松开的抖动
  480.                 an=1;
  481.        
  482.         }
  483.                    if(K1==0&&an==1)
  484.         {
  485.                  DelayMs(10);                                                  // 去除按键按下的抖动
  486.                 while(!K1);                                         // 等待按键释放
  487.                 DelayMs(10);                                                  // 去除按键松开的抖动
  488.                 an=0;

  490.         }       
  491.   }
  492.   void move_2(void)
  493.   {
  494.              if(K2==0&&move==0)
  495.         {
  496.                  DelayMs(10);                                                  // 去除按键按下的抖动
  497.                 while(!K2);                                         // 等待按键释放
  498.                 DelayMs(10);                                                  // 去除按键松开的抖动
  499.                 move=1;
  500.         }
  501.   
  502.                      if(K2==0&&move==1)
  503.         {
  504.                  DelayMs(10);                                                  // 去除按键按下的抖动
  505.                 while(!K2);                                         // 等待按键释放
  506.                 DelayMs(10);                                                  // 去除按键松开的抖动
  507.                 move=2;
  508.         }

  510.                    if(K2==0&&move==2)
  511.         {
  512.                  DelayMs(10);                                                  // 去除按键按下的抖动
  513.                 while(!K2);                                         // 等待按键释放
  514.                 DelayMs(10);                                                  // 去除按键松开的抖动
  515.                 move=3;
  516.         }
  517.                    if(K2==0&&move==3)
  518.         {
  519.                  DelayMs(10);                                                  // 去除按键按下的抖动
  520.                 while(!K2);                                         // 等待按键释放
  521.                 DelayMs(10);                                                  // 去除按键松开的抖动
  522.                 move=0;
  523.         }
  524.   
  525.   }

  527. uchar AlarmTL;                        // 温度下限报警值
  528. uchar AlarmTH;                        // 温度上限报警值
  529. uchar AlarmHL;                        // 湿度下限报警值
  530. uchar AlarmHH;                        // 湿度上限报警值
  531. void up_down(void)
  532. {
  533. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  534.           if(K4==0&&move==0)
  535.         {
  536.                  DelayMs(10);                                                  // 去除按键按下的抖动
  537.                 while(!K4);                                         // 等待按键释放
  538.                 DelayMs(10);                                                  // 去除按键松开的抖动
  539.                         if(AlarmTL>0)                                  // 只有当湿度上限值大于0时，才能减1
  540.                                 {
  541.                                         AlarmTL--;         
  542.                        
  543.                        
  544.                                         }
  545.         }
  546.                         if(K3==0&&move==0)                         // 判断 “加按键“ 是否被按下
  547.                         {
  548.                                 DelayMs(10);                                                  // 去除按键按下的抖动
  549.                        while(!K3);                                         // 等待按键释放
  550.                        DelayMs(10);
  551.                                 if(AlarmTL<99)                                // 只有当湿度上限值小于99时，才能加1
  552.                                         AlarmTL++;
  553.                    

  555.                         }       
  556.                         ///////////////////////////////////////////////////////////////////////////////////////////////////////
  557.           if(K4==0&&move==1)
  558.         {
  559.                  DelayMs(10);                                                  // 去除按键按下的抖动
  560.                 while(!K4);                                         // 等待按键释放
  561.                 DelayMs(10);                                                  // 去除按键松开的抖动
  562.                         if(AlarmTH>0)                                  // 只有当湿度上限值大于0时，才能减1
  563.                                 {
  564.                                         AlarmTH--;         
  565.                        
  566.                        
  567.                                         }
  568.         }
  569.                         if(K3==0&&move==1)                         // 判断 “加按键“ 是否被按下
  570.                         {
  571.                                 DelayMs(10);                                                  // 去除按键按下的抖动
  572.                        while(!K3);                                         // 等待按键释放
  573.                        DelayMs(10);
  574.                                 if(AlarmTH<99)                                // 只有当湿度上限值小于99时，才能加1
  575.                                         AlarmTH++;
  576.                    

  578.                         }       
  579. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  580.           if(K4==0&&move==2)
  581.         {
  582.                  DelayMs(10);                                                  // 去除按键按下的抖动
  583.                 while(!K4);                                         // 等待按键释放
  584.                 DelayMs(10);                                                  // 去除按键松开的抖动
  585.                         if(AlarmHL>0)                                  // 只有当湿度上限值大于0时，才能减1
  586.                                 {
  587.                                         AlarmHL--;         
  588.                        
  589.                        
  590.                                         }
  591.         }
  592.                         if(K3==0&&move==2)                         // 判断 “加按键“ 是否被按下
  593.                         {
  594.                                 DelayMs(10);                                                  // 去除按键按下的抖动
  595.                        while(!K3);                                         // 等待按键释放
  596.                        DelayMs(10);
  597.                                 if(AlarmHL<99)                                // 只有当湿度上限值小于99时，才能加1
  598.                                         AlarmHL++;
  599.                    

  601.                         }       
  602. ///////////////////////////////////////////////////////////////////////////////////////////
  603.                    if(K4==0&&move==3)
  604.         {
  605.                  DelayMs(10);                                                  // 去除按键按下的抖动
  606.                 while(!K4);                                         // 等待按键释放
  607.                 DelayMs(10);                                                  // 去除按键松开的抖动
  608.                         if(AlarmHH>0)                                  // 只有当湿度上限值大于0时，才能减1
  609.                                 {
  610.                                         AlarmHH--;         
  611.                        
  612.                        
  613.                                         }
  614.         }
  615.                         if(K3==0&&move==3)                         // 判断 “加按键“ 是否被按下
  616.                         {
  617.                                 DelayMs(10);                                                  // 去除按键按下的抖动
  618.                        while(!K3);                                         // 等待按键释放
  619.                        DelayMs(10);
  620.                                 if(AlarmHH<99)                                // 只有当湿度上限值小于99时，才能加1
  621.                                         AlarmHH++;
  622.                    

  624.                         }
  625. /////////////////////////////////////////////////////////////////////////////////////////////////////       
  626. }

  628. uchar TAB[8]={0x00,0x00,0x00,0x00,0x00};
  629. void send(uchar dat)
  630. {
  631. SBUF=dat;
  632. while(TI==0);
  633. TI=0;
  634. }
  635. sbit LED1=P0^6;
  636. sbit LED2=P0^7;
  637. sbit LED3=P0^4;
  638. sbit LED4=P0^5;

  640. void panduan(void)
  641. {
  642.         if(wendu<AlarmTL)
  643.          {
  644.            LED1=0;
  645.            Beep=0;
  646.            DelayMs(2);
  647.            Beep=1;
  648.          }
  649.                  if(wendu>AlarmTL)
  650.          {
  651.            LED1=1;
  652.            Beep=1;
  653.          }
  654.                  if(wendu>AlarmTH)
  655.          {
  656.            LED2=0;
  657.            Beep=0;
  658.            DelayMs(2);
  659.            Beep=1;
  660.          }
  661.                    if(wendu<AlarmTH)
  662.          {
  663.            LED2=1;
  664.            Beep=1;
  665.          }
  666.                   if(shidu<AlarmHL)
  667.          {
  668.            LED3=0;
  669.            Beep=0;
  670.            DelayMs(2);
  671.            Beep=1;
  672.          }
  673.                            if(shidu>AlarmHL)
  674.          {
  675.            LED3=1;
  676.            Beep=1;
  677.          }
  678.                    if(shidu>AlarmHH)
  679.          {
  680.            LED4=0;
  681.            Beep=0;
  682.            DelayMs(2);
  683.            Beep=1;
  684.          }
  685.                    if(shidu<AlarmHH)
  686.          {
  687.            LED4=1;
  688.            Beep=1;
  689.          }
  690. }
  691.   //////////////////////////////////////////////////////////////////////////
  692. /*------------------------------------------------
  693.                     主函数
  694. ------------------------------------------------*/
  695. void main(void)
  696. {
  697. uchar i;
  698. TMOD=0X20;
  699. SCON=0X40;
  700. PCON=0X00;
  701. TH1=0xfd;
  702. TL1=0xfd;
  703. TR1=1;
  704.     key_init();
  705.         AlarmTL=15;
  706.         AlarmTH=50;
  707.         AlarmHL=15;
  708.         AlarmHH=50;
  709.         DHT11_delay_ms(1000);    //DHT11上电后要等待1S以越过不稳定状态在此期间不能发送任何指令  
  710.         P0=0xff;
  711.         while (1)
  712.         {
  713.          caidan();
  714.                  if(an==0)
  715.                  {
  716.                       DHT11_receive();
  717.                     shumaguan_show();
  718.                         panduan();
  719.                  }
  720.                                   if(an==1)
  721.                          {
  722.                                 Beep=1;
  723.                                         DelayMs(10);
  724.                                 move_2();        //2位右移
  725.                                 up_down();
  726.                                 LED[1]=AlarmHH/10;// 湿度上限报警
  727.                                   LED[0]=AlarmHH%10;
  728.                                 LED[2]=AlarmHL%10; // 湿度下限报警
  729.                                 LED[3]=AlarmHL/10;
  730.                                 LED[7]=AlarmTL/10; // 温度下限报警
  731.                                 LED[6]=AlarmTL%10;
  732.                                 LED[4]=AlarmTH%10;// 温度上限报警
  733.                                 LED[5]=AlarmTH/10;
  734.                
  735.                                 if(move==0)  LED2_Display (4);
  736.                             if(move==1)  LED2_Display (3);
  737.                                 if(move==2)  LED2_Display (2);
  738.                                 if(move==3)  LED2_Display (1);   
  739.                         }
  740.                                                 if(K5==0)       
  741.                                                 {
  742.                                                          DelayMs(10);                                                  // 去除按键按下的抖动
  743.                                                                 while(!K5);                                         // 等待按键释放
  744.                                                                 DelayMs(10);
  745.                                                                 TAB[0]=rec_dat[15];
  746.                                                                    TAB[1]=rec_dat[16];
  747.                                                             TAB[2]=rec_dat[17];
  748.                                                                    TAB[3]=rec_dat[18];
  749.                                                             TAB[4]=0x00;
  750.                                                    for(i=0;i<4;i++)
  751.                                                  {
  752.                                                          send(TAB[i]);
  753.                                                                 DelayMs(200);
  754.                                                  }
  755.                                                  }       
  756.                                                                    
  757.         }
  758. }
复制代码

所有资料51hei提供下载:
基于单片机的蔬菜大棚温湿度智能控制系统设计.rar (708.89 KB, 下载次数: 275)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:725749 发表于 2020-4-9 19:55 | 显示全部楼层
原理图用什么软件看呀
回复

使用道具 举报

ID:755012 发表于 2020-5-19 10:10 | 显示全部楼层
好帖，lz牛逼
回复

使用道具 举报

ID:758682 发表于 2020-5-22 20:36 | 显示全部楼层
好帖子很有用
回复

使用道具 举报

ID:165117 发表于 2020-5-29 15:14 | 显示全部楼层
好帖子谢谢分享  学习学习!
回复

使用道具 举报

ID:808396 发表于 2020-8-22 05:47 | 显示全部楼层
程序里有lcd，但是程序里有lcd，而且数码管小数点连接标的不明确，程序复杂而且有很多多余
回复

使用道具 举报

ID:802167 发表于 2020-8-27 21:55 | 显示全部楼层
913261927 发表于 2020-4-9 19:55
原理图用什么软件看呀

proteus
回复

使用道具 举报

ID:306996 发表于 2020-9-9 08:44 | 显示全部楼层
913261927 发表于 2020-4-9 19:55
原理图用什么软件看呀

ad就可以看
回复

使用道具 举报

ID:937091 发表于 2021-6-20 19:02 | 显示全部楼层
“要求当前温湿度数据可以记录、存储、并通过穿行口上传到上位机以备查询。”
                                                                                                                                                      
请问加了这个条件，需要怎样实现呢，是只用在.c程序里写出来吗？该怎么写呢。                                                                       您分享的文件的原理图还用改变吗 ？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表