單片機論壇

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索
查看: 268|回復: 1
收起左側

贝克汉姆曼联7号图片: 單片機簡易水位控制系統Proteus仿真+代碼

[復制鏈接]
bianshuai 發表于 2019-6-25 22:01 | 顯示全部樓層 |閱讀模式
適合初學者的簡易水位控制系統仿真原理圖如下(proteus仿真工程文件可到本帖附件中下載)
QQ圖片20190625220023.png

單片機源程序如下:
  1. #include "reg52.h"
  2. //宏定義
  3. #define uint unsigned int
  4. #define uchar unsigned char
  5. //LCD管腳聲明
  6. sbit LCDRS = P1^1;
  7. sbit LCDEN= P1^2;
  8. //初始化時顯示的內容
  9. uchar code Init1[]="Tp:00.0 C Ti:000";
  10. uchar code Init2[]="Up:00   Down:00 ";
  11. //液晶的基本操作程序
  12. //LCD延時
  13. void LCDdelay(uint z)
  14. {
  15.   uint x,y;
  16.   for(x=z;x>0;x--)
  17.     for(y=10;y>0;y--);
  18. }
  19. //寫命令
  20. void write_com(uchar com)
  21. {
  22.   LCDRS=0;
  23.   P0=com;
  24.   LCDdelay(5);
  25.   LCDEN=1;
  26.   LCDdelay(5);
  27.   LCDEN=0;
  28. }
  29. //寫數據
  30. void write_data(uchar date)
  31. {
  32.   LCDRS=1;
  33.   P0=date;
  34.   LCDdelay(5);
  35.   LCDEN=1;
  36.   LCDdelay(5);
  37.   LCDEN=0;
  38. }

  39. //顯示時間溫度數據程序
  40. void Display_1602(uint aa,uchar dss,uchar sxx,uchar xxx)
  41. {
  42.         //溫度顯示
  43.         write_com(0x80+3);
  44.         write_data('0'+aa/100);
  45.         write_data('0'+aa/10%10);
  46.         write_data('.');
  47.         write_data('0'+aa%10);
  48.         write_data(0xdf);
  49.         //定時顯示
  50.         write_com(0x80+13);
  51.         write_data('0'+dss/100);
  52.         write_data('0'+dss/10%10);
  53.         write_data('0'+dss%10);
  54.         //上限顯示
  55.         write_com(0x80+0x40+3);
  56.         write_data('0'+sxx/10%10);
  57.         write_data('0'+sxx%10);
  58.         //下限顯示
  59.         write_com(0x80+0x40+13);
  60.         write_data('0'+xxx/10%10);
  61.         write_data('0'+xxx%10);
  62.         }
  63. //字符顯示程序
  64. void Display_wd()
  65. {
  66.         //溫度顯示
  67.         write_com(0x80);
  68.         write_data('S');
  69.         write_data('e');
  70.         write_data('t');
  71.         write_data(' ');
  72.         write_data('s');
  73.         write_data('t');
  74.         write_data('a');
  75.         write_data('t');
  76.         write_data('e');       
  77. }
  78. //1602初始化程序
  79. //1602初始化
  80. void Init1602()
  81. {
  82.   uchar i=0;
  83. //  write_com(0x01);//清屏
  84.   write_com(0x38);//屏幕初始化
  85.   write_com(0x0c);//打開顯示 無光標 無光標閃爍
  86.   write_com(0x06);//當讀或寫一個字符是指針后一一位
  87.   write_com(0x80);//設置位置
  88.   for(i=0;i<16;i++)
  89.   {
  90.                 write_data(Init1[i]);
  91.   }
  92.   write_com(0x80+0x40);//設置位置
  93.   for(i=0;i<16;i++)
  94.   {
  95.                 write_data(Init2[i]);
  96.   }
  97. }
  98. //程序頭函數
  99. #include <reg52.h>
  100. //顯示函數
  101. #include <display.h>
  102. //宏定義
  103. #define uint unsigned int
  104. #define uchar unsigned char
  105. //LCD管腳聲明
  106. sbit jdq= P1^0;        //加熱繼電器
  107. sbit shui=P1^3;//加水繼電器
  108. sbit Feng = P2^6; //蜂鳴器
  109. //按鍵
  110. sbit Key1=P1^4;         //設置
  111. sbit Key2=P1^5;         //加
  112. sbit Key3=P1^6;         //減
  113. sbit Key4=P1^7;         //確定          
  114. sbit shang=P3^7;//上限
  115. sbit xia=P3^6;//下限
  116. sbit DQ=P2^2;                             //定義DS18B20總線I/O
  117. signed char w,bj,bjx,bjd;                                     //溫度值全局變量
  118. uchar c;                                //溫度值全局變量
  119. bit bdata flag=0,flag_BJ,flag_off=1,que;
  120. //時間計算
  121. #define Imax 14000   //此處為晶振為11.0592時的取值,
  122. #define Imin 8000    //如用其它頻率的晶振時,
  123. #define Inum1 145    //要改變相應的取值。
  124. #define Inum2 700
  125. #define Inum3 3000
  126. //解碼變量
  127. unsigned char Im[4]={0x00,0x00,0x00,0x00};
  128. //全局變量
  129. uchar f;
  130. unsigned char m,Tc;
  131. unsigned char IrOK;
  132. //設置變量

  133. uchar xx=29;
  134. //下限
  135. uchar sx=35;
  136. //上限
  137. int ds=0;
  138. uchar Mode=0;
  139. void delay(uint z)
  140. {
  141.         uint i,j;
  142.         for(i=0;i<z;i++)
  143.         for(j=0;j<121;j++);
  144. }
  145. //溫度工作程序
  146. /*****延時子程序*****/
  147. void Delay_DS18B20(int num)
  148. {
  149.   while(num--) ;
  150. }
  151. /*****初始化DS18B20*****/
  152. void Init_DS18B20(void)
  153. {
  154.   unsigned char x=0;
  155.   DQ = 1;         //DQ復位
  156.   Delay_DS18B20(8);    //稍做延時
  157.   DQ = 0;         //單片機將DQ拉低
  158.   Delay_DS18B20(8);   //精確延時,大于480us
  159.   DQ = 1;         //拉高總線
  160.   Delay_DS18B20(14);
  161.   x = DQ;           //稍做延時后,如果x=0則初始化成功,x=1則初始化失敗
  162.   Delay_DS18B20(20);
  163. }
  164. /*****讀一個字節*****/
  165. unsigned char ReadOneChar(void)
  166. {
  167.   unsigned char i=0;
  168.   unsigned char dat = 0;
  169.   for (i=8;i>0;i--)
  170.   {
  171.     DQ = 0;     // 給脈沖信號
  172.     dat>>=1;
  173.     DQ = 1;     // 給脈沖信號
  174.     if(DQ)
  175.     dat|=0x80;
  176.     Delay_DS18B20(4);
  177.   }
  178.   return(dat);
  179. }
  180. /*****寫一個字節*****/
  181. void WriteOneChar(unsigned char dat)
  182. {
  183.   unsigned char i=0;
  184.   for (i=8; i>0; i--)
  185.   {
  186.     DQ = 1;
  187.     DQ = dat&0x10;
  188.     Delay_DS18B20(5);
  189.     DQ = 0;
  190.     dat>>=1;
  191.   }
  192. }
  193. /*****讀取溫度*****/
  194. unsigned int ReadTemperature(void)
  195. {
  196.   unsigned char a=0;
  197.   unsigned char b=0;
  198.   unsigned int t=0;
  199.   float tt=0;
  200.   Init_DS18B20();
  201.   WriteOneChar(0xC1);  //跳過讀序號列號的操作
  202.   WriteOneChar(0x44);  //啟動溫度轉換
  203.   Init_DS18B20();
  204.   WriteOneChar(0xC1);  //跳過讀序號列號的操作
  205.   WriteOneChar(0xBE);  //讀取溫度寄存器
  206.   a=ReadOneChar();     //讀低8位
  207.   b=ReadOneChar();    //讀高8位
  208.   t=b;
  209.   t<<=8;
  210.   t=t|a;
  211.   tt=t*0.00625;
  212.   t= tt*10+0.5;     //放大10倍輸出并四舍五入
  213.   return(t);
  214. }
  215. /*****讀取溫度*****/
  216. void check_wendu(void)
  217. {
  218.         c=ReadTemperature()-5;         //獲取溫度值并減去DS18B20的溫漂誤差
  219.         w=c/10;                                                      //計算得到整數位
  220.         if(w<0){w=0;}                                   //設置溫度顯示上限
  221.         if(w>99){w=99;}                           //設置溫度顯示上限   
  222. }
  223. //按鍵工作程序
  224. void Key()
  225. {
  226.         //模式選擇
  227.         if(Key1==0)
  228.         {
  229.                 while(Key1==0);
  230.                 Feng=0;
  231.                 Mode++;
  232.                 Display_wd();
  233.                 if(Mode==4)
  234.                 {
  235.                         Mode=1;
  236.                         Feng=1;
  237.                 }
  238.                    write_com(0x38);//屏幕初始化
  239.                    write_com(0x0d);//打開顯示 無光標 光標閃爍
  240.                    write_com(0x06);//當讀或寫一個字符是指針后一一位
  241.                 switch(Mode)
  242.                 {
  243.                         case 1:
  244.                         {
  245.                                 write_com(0x80+15);//位置
  246.                                 Feng=1;
  247.                                 break;
  248.                         }
  249.                         case 2:
  250.                         {
  251.                                 write_com(0x80+0x40+4);//位置
  252.                                 Feng=1;
  253.                                 break;
  254.                         }
  255.                         case 3:
  256.                         {
  257.                                 write_com(0x80+0x40+14);//位置
  258.                                 Feng=1;
  259.                                 break;
  260.                         }
  261.                 }
  262.         }
  263.         if(Key2==0&&Mode!=0)
  264.         {
  265.                 while(Key2==0);
  266.                 Feng=0;
  267.                 switch(Mode)
  268.                 {
  269.                         case 1:
  270.                         {
  271.                                 if(ds<999)
  272.                                 {
  273.                                         ds++;
  274.                                         write_com(0x80+13);
  275.                                         write_data('0'+ds/100);
  276.                                         write_data('0'+ds/10%10);
  277.                                         write_data('0'+ds%10);
  278.                                         write_com(0x80+15);//位置
  279.                                 }
  280.                                 Feng=1;
  281.                                 break;
  282.                         }
  283.                         case 2:
  284.                         {
  285.                                 if(sx<99-1)
  286.                                 {
  287.                                         sx++;
  288.                                         write_com(0x80+0x40+3);
  289.                                         write_data('0'+sx/10%10);
  290.                                         write_data('0'+sx%10);
  291.                                         write_com(0x80+0x40+4);//位置
  292.                                 }
  293.                                 Feng=1;
  294.                                 break;                               
  295.                         }
  296.                         case 3:
  297.                         {
  298.                                 if(xx<sx-1)
  299.                                 {
  300.                                         xx++;
  301.                                         write_com(0x80+0x40+13);
  302.                                         write_data('0'+xx/10%10);
  303.                                         write_data('0'+xx%10);
  304.                                         write_com(0x80+0x40+14);//位置
  305.                                 }
  306.                                 Feng=1;
  307.                                 break;                               
  308.                         }               
  309.                 }
  310.         }
  311.         if(Key3==0&&Mode!=0)
  312.         {
  313.                 while(Key3==0);
  314.                 Feng=0;
  315.                 switch(Mode)
  316.                 {
  317.                         case 1:
  318.                         {
  319.                                 if(ds>0)
  320.                                 {
  321.                                         ds--;
  322.                                         write_com(0x80+13);
  323.                                         write_data('0'+ds/100);
  324.                                         write_data('0'+ds/10%10);
  325.                                         write_data('0'+ds%10);
  326.                                         write_com(0x80+15);//位置
  327.                                 }
  328.                                 Feng=1;
  329.                                 break;
  330.                         }
  331.                         case 2:
  332.                         {
  333.                                 if(sx>xx+1)
  334.                                 {
  335.                                         sx--;
  336.                                         write_com(0x80+0x40+3);
  337.                                         write_data('0'+sx/10%10);
  338.                                         write_data('0'+sx%10);
  339.                                         write_com(0x80+0x40+4);//位置
  340.                                 }
  341.                                 Feng=1;
  342.                                 break;                               
  343.                         }
  344.                         case 3:
  345.                         {
  346.                                 if(xx>0)
  347.                                 {
  348.                                         xx--;
  349.                                         write_com(0x80+0x40+13);
  350.                                         write_data('0'+xx/10%10);
  351.                                         write_data('0'+xx%10);
  352.                                         write_com(0x80+0x40+14);//位置
  353.                                 }
  354.                                 Feng=1;
  355.                                 break;                               
  356.                         }               
  357.                 }
  358.         }
  359.         if(Key4==0)
  360.         {
  361.                 while(Key4==0);
  362.                 Feng=0;
  363.                 Mode=0;
  364. //                write_com(0x38);//屏幕初始化
  365. //                write_com(0x0c);//打開顯示 無光標 無光標閃爍
  366.                 Init1602();
  367.                 if(ds>0)
  368.                 {
  369.                         flag=1;
  370.                         jdq=1;
  371.                         TR1=1;
  372.                 }
  373.                 Feng=1;
  374.         }
  375. }
  376. /*                if(IrOK==1)
  377.                 {
  378.                         if(Im[2]==0x0d)        //??厴柚眉?br />
  379.                         {
  380.                                 Feng=0;
  381.                                 Mode++;
  382.                                 Display_wd();
  383.                                 if(Mode==4)
  384.                                 {
  385.                                         Mode=1;
  386.                                         Feng=1;
  387.                                 }
  388.                                    write_com(0x38);//屏幕初始化
  389.                                    write_com(0x0d);//打開顯示 無光標 光標閃爍
  390.                                    write_com(0x06);//當讀或寫一個字符是指針后一一位
  391.                                 switch(Mode)
  392.                                 {
  393.                                         case 1:
  394.                                         {
  395.                                                 write_com(0x80+15);//位置
  396.                                                 Feng=1;
  397.                                                 break;
  398.                                         }
  399.                                         case 2:
  400.                                         {
  401.                                                 write_com(0x80+0x40+5);//位置
  402.                                                 Feng=1;
  403.                                                 break;
  404.                                         }
  405.                                         case 3:
  406.                                         {
  407.                                                 write_com(0x80+0x40+14);//位置
  408.                                                 Feng=1;
  409.                                                 break;
  410.                                         }
  411.                                 }                                 
  412.                         }
  413.                         //+鍵
  414.                         else if(Im[2]==0x40)
  415.                         {
  416.                                 if(Mode!=0)
  417.                                 {
  418.                                         Feng=0;
  419.                                         switch(Mode)
  420.                                         {
  421.                                                 case 1:
  422.                                                 {
  423.                                                         if(ds<999)
  424.                                                         {
  425.                                                                 ds++;
  426.                                                                 write_com(0x80+13);
  427.                                                                 write_data('0'+ds/100);
  428.                                                                 write_data('0'+ds/10%10);
  429.                                                                 write_data('0'+ds%10);
  430.                                                                 write_com(0x80+15);//位置
  431.                                                         }
  432.                                                         Feng=1;
  433.                                                         break;
  434.                                                 }
  435.                                                 case 2:
  436.                                                 {
  437.                                                         if(sx<99-1)
  438.                                                         {
  439.                                                                 sx++;
  440.                                                                 write_com(0x80+0x40+4);
  441.                                                                 write_data('0'+sx/10%10);
  442.                                                                 write_data('0'+sx%10);
  443.                                                                 write_com(0x80+0x40+5);//位置
  444.                                                         }
  445.                                                         Feng=1;
  446.                                                         break;                               
  447.                                                 }
  448.                                                 case 3:
  449.                                                 {
  450.                                                         if(xx<sx-1)
  451.                                                         {
  452.                                                                 xx++;
  453.                                                                 write_com(0x80+0x40+13);
  454.                                                                 write_data('0'+xx/10%10);
  455.                                                                 write_data('0'+xx%10);
  456.                                                                 write_com(0x80+0x40+14);//位置
  457.                                                         }
  458.                                                         Feng=1;
  459.                                                         break;                               
  460.                                                 }               
  461.                                         }
  462.                                 }
  463.                         }
  464.                         //-鍵
  465.                         else if(Im[2]==0x19)
  466.                         {
  467.                                 if(Mode!=0)
  468.                                 {
  469.                                         Feng=0;
  470.                                         switch(Mode)
  471.                                         {
  472.                                                 case 1:
  473.                                                 {
  474.                                                         if(ds>0)
  475.                                                         {
  476.                                                                 ds--;
  477.                                                                 write_com(0x80+13);
  478.                                                                 write_data('0'+ds/100);
  479.                                                                 write_data('0'+ds/10%10);
  480.                                                                 write_data('0'+ds%10);
  481.                                                                 write_com(0x80+15);//位置
  482.                                                         }
  483.                                                         Feng=1;
  484.                                                         break;
  485.                                                 }
  486.                                                 case 2:
  487.                                                 {
  488.                                                         if(sx>xx+1)
  489.                                                         {
  490.                                                                 sx--;
  491.                                                                 write_com(0x80+0x40+4);
  492.                                                                 write_data('0'+sx/10%10);
  493.                                                                 write_data('0'+sx%10);
  494.                                                                 write_com(0x80+0x40+5);//位置
  495.                                                         }
  496.                                                         Feng=1;
  497.                                                         break;                               
  498.                                                 }
  499.                                                 case 3:
  500.                                                 {
  501.                                                         if(xx>0)
  502.                                                         {
  503.                                                                 xx--;
  504.                                                                 write_com(0x80+0x40+13);
  505.                                                                 write_data('0'+xx/10%10);
  506.                                                                 write_data('0'+xx%10);
  507.                                                                 write_com(0x80+0x40+14);//位置
  508.                                                         }
  509.                                                         Feng=1;
  510.                                                         break;                               
  511.                                                 }               
  512.                                         }
  513.                                 }
  514.                         }
  515.                         //確定鍵
  516.                         else if(Im[2]==0x15)
  517.                         {
  518.                                 Feng=0;
  519.                                 Mode=0;
  520.                                 Init1602();
  521.                                 if(ds>0)
  522.                                 {
  523.                                         flag=1;
  524.                                         jdq=1;
  525.                                         TR1=1;
  526.                                 }
  527.                                 Feng=1;
  528.                         }
  529.                         IrOK=0;          
  530.                 }
  531.         }
  532.         */
  533. //報警部分程序
  534. void Alam()
  535. {
  536.         if(flag_BJ==1&&flag_off==1)
  537.         {
  538.                 Feng=0;
  539.                 delay(1000);
  540.                 Feng=1;
  541.                 flag_off=0;
  542. //                flag_BJ=0;
  543.         }
  544. }
  545. //主程序
  546. void main()
  547. {

  548.         Init1602();
  549.         EA=1;//打開中斷總開關
  550.         IT1=1;//下降沿有效
  551.         EX1=1;//外部中斷1開
  552.         ET1=1;//打開允許開關
  553.         TMOD=0x01;//設置工作方式
  554.         TL1=0x3c;
  555.         TH1=0xb0;//賦初值
  556.         TH0=0;//T0賦初值
  557.         TL0=0;
  558.         TR0=0;//t0開始計時
  559.         check_wendu();
  560.         delay(1000);
  561.         bjd=99;
  562.         bjx=0;
  563.         while(1)
  564.         {       
  565.                 check_wendu();
  566.                 if(Mode==0)
  567.                 {       
  568.                         Display_1602(c,ds,sx,xx);
  569.                         if((xia==1)&&(shang==1)) //低于下限
  570.                         {
  571.                                  que=1;
  572.                                 shui=0;
  573.                                 jdq=1;
  574.                         }
  575.                         else
  576.                         {
  577.                                 que=0;
  578.                         }
  579.                         if((shang==0)&&(xia==0)) //高于上限
  580.                         {
  581.                                 shui=1;
  582.                                 if(flag_BJ==0)
  583.                                 flag_BJ=1;
  584.                         }
  585.                         if((shang==0)&&(xia==1)) //錯誤
  586.                         {
  587.                                 shui=1;
  588.                                 jdq=1;
  589.                                 Feng=0;
  590.                                 que=1;
  591.                         }
  592.                         if(flag==0)
  593.                         {
  594.                                 if((w<bjd)&&(w>bjx))
  595.                                 {
  596.                                         if(w>=sx)
  597.                                         {
  598.                                                 jdq=1;
  599.                                                 if(flag_BJ==0)
  600.                                                 flag_BJ=1;
  601.                                         }
  602.                                         else if((w<xx)&&(que==0))          
  603.                                         {
  604.                                                 jdq=0;
  605.                                                 if(flag_BJ==0)
  606.                                                 flag_BJ=1;
  607.                                         }
  608.                                         else
  609.                                         {
  610.                                                 flag_BJ=0;
  611.                                                 flag_off=1;
  612.                                         }
  613.                                         bjd=w+5;
  614.                                         bjx=w-5;
  615.                                 }
  616.                         }
  617.                 }
  618.                 Key();
  619.                 Alam();
  620.         }
  621. }
  622. //定時器工作程序
  623. void time1() interrupt 3//定時器函數
  624. {
  625.         uint s;
  626.         TH1=0x3c;
  627.         TL1=0xb0;//重新賦初值
  628.         s++;
  629.         if(s==1200)        //s=20為1s鐘  1200為1分鐘
  630.         {
  631.                 s=0;
  632.                 ds--;
  633.                 if(ds==0)
  634.                 {
  635.                         flag=0;
  636.                         if(w>=sx)
  637.                         {
  638.                                 jdq=1;
  639.                                 if(flag_BJ==0)
  640.                                 flag_BJ=1;
  641.                         }
  642.                         else if((w<xx)&&(que==0))
  643.                         {
  644.                                 jdq=0;
  645.                                 if(flag_BJ==0)
  646.                                 flag_BJ=1;
  647.                         }
  648.                         else
  649.                                 {
  650.                                         flag_BJ=0;
  651.                                         flag_off=1;
  652.                                 }
  653.                         bjd=w+10;
  654.                         bjx=w-10;
  655.                         TR1=0;
  656.                 }
  657.         }
  658. }

  659.                //準備讀下一碼
復制代碼

所有資料51hei提供下載:
簡易水位控制.rar (178.59 KB, 下載次數: 8)
szzxl10 發表于 2019-7-12 18:32 | 顯示全部樓層
感謝分享
您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

QQ|手機版|小黑屋|單片機論壇 |51黑電子論壇單片機 聯系QQ:125739409;技術交流QQ群582644647

Powered by 曼联vs曼城

快速回復 曼联vs曼城 返回列表