找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1685|回复: 0
收起左侧

单片机+LCD1602显示冷热水调和系统Proteus仿真程序 精度为±1℃

[复制链接]
ID:559790 发表于 2019-7-11 17:53 | 显示全部楼层 |阅读模式
实现的功能(1)用LCD1602液晶显示水温、设置上下限和定时时间,(2)水温检测显示范围为00~99℃,精度为±1℃。(3)温度预设范围为0~99℃,当检测温度低于预设温度时,开始加热;检测温度高于预设温度时,停止加热。(4)设置4个程序按键。分别是设置按键、加键、减键、确定。(5)可以红外遥控,通过红外一体接收探头接收遥控器信号,执行与主板按键同等功能。(6)有水位检测功能,无水自动上水,无水不加热。

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)
0.png

单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #define uint unsigned int
  4. #define uchar unsigned char

  5. sbit LCDRS = P1^1;        //命令数据选择        
  6. sbit LCDEN= P1^2;        //使能
  7. sbit jdq= P1^0;        //加热继电器
  8. sbit shui=P1^3;//加水继电器
  9. sbit Feng = P2^6; //蜂鸣器
  10. //按键
  11. sbit Key1=P1^4;         //设置
  12. sbit Key2=P1^5;         //加
  13. sbit Key3=P1^6;         //减
  14. sbit Key4=P1^7;         //确定         
  15. sbit shang=P3^7;//上限
  16. sbit xia=P3^6;//下限
  17. sbit DQ=P2^2;                                //定义DS18B20总线I/O
  18. signed char w,bj,bjx,bjd;     //温度值全局变量
  19. uint c;                                           //温度值全局变量
  20. bit bdata flag=0,flag_BJ,flag_off=1,que;//flag:定时状态标志位flag_BJ:报警标志位flag_off:手动关闭报警标志位que:缺水标志位
  21. /*******遥控时间计算********/
  22. #define Imax  14000    //此处为晶振为12时的取值,
  23. #define Imin  8000    //如用其它频率的晶振时,
  24. #define Inum1 1450    //要改变相应的取值。
  25. #define Inum2 700
  26. #define Inum3 3000
  27. //解码变量
  28. unsigned char Im[4]={0x00,0x00,0x00,0x00};

  29. //全局变量
  30. uchar f;
  31. unsigned char m,Tc;
  32. unsigned char IrOK;

  33. uint xx=28;         //T设定下限
  34. uint sx=37;         //T设定上限

  35. int ds=0;
  36. uchar Mode=0;
  37. /********设置变量**********/

  38. //初始画时显示的内容
  39. uchar code Init1[]="Tp:00.0 C Ti:000";
  40. uchar code Init2[]=" Up:00  Down:00 ";
  41. /*********液晶的基本操作程序**********/

  42. //LCD延时
  43. void LCDdelay(uint z)
  44. {
  45.   uint x,y;
  46.   for(x=z;x>0;x--)
  47.     for(y=10;y>0;y--);
  48. }
  49. //写命令
  50. void write_com(uchar com)
  51. {
  52.   LCDRS=0;
  53.   P0=com;
  54.   LCDdelay(5);
  55.   LCDEN=1;
  56.   LCDdelay(5);
  57.   LCDEN=0;
  58. }
  59. //写数据
  60. void write_data(uint date)
  61. {
  62.   LCDRS=1;
  63.   P0=date;
  64.   LCDdelay(5);
  65.   LCDEN=1;
  66.   LCDdelay(5);
  67.   LCDEN=0;
  68. }
  69. /*******1602初始化程序********/
  70. void Init1602()
  71. {
  72.   uchar i=0;
  73.   uchar j=0;
  74.   
  75.   write_com(0x38);    //屏幕初始化
  76.   write_com(0x0c);    //打开显示 无光标 无光标闪烁
  77.   write_com(0x06);    //当读或写一个字符是指针后一一位
  78.   write_com(0x01);    //清屏
  79.   write_com(0x80);    //设置位置
  80.   
  81.   for(i=0;i<16;i++)
  82.   {
  83.                 write_data(Init1[i]);
  84.   }
  85.   write_com(0xc0);//设置位置
  86.   for(j=0;j<16;j++)
  87.   {
  88.                 write_data(Init2[j]);
  89.   }
  90. }

  91. /*******显示时间温度数据程序***********/
  92. void Display_1602(uint c,uint ds,uint sx,uint xx)
  93. {
  94.         //温度显示
  95.         write_com(0x80+3);
  96.         write_data('0'+c/100);
  97.         write_data('0'+c/10%10);
  98.         write_data('.');
  99.         write_data('0'+c %10);
  100.         write_data(0xdf);

  101.         //定时显示
  102.         write_com(0x80+13);
  103.         write_data('0'+ds/100);
  104.         write_data('0'+ds/10%10);
  105.         write_data('0'+ds%10);

  106.         //上限显示
  107.         write_com(0x80+0x40+4);
  108.         write_data('0'+sx/10%10);
  109.         write_data('0'+sx%10);

  110.         //下限显示
  111.         write_com(0x80+0x40+13);
  112.         write_data('0'+xx/10%10);
  113.         write_data('0'+xx%10);
  114.         
  115. }
  116. /****字符显示程序*****/
  117. void Display_wd()
  118. {
  119.         //温度显示
  120.         write_com(0x80);
  121.         write_data('S');
  122.         write_data('e');
  123.         write_data('t');
  124.         write_data(' ');
  125.         write_data('s');
  126.         write_data('t');
  127.         write_data('a');
  128.         write_data('t');
  129.         write_data('e');        
  130. }


  131. void delay(uint z)
  132. {
  133.         uint i,j;
  134.         for(i=0;i<z;i++)
  135.         for(j=0;j<121;j++);
  136. }
  137. /*******************温度工作程序**************************/
  138. /*****延时子程序*****/
  139. void Delay_DS18B20(int num)
  140. {
  141.   while(num--) ;
  142. }
  143. /*****初始化DS18B20*****/
  144. uchar Init_DS18B20(void)
  145. {
  146.   unsigned char x=0;
  147.   DQ = 1;         //DQ复位
  148.   Delay_DS18B20(8);    //稍做延时
  149.   DQ = 0;         //单片机将DQ拉低
  150.   Delay_DS18B20(80);   //精确延时,大于480us
  151.   DQ = 1;         //拉高总线
  152.   Delay_DS18B20(14);
  153.   x = DQ;           //稍做延时后,如果x=0则初始化成功,x=1则初始化失败
  154.   Delay_DS18B20(20);
  155.   return(x);
  156. }
  157. /*****读一个字节*****/
  158. unsigned char ReadOneChar(void)
  159. {
  160.   unsigned char i=0;
  161.   unsigned char dat = 0;
  162.   for (i=8;i>0;i--)
  163.   {
  164.     DQ = 0;     // 给脉冲信号
  165.     dat>>=1;
  166.     DQ = 1;
  167.         _nop_();
  168.         _nop_();             // 给脉冲信号
  169.     if(DQ)
  170.     dat|=0x80;
  171.     Delay_DS18B20(4);
  172.         DQ=1;
  173.   }
  174.   return(dat);
  175. }
  176. /*****写一个字节*****/
  177. void WriteOneChar(unsigned char dat)
  178. {
  179.   unsigned char i=0;
  180.   for (i=8; i>0; i--)
  181.   {
  182.     DQ = 0;
  183.     DQ = dat&0x01;
  184.     Delay_DS18B20(5);
  185.     DQ = 1;
  186.     dat>>=1;
  187.   }
  188. }
  189. /*****读取温度*****/
  190. unsigned int ReadTemperature(void)
  191. {
  192.   unsigned char a=0;
  193.   unsigned char b=0;
  194.   unsigned int t=0;
  195.   float tt=0;
  196.   Init_DS18B20();
  197.   WriteOneChar(0xCC);  //跳过读序号列号的操作
  198.   WriteOneChar(0x44);  //启动温度转换
  199.   Init_DS18B20();
  200.   WriteOneChar(0xCC);  //跳过读序号列号的操作
  201.   WriteOneChar(0xBE);   //读取温度寄存器
  202.   a=ReadOneChar();      //读低8位
  203.   b=ReadOneChar();      //读高8位
  204.   t=b;
  205.   t<<=8;
  206.   t=t|a;
  207.   tt=t*0.0625;
  208.   t= tt*10+0.5;        //放大10倍输出并四舍五入
  209.   return(t);
  210. }


  211. /*****读取温度*****/
  212. void check_wendu(void)
  213. {
  214.         c=ReadTemperature();                          //获取温度值并减去DS18B20的温漂误差
  215.         w=c/10;                                                      //计算得到整数位
  216.         if(w<0){w=0;}                                   //设置温度显示下限
  217.         if(w>99){w=99;}                                   //设置温度显示上限   
  218. }

  219. /****************按键工作程序*************************/
  220. void Key()
  221. {
  222.         //模式选择
  223.         if(Key1==0)
  224.         {
  225.                 while(Key1==0);
  226.                 Feng=0;
  227.                 Mode++;
  228.                 Display_wd();
  229.                 if(Mode==4)
  230.                 {
  231.                         Mode=1;
  232.                         Feng=1;
  233.                 }
  234.                    write_com(0x38);//屏幕初始化
  235.                    write_com(0x0d);//打开显示 无光标 光标闪烁
  236.                    write_com(0x06);//当读或写一个字符是指针后一一位
  237.                 switch(Mode)
  238.                 {
  239.                         case 1:
  240.                         {
  241.                                 write_com(0x80+15);//位置
  242.                                 Feng=1;
  243.                                 break;
  244.                         }
  245.                         case 2:
  246.                         {
  247.                                 write_com(0x80+0x40+5);//位置
  248.                                 Feng=1;
  249.                                 break;
  250.                         }
  251.                         case 3:
  252.                         {
  253.                                 write_com(0x80+0x40+14);//位置
  254.                                 Feng=1;
  255.                                 break;
  256.                         }
  257.                 }
  258.         }
  259.         if(Key2==0&&Mode!=0)
  260.         {
  261.                 while(Key2==0);
  262.                 Feng=0;
  263.                 switch(Mode)
  264.                 {
  265.                         case 1:
  266.                         {
  267.                                 if(ds<999)
  268.                                 {
  269.                                         ds++;
  270.                                         write_com(0x80+13);
  271.                                         write_data('0'+ds/100);
  272.                                         write_data('0'+ds/10%10);
  273.                                         write_data('0'+ds%10);
  274.                                         write_com(0x80+15);//位置
  275.                                 }
  276.                                 Feng=1;
  277.                                 break;
  278.                         }
  279.                         case 2:
  280.                         {
  281.                                 if(sx<99-1)
  282.                                 {
  283.                                         sx++;
  284.                                         write_com(0x80+0x40+4);
  285.                                         write_data('0'+sx/10%10);
  286.                                         write_data('0'+sx%10);
  287.                                         write_com(0x80+0x40+5);//位置
  288.                                 }
  289.                                 Feng=1;
  290.                                 break;                                
  291.                         }
  292.                         case 3:
  293.                         {
  294.                                 if(xx<sx-1)
  295.                                 {
  296.                                         xx++;
  297.                                         write_com(0x80+0x40+13);
  298.                                         write_data('0'+xx/10%10);
  299.                                         write_data('0'+xx%10);
  300.                                         write_com(0x80+0x40+14);//位置
  301.                                 }
  302.                                 Feng=1;
  303.                                 break;                                
  304.                         }               
  305.                 }
  306.         }
  307.         if(Key3==0&&Mode!=0)
  308.         {
  309.                 while(Key3==0);
  310.                 Feng=0;
  311.                 switch(Mode)
  312.                 {
  313.                         case 1:
  314.                         {
  315.                                 if(ds>0)
  316.                                 {
  317.                                         ds--;
  318.                                         write_com(0x80+13);
  319.                                         write_data('0'+ds/100);
  320.                                         write_data('0'+ds/10%10);
  321.                                         write_data('0'+ds%10);
  322.                                         write_com(0x80+15);//位置
  323.                                 }
  324.                                 Feng=1;
  325.                                 break;
  326.                         }
  327.                         case 2:
  328.                         {
  329.                                 if(sx>xx+1)
  330.                                 {
  331.                                         sx--;
  332.                                         write_com(0x80+0x40+4);
  333.                                         write_data('0'+sx/10%10);
  334.                                         write_data('0'+sx%10);
  335.                                         write_com(0x80+0x40+5);//位置
  336.                                 }
  337.                                 Feng=1;
  338.                                 break;                                
  339.                         }
  340.                         case 3:
  341.                         {
  342.                                 if(xx>0)
  343.                                 {
  344.                                         xx--;
  345.                                         write_com(0x80+0x40+13);
  346.                                         write_data('0'+xx/10%10);
  347.                                         write_data('0'+xx%10);
  348.                                         write_com(0x80+0x40+14);//位置
  349.                                 }
  350.                                 Feng=1;
  351.                                 break;                                
  352.                         }               
  353.                 }
  354.         }
  355.         if(Key4==0)
  356.         {
  357.                 while(Key4==0);
  358.                 Feng=0;
  359.                 Mode=0;
  360.             write_com(0x38);//屏幕初始化
  361.             write_com(0x0c);//打开显示 无光标 无光标闪烁
  362.                 Init1602();
  363.                 //Display_1602(c,ds,sx,xx);
  364.                 if(ds>0)
  365.                 {
  366.                         flag=1;
  367.                         jdq=1;
  368.                         TR1=1;
  369.                 }
  370.                 Feng=1;
  371.         }
  372.                 if(IrOK==1)
  373.                 {
  374.                         if(Im[2]==0x0d)        //遥控设置键
  375.                         {
  376.                                 Feng=0;
  377.                                 Mode++;
  378.                                 Display_wd();
  379.                                 if(Mode==4)
  380.                                 {
  381.                                         Mode=1;
  382.                                         Feng=1;
  383.                                 }
  384.                                    write_com(0x38);//屏幕初始化
  385.                                    write_com(0x0d);//打开显示 无光标 光标闪烁
  386.                                    write_com(0x06);//当读或写一个字符是指针后一一位
  387.                                 switch(Mode)
  388.                                 {
  389.                                         case 1:
  390.                                         {

  391.                                                 write_com(0x80+15);//位置
  392.                                                 Feng=1;
  393.                                                 break;
  394.                                         }
  395.                                         case 2:
  396.                                         {
  397.                                                 write_com(0x80+0x40+5);//位置
  398.                                                 Feng=1;
  399.                                                 break;
  400.                                         }
  401.                                         case 3:
  402.                                         {
  403.                                                 write_com(0x80+0x40+14);//位置
  404.                                                 Feng=1;
  405.                                                 break;
  406.                                         }
  407.                                 }                                 
  408.                         }
  409.                         //+键
  410.                         else if(Im[2]==0x40)
  411.                         {
  412.                                 if(Mode!=0)
  413.                                 {
  414.                                         Feng=0;
  415.                                         switch(Mode)
  416.                                         {
  417.                                                 case 1:
  418.                                                 {
  419.                                                         if(ds<999)
  420.                                                         {
  421.                                                                 ds++;
  422.                                                                 write_com(0x80+13);
  423.                                                                 write_data('0'+ds/100);
  424.                                                                 write_data('0'+ds/10%10);
  425.                                                                 write_data('0'+ds%10);
  426.                                                                 write_com(0x80+15);//位置
  427.                                                         }
  428.                                                         Feng=1;
  429.                                                         break;
  430.                                                 }
  431.                                                 case 2:
  432.                                                 {
  433.                                                         if(sx<99-1)
  434.                                                         {
  435.                                                                 sx++;
  436.                                                                 write_com(0x80+0x40+4);
  437.                                                                 write_data('0'+sx/10%10);
  438.                                                                 write_data('0'+sx%10);
  439.                                                                 write_com(0x80+0x40+5);//位置
  440.                                                         }
  441.                                                         Feng=1;
  442.                                                         break;                                
  443.                                                 }
  444.                                                 case 3:
  445.                                                 {
  446.                                                         if(xx<sx-1)
  447.                                                         {
  448.                                                                 xx++;
  449.                                                                 write_com(0x80+0x40+13);
  450.                                                                 write_data('0'+xx/10%10);
  451.                                                                 write_data('0'+xx%10);
  452.                                                                 write_com(0x80+0x40+14);//位置
  453.                                                         }
  454.                                                         Feng=1;
  455.                                                         break;                                
  456.                                                 }               
  457.                                         }
  458.                                 }
  459.                         }
  460.                         //-键
  461.                         else if(Im[2]==0x19)
  462.                         {
  463.                                 if(Mode!=0)
  464.                                 {
  465.                                         Feng=0;
  466.                                         switch(Mode)
  467.                                         {
  468.                                                 case 1:
  469.                                                 {
  470.                                                         if(ds>0)
  471.                                                         {
  472.                                                                 ds--;
  473.                                                                 write_com(0x80+13);
  474.                                                                 write_data('0'+ds/100);
  475.                                                                 write_data('0'+ds/10%10);
  476.                                                                 write_data('0'+ds%10);
  477.                                                                 write_com(0x80+15);//位置
  478.                                                         }
  479.                                                         Feng=1;
  480.                                                         break;
  481.                                                 }
  482.                                                 case 2:
  483.                                                 {
  484.                                                         if(sx>xx+1)
  485.                                                         {
  486.                                                                 sx--;
  487.                                                                 write_com(0x80+0x40+4);
  488.                                                                 write_data('0'+sx/10%10);
  489.                                                                 write_data('0'+sx%10);
  490.                                                                 write_com(0x80+0x40+5);//位置
  491.                                                         }
  492.                                                         Feng=1;
  493.                                                         break;                                
  494.                                                 }
  495.                                                 case 3:
  496.                                                 {
  497.                                                         if(xx>0)
  498.                                                         {
  499.                                                                 xx--;
  500.                                                                 write_com(0x80+0x40+13);
  501.                                                                 write_data('0'+xx/10%10);
  502.                                                                 write_data('0'+xx%10);
  503.                                                                 write_com(0x80+0x40+14);//位置
  504.                                                         }
  505.                                                         Feng=1;
  506.                                                         break;                                
  507.                                                 }               
  508.                                         }
  509.                                 }
  510.                         }
  511.                         //确定键
  512.                         else if(Im[2]==0x15)
  513.                         {
  514.                                 Feng=0;
  515.                                 Mode=0;
  516.                                 Init1602();
  517.                                 if(ds>0)
  518.                                 {
  519.                                         flag=1;
  520.                                         jdq=1;
  521.                                         TR1=1;
  522.                                 }
  523.                                 Feng=1;
  524.                         }
  525.                         IrOK=0;         
  526.                 }
  527. }

  528. /*********************报警部分程序**************************/
  529. void Alam()
  530. {
  531.         if(flag_BJ==1&&flag_off==1)
  532.         {
  533.                 Feng=0;
  534.                 delay(1000);
  535.                 Feng=1;
  536.                 flag_off=0;
  537. //                flag_BJ=0;
  538.         }
  539. }
  540. /**************************主程序******************************/
  541. void main()
  542. {
  543.         Init1602();
  544.         EA=1;       //打开中断总开关
  545.         IT1=1;     //下降沿有效
  546.         EX1=1;     //外部中断1开
  547.         ET1=1;     //打开允许开关
  548.         TMOD=0x11; //设置工作方式
  549.         TL1=0x3c;
  550.         TH1=0xb0;  //T1赋初值50ms
  551.         TH0=0;     //T0赋初值
  552.         TL0=0;
  553.         TR0=0;     //t0开始计时控制
  554.         check_wendu();
  555.         delay(1000);
  556.         bjd=99;
  557.         bjx=0;                                 //这两个变量的作用就是,防止温度大范围跳动造成加热设备误动作
  558.         while(1)
  559.         {        
  560.                 check_wendu();
  561.                 if(Mode==0)
  562.                 {        
  563.                         Display_1602(c,ds,sx,xx);
  564.                         if((xia==1)&&(shang==1)) //低于下限
  565.                         {
  566.                                  que=1;
  567.                                 shui=0;
  568.                                 jdq=1;
  569.                         }
  570.                         else
  571.                         {
  572.                                 que=0;
  573.                         }
  574.                         if((shang==0)&&(xia==0)) //高于上限
  575.                         {
  576.                                 shui=1;
  577.                                 if(flag_BJ==0)
  578.                                 flag_BJ=1;
  579.                         }
  580.                         if((shang==0)&&(xia==1)) //错误
  581.                         {
  582.                                 shui=1;
  583.                                 jdq=1;
  584.                                 Feng=0;
  585.                                 que=1;
  586.                         }
  587.                         if(flag==0)
  588.                         {
  589.                                 if((w<bjd)&&(w>bjx))
  590.                                 {
  591.                                         if(w>=sx)
  592.                                         {
  593.                                                 jdq=1;
  594.                                                 if(flag_BJ==0)
  595.                                                 flag_BJ=1;
  596.                                         }
  597.                                         else if((w<xx)&&(que==0))         
  598.                                         {
  599.                                                 jdq=0;
  600.                                                 if(flag_BJ==0)
  601.                                                 flag_BJ=1;
  602.                                         }
  603.                                         else
  604.                                         {
  605.                                                 flag_BJ=0;
  606.                                                 flag_off=1;
  607.                                         }
  608.                                         bjd=w+5;
  609.                                         bjx=w-5;
  610.                                 }
  611.                         }
  612.                 }
  613.                 Key();
  614.                 Alam();
  615.         }
  616. }
  617. /*****************定时器工作程序**********************/
  618. void time1() interrupt 3//定时器T1函数
  619. {
  620.         uint s;
  621.         TH1=0x3c;
  622.         TL1=0xb0;       //重新赋初值
  623.         s++;
  624.         if(s==1200)            //s=20为1s钟  1200为1分钟
  625.         {
  626.                 s=0;
  627.                 ds--;
  628.                 if(ds==0)
  629.                 {
  630.                         flag=0;
  631.                         if(w>=sx)
  632.                         {
  633.                                 jdq=1;
  634.                                 if(flag_BJ==0)
  635.                                 flag_BJ=1;
  636.                         }
  637.                         else if((w<xx)&&(que==0))
  638.                         {
  639.                                 jdq=0;
  640.                                 if(flag_BJ==0)
  641.                                 flag_BJ=1;
  642.                         }
  643.                         else
  644.                                 {
  645.                                         flag_BJ=0;
  646.                                         flag_off=1;
  647.                                 }
  648.                         bjd=w+10;
  649.                         bjx=w-10;
  650.                         TR1=0;
  651.                 }
  652.         }
  653. }

  654. /*****************红外解码定时器程序****************************/
  655. //外部中断解码程序_外部中断1
  656. void intersvr1(void) interrupt 2 using 1
  657. {
  658. TR0=1;
  659. Tc=TH0*256+TL0;//提取中断时间间隔时长
  660. TH0=0;
  661. TL0=0;            //定时中断重新置零

  662. if((Tc>Imin)&&(Tc<Imax))
  663. {
  664.         m=0;
  665.         f=1;
  666.         return;
  667. }                  //找到启始码
  668. if(f==1)
  669. {
  670.         if(Tc>Inum1&&Tc<Inum3)
  671.     {
  672.            Im[m/8]=Im[m/8]>>1|0x80; m++;
  673.     }
  674.     if(Tc>Inum2&&Tc<Inum1)
  675.     {
  676.       Im[m/8]=Im[m/8]>>1; m++; //取码
  677.            }
  678.            if(m==32)
  679.     {
  680.       m=0;  
  681.       f=0;
  682.       if(Im[2]==~Im[3])
  683.       {
  684.            IrOK=1;
  685.                    TR0=0;
  686.            }
  687.       else IrOK=0;   //取码完成后判断读码是否正确
  688.     }
  689.                     //准备读下一码
  690. }
  691. }
复制代码

所有资料51hei提供下载:
水温调试.zip (106.34 KB, 下载次数: 32)

评分

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

查看全部评分

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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