最新发表 推荐阅读 明星博主 原创博文 年度排行 博文排行 博文评论 FPGA/CPLD MCU/ 嵌入式 模拟 电源/新能源 测试测量 通信 智能手机 处理器与DSP PCB 汽车电子 消费电子 智能硬件 物联网 软件与OS 采购与分销 供应链管理 工程师职场 EDA/ IP/ 设计与制造 无人机 机器人/ AI 医疗电子 工业电子 管理
小羡
文章：16 阅读：17954 评论：0 赞：119
好友 私信 个人主页

原创 51单片机超声波水位控制器设计资料

2023-4-27 20:14 1038 8 4 分类: MCU/ 嵌入式
本设计中液晶显示有4个字母，分别为
H------容器的最高水位设定值（不能高于实际高度）
L------容器的最低水位设定值
D-----容器实际高度（可以设置）
C-----容器内液体的高度（在实际演示中，障碍物离探头越近，液晶C显示越大，因为障碍物好比液面，离探头近了说明水位高了）

特别提醒:如果容器实际高度D你设置为1米，那么C液体的高度最高能测到98cm,因为探头的盲区在2cm左右。如果D设为2米，那么最高能测到1.98m.

按键功能分别为：设置键 增加键 减小键 复位键

三个指示灯的分别功能为：红色----超过设定的最高水位H  黄色-----低于设定的最低水位L
                        绿色----最高H和最低L中间

本文采用AT89C52单片机系统实现了水塔水位的自动控制，设计出一种低成本、高实用价值的水塔水位控制器。该系统具有水位检测、水位高度LCD显示、低水位高水位报警以及自动加水等功能。
本设计过程中主要采用了传感技术、单片机技术、光报警技术以及弱电控制强电的技术。本设计传感器使用了超声波模块，并且详细阐述了超声波测距测的原理，给出了系统构成框图。此系统具有易控制、工作可靠、测量精度高的优点，可实时监控液位。并采用52单片机系统控制整个电路的信号处理以及采用光电耦合和继电器来实现弱电控制强电来实现加水系统的自动控制。它能自动完成水位检测、光报警、上水停水的全部工作循环，保证液面高度始终处于较理想的范围内，它结构简单，制造成本低，灵敏度高，节约能源显著，是用于各种高层液体储存的理想设备。

示意图：



Altium Designer画的原理图和PCB图如下：
 

超声波水位控制器元件清单
1)    9*15万用板                                  1
2)    AT89C51单片机                            1
3)    超声波探头                                     0
4)    40脚IC座                                    1
5)    4脚排针                                         0
6)    杜邦线4根                                        0
7)    继电器*2                                        0
8)    LCD1602液晶                               1
9)    103电位器                                     0
10)    16脚IC座                                0
11)    16脚排针                                   1
12)    蜂鸣器                                         0
13)    8550三极管*3                           0
14)    1k电阻*8                                    0
15)    10k电阻                                        0
16)    10uf电容                                      0
17)    30pf电容*2                                 0
18)    12M晶振                                      1
19)    3mmLED（红、绿各2个，黄1个）       0
20)    轻触按键*4                                 1
21)    自锁开关                                       1
22)    DC电源插口                                1
23)    USB电源线（电池盒）
24)    直流水泵*2（根据客户自选）

单片机程序源码如下:

  2. /***************************************************************
  3.         名称：基于51单片机的超声波水位监测报警系统
  4.         单片机型号：AT89C51
  5.         单片机设置：时钟12T，晶体12MHZ
  6.         注：修改增加水泵控制和排水控制，即双继电器
  7. ***************************************************************/

  9. #include
  10. #include                 // 包含循环移位:_cror_
  11. #include "main.h"     
  12. //----------------------------------------------------------------------

  14. uchar code TabNumASCII[10] =    {'0','1','2','3','4','5','6','7','8','9'};

  16. bool        g_flag = isNo;                //用于标记超时（65.536ms）           
  17. bool        g_flag05s = isNo;        //用于标记0.52秒  
  18. uchar         ucCount = 0;                        //用于计数0.52秒     
  19.    
  20. uint        uiH = 80;                        //设定的最高报警水位 H
  21. uint        uiL = 30;                        //设定的最低报警水位 L
  22. uint        uiD = 100;                         //检测探头到水库底部的距离 D

  24. bool        g_flagSwitch = isNo;                //控制阀门连续开启间隔延时(保护)标志
  25. bool        g_flagBeepTimer = isNo;        //定时提醒标志
  26.                

  28. //-----------------------------------------------------------------------
  29. // 延时10us
  30. void delay10us(void)                //@12MHz
  31. {
  32.         unsigned char i;

  34.         _nop_();
  35.         i = 2;
  36.         while (--i);
  37. }

  39. // 延时100us
  40. void delay100us(void)                //@12MHz
  41. {
  42.         uchar i;

  44.         _nop_();
  45.         i = 47;
  46.         while (--i);
  47. }

  49. // 延时125us
  50. void delay125us(void)                //@12MHz
  51. {
  52.         unsigned char i;
  53.         i = 60;
  54.         while (--i);
  55. }

  57. // 延时5ms
  58. void delay5ms(void)                //@12.000MHz
  59. {
  60.         unsigned char i, j;

  62.         i = 10;
  63.         j = 183;
  64.         do
  65.         {
  66.                 while (--j);
  67.         } while (--i);
  68. }

  70. // 延时500ms
  71. void delay500ms(void)                //@12MHz
  72. {
  73.         unsigned char i, j, k;

  75.         _nop_();
  76.         i = 4;
  77.         j = 205;
  78.         k = 187;
  79.         do
  80.         {
  81.                 do
  82.                 {
  83.                         while (--k);
  84.                 } while (--j);
  85.         } while (--i);
  86. }

  88. //-----------------------------------------------------------------------
  89. //初始化IO端口                        
  90. void initIO(void)                                       
  91. {
  92.         P0 = 0xff;
  93.         P1 = 0xff;
  94.         P2 = 0xff;
  95.         P3 = 0xff;
  96. }

  98. // 初始化定时器0，定时器时钟12T模式 模式1，16位 @12.000MHz
  99. void initTimer0(void)               
  100. {
  101.         TMOD &= 0xF0;                //设置定时器模式
  102.         TMOD |= 0x01;                //设置定时器模式
  103.         TL0 = 0;                                //定时器初值清零
  104.         TH0 = 0;                                //定时器初值清零
  105.         //TR0 = 1;                           //开定时器0
  106.     ET0 = 1;                          //开定时器0中断
  107.     EA = 1;                             //开总中断            
  108.         
  109. }

  111. // 初始化定时器1，定时器时钟12T模式 模式1，16位 @12.000MHz
  112. void initTimer1(void)                //50毫秒@12.000MHz
  113. {        
  114.         TMOD &= 0x0F;                //设置定时器模式
  115.         TMOD |= 0x10;                //设置定时器模式
  116.         TL1 = 0xB0;                //设置定时初值
  117.         TH1 = 0x3C;                //设置定时初值        
  118.         TR1 = 1;                //定时器1开始计时
  119.         ET1 = 1;          //开定时器0中断
  120. }

  122. //-----------------------------------------------------------------------
  123. //定时器0中断
  124. void zd0(void) interrupt 1                  
  125. {
  126.         
  127.         g_flag = isYes;                                                        //中断溢出标志,g_flag = isYes超过测距范围
  128.         if(++ucCount >= 8)
  129.         {
  130.                 ucCount = 0;
  131.                 g_flag05s = isYes;                                        //g_flag05s = isYes定时0.52秒到，用于测量周期延时
  132.         }
  133.         TL0 = 0;                //设置定时初值
  134.         TH0 = 0;                //设置定时初值
  135.         
  136. }


  139. //定时器1中断 定时50ms
  140. void tm1_isr() interrupt 3 using 1
  141. {
  142.         static uchar count = DATA_switchTime;        //50ms的200倍 = 10S
  143.         static uchar uiCount = 1200;                                //                        = 1分钟               
  144.         static uint uiCount_BeepTimer = DATA_BeepTimer;

  146.         TL1 = 0xB0;                //设置定时初值
  147.         TH1 = 0x3C;                //设置定时初值

  149.         if (g_flagSwitch == isNo)
  150.         {
  151.                 if (count-- == 0)               //50ms * 200 -> 10s
  152.                 {
  153.                         count = DATA_switchTime;
  154.                         g_flagSwitch = isYes;
  155.                         // TR1 = 0;
  156.                 }
  157.         }        
  158.         
  159.         if(g_flagBeepTimer == isNo)
  160.         {
  161.                 if (uiCount-- == 0)               //= 1分钟
  162.                 {
  163.                         uiCount = 1200;
  164.                         if(uiCount_BeepTimer-- == 0)
  165.                         {
  166.                                 uiCount_BeepTimer = DATA_BeepTimer;
  167.                                 g_flagBeepTimer = isYes;
  168.                                 // TR1 = 0;
  169.                         }                        
  170.                         
  171.                 }

  173.         }
  174. }

  176. //-----------------------------------------------





  182. //外部中断1
  183. void exint1() interrupt 2
  184. {
  185.     EX1 = 0;                         //关闭当前中断
  186.         TR0 = 0;                           //关闭时器0
  187.         
  188. }
  189. //-----------------------------------------------------------------------
  190.   
  191. //读LCD忙状态并等待忙状态结束
  192. void LCD_waitNotBusy(void)
  193. {
  194.         IO_LCD_Data = 0xFF;
  195.         io_LCD_RS = 0;
  196.         io_LCD_RW = 1;
  197.         io_LCD_E = 0;
  198.         _nop_();
  199.         _nop_();
  200.         io_LCD_E = 1;
  201.         while(IO_LCD_Data & 0x80); //检测如果是忙信号，一直等到不忙
  202. }

  204. //给LCD写指令
  205. void LCDWriteCommand(uchar command,bool ifReadBusy) //ifReadBusy = 1 时先进行忙检测
  206. {
  207.         if (ifReadBusy == isReadBusy) LCD_waitNotBusy(); //根据需要检测忙
  208.         IO_LCD_Data = command;
  209.         io_LCD_RS = 0;
  210.         io_LCD_RW = 0;        
  211.         io_LCD_E = 0;
  212.         _nop_();
  213.         _nop_();
  214.         io_LCD_E = 1;        
  215. }

  217. //给LCD写数据
  218. void LCDWriteData(uchar dat)
  219. {
  220.         LCD_waitNotBusy(); //等到不忙
  221.         IO_LCD_Data = dat;
  222.         io_LCD_RS = 1;
  223.         io_LCD_RW = 0;
  224.         io_LCD_E = 0;
  225.         _nop_();
  226.         _nop_();
  227.         io_LCD_E = 1;
  228. }




  233. // 初始化LCD1602液晶显示屏
  234. void initLCD1602(void)
  235. {
  236.         uchar        i;        
  237.         IO_LCD_Data = 0;                                                                // 数据端口清零
  238.         for(i = 0; i < 3; i++)                                                // 设置三次显示模式
  239.         {
  240.                 LCDWriteCommand(0x38,isNotReadBusy);        // 不检测忙信号
  241.                 delay5ms();
  242.         }
  243.         
  244.         LCDWriteCommand(0x38,isReadBusy); // 设置显示模式,检测忙信号
  245.         LCDWriteCommand(0x08,isReadBusy); // 关闭显示
  246.         LCDWriteCommand(0x01,isReadBusy); // 显示清屏
  247.         LCDWriteCommand(0x06,isReadBusy); // 显示光标移动设置
  248.         LCDWriteCommand(0x0F,isReadBusy); // 显示开及光标设置
  249. }



  253. //按指定位置显示一个字符
  254. void putOneCharToLCD1602(uchar line, uchar position, uchar ucData)
  255. {

  257.         line &= DATA_LineMax;
  258.         position &= DATA_PositionMax;
  259.         if (line == DATA_LineTow) position |= 0x40;                         //当要显示第二行时地址码+0x40;
  260.         position |= 0x80;                                                                         //设置两行显示格式 D7 = 1；
  261.         LCDWriteCommand(position, isReadBusy);                         //发送命令 设置字符地址
  262.         LCDWriteData(ucData);                                                                  //写入字符的数据        
  263. }

  265. //按指定位置显示一串字符
  266. void putLineCharsToLCD1602(uchar line, uchar position, uchar count, uchar code *ucData)
  267. {
  268.         uchar i;
  269.         for(i = 0; i < count; i++)                                                        //连续显示单个字符
  270.         {
  271.                 putOneCharToLCD1602(line, position + i, ucData);        
  272.         }
  273. }


  276. //按指定位置连续显示三个字符（三位数字）
  277. void        putThreeCharToLCD1602(uchar line, uchar position, uint uiNumber)
  278. {
  279.         uiNumber %= 1000;
  280.         putOneCharToLCD1602(line, position, TabNumASCII[uiNumber / 100]);
  281.         putOneCharToLCD1602(line, ++position, TabNumASCII[uiNumber % 100 / 10]);
  282.         putOneCharToLCD1602(line, ++position, TabNumASCII[uiNumber % 100 % 10]);        
  283.         
  284. }
  285.         


  288. // 按键检测子程序，有键按下返回键端口数据，无键返回0
  289. uchar GetKey(void)
  290. {        
  291.     uchar KeyTemp = (IO_KEY | DATA_KEY_ORL);                //获取按键端口数据        
  292.         
  293.         if( KeyTemp != DATA_KEY_Null )                                // 如果不为空
  294.         {
  295.                 uchar CountTemp = 0;
  296.                 do
  297.                 {
  298.                         delay125us();
  299.                         if(KeyTemp != (IO_KEY | DATA_KEY_ORL)) return 0;        //在延时期间检测键，如果不稳定保持则退出        
  300.                         
  301.                 } while(++CountTemp > Data_Key20msCountMax);                                 // 延时20ms去抖动
  302.                
  303.                 while((IO_KEY | DATA_KEY_ORL) != DATA_KEY_Null);         //等键释放               
  304.                
  305.                 return KeyTemp;        // 有键按下返回键端口数据
  306.         }
  307.         
  308.         return 0;        // 无有效键返回0
  309. }



  313. //加一
  314. uchar  INC_Number(uchar Number, uchar Min, uchar Max)
  315. {
  316.         if(Number >= Max) return Min; else return (++ Number);
  317.                
  318. }

  320. //减一
  321. uchar  DEC_Number(uchar Number, uchar Min, uchar Max)
  322. {
  323.         if(Number <= Min) return Max; else return (-- Number);
  324.                
  325. }

  327. // 检测到有按键后 这里执行按键任务                        
  328. void execute_key_task(uchar ucKeyValue)        
  329. {
  330.         uchar state = 0;                                                //定义调整数据的状态变量
  331.         uchar keyValue = 0;                                        //定义键值的临时变量
  332.         
  333.         if(ucKeyValue != DATA_KEY_Set) return;        //不是设置键退出
  334.         
  335.         //是设置键继续-----------------------------------------------------
  336.         
  337.         putLineCharsToLCD1602(lineTow, 8, 8, "C:000cm ");        //清零显示当前距离CURRENT               
  338.         putThreeCharToLCD1602(lineOne, 8 + 2, uiD);                //光标调整到调整总距离（检测探头到水库底部的距离“D：000cm”）        
  339.         
  340.         while(1)
  341.         {
  342.                 keyValue = GetKey();        
  343.                 if(keyValue == 0) continue;
  344.                
  345.                 switch(keyValue)
  346.                 {
  347.                         case DATA_KEY_Set:
  348.                         {
  349.                                 // 如果按的是设置键，顺序设置总距离D——高水位H——低水位L——退出
  350.                                 switch(state)
  351.                                 {
  352.                                         case 0:                        // 如果是设置总距离状态，改变为设置高水位状态，并显示高水位，实现移动光标到高水位后面
  353.                                         {
  354.                                                 state = 1;                                                
  355.                                                 putThreeCharToLCD1602(lineOne, 0 + 2, uiH);                                                
  356.                                         }
  357.                                         break;
  358.                                         case 1:
  359.                                         {
  360.                                                 uchar tempMax = uiD - DATA_uiD_Min;
  361.                                                 if(tempMax < 2 + 2) tempMax = 2 + 2;                                                                                       
  362.                                                 if(uiH > tempMax)
  363.                                                 {
  364.                                                         uiH = tempMax;
  365.                                                         putThreeCharToLCD1602(lineOne, 0 + 2, uiH);
  366.                                                 }
  367.                                                 else if(uiH < 2 + 2)
  368.                                                 {
  369.                                                         uiH = 2 + 2;        
  370.                                                         putThreeCharToLCD1602(lineOne, 0 + 2, uiH);
  371.                                                 }                                                        
  372.                                                 state = 2;
  373.                                                 putThreeCharToLCD1602(lineTow, 0 + 2, uiL);
  374.                                         }
  375.                                         break;
  376.                                         case 2:
  377.                                         {
  378.                                                 if(uiL > uiH - 2)
  379.                                                 {
  380.                                                         uiL = uiH - 2;
  381.                                                         putThreeCharToLCD1602(lineTow, 0 + 2, uiL);
  382.                                                 }
  383.                                                 return;        
  384.                                                 
  385.                                         }
  386.                                         break;
  387.                                 }
  388.                                 
  389.                         }
  390.                         break;
  391.                         // 如果按的是增加键，改变相应数据并显示
  392.                         case DATA_KEY_INC:
  393.                         {
  394.                                 switch(state)
  395.                                 {
  396.                                         case 0:
  397.                                         {
  398.                                                 uiD = INC_Number(uiD, DATA_uiD_Min, DATA_uiD_Max);
  399.                                                 putThreeCharToLCD1602(lineOne, 8 + 2, uiD);                                                        
  400.                                         }
  401.                                         break;
  402.                                         case 1:
  403.                                         {
  404.                                                 uchar tempMax = uiD - DATA_uiD_Min;
  405.                                                 if(tempMax < 2 + 2) tempMax = 2 + 2;
  406.                                                 uiH = INC_Number(uiH, 2, tempMax);                                                
  407.                                                 putThreeCharToLCD1602(lineOne, 0 + 2, uiH);        
  408.                                         }
  409.                                         break;
  410.                                         case 2:
  411.                                         {
  412.                                                 uiL = INC_Number(uiL, 0, uiH - 2);        
  413.                                                 putThreeCharToLCD1602(lineTow, 0 + 2, uiL);        
  414.                                         }
  415.                                         break;
  416.                                 }
  417.                                 
  418.                         }
  419.                         break;
  420.                         // 如果按的是减少键，改变相应数据并显示
  421.                         case DATA_KEY_DEC:
  422.                         {
  423.                                 switch(state)
  424.                                 {
  425.                                         case 0:
  426.                                         {
  427.                                                 uiD = DEC_Number(uiD, DATA_uiD_Min, DATA_uiD_Max);                                       
  428.                                                 putThreeCharToLCD1602(lineOne, 8 + 2, uiD);
  429.                                         }
  430.                                         break;
  431.                                         case 1:
  432.                                         {
  433.                                                 uchar tempMax = uiD - DATA_uiD_Min;
  434.                                                 if(tempMax < 2 + 2) tempMax = 2 + 2;
  435.                                                 uiH = DEC_Number(uiH, 2, tempMax);                                                
  436.                                                 putThreeCharToLCD1602(lineOne, 0 + 2, uiH);        

  438.                                         }
  439.                                         break;
  440.                                         case 2:
  441.                                         {
  442.                                                 uiL = DEC_Number(uiL, 0, uiH - 2);        
  443.                                                 putThreeCharToLCD1602(lineTow, 0 + 2, uiL);        

  445.                                         }
  446.                                         break;
  447.                                 }
  448.                                 
  449.                         }
  450.                         break;
  451.                         
  452.                 }
  453.                
  454.         }
  455.         
  456. }



  460. // 蜂鸣器        
  461. void        buzzerCall(void)
  462. {
  463.         uchar        i;
  464.         
  465.                 for(i = 0; i < 90; i++)
  466.                 {
  467.                         io_Buzzer = 0;
  468.                         delay100us();
  469.                         io_Buzzer = 1;
  470.                         delay100us();
  471.                         delay100us();               
  472.                 }
  473.                 delay100us();        
  474.                 delay100us();        
  475. }

  477. //计算水位
  478. bool CalculatedWaterLevel(void)
  479. {
  480.         uchar         i = 8 + 2;                                        //当前水位的数字在LCD屏显示的起点位置
  481.         uint          uiTime;                                                //声波传播时间
  482.         ulong         ulDis;                                                //实时测量到距离        
  483.         
  484.         uiTime = TH0 << 8 | TL0;        
  485.         ulDis = (uiTime * 3.40) / 200;             //计算当前测量的距离，单位cm
  486.         
  487.         TH0 = 0;
  488.         TL0 = 0;        
  489.         
  490.         if((ulDis > uiD) || (g_flag == isYes ))         // ulDis > uiD 超出测量范围；g_flag == isYes超时；
  491.         {         
  492.                 g_flag = isNo;               
  493.                 TR0 = 0;
  494.                 putLineCharsToLCD1602(lineTow, i, 3, "Err");        // 显示Err                 
  495.                
  496.                 //阀门动作：               
  497.                 // if(g_flagSwitch == isYes)
  498.                 // {               
  499.                         // io_Control_Inlet = isio_Control_Inlet_OFF;               
  500.                         // io_Control_Outlet = isio_Control_Outlet_ON;
  501.                         // g_flagSwitch = isNo;
  502.                 // }               
  503.                
  504.                 //指示灯：
  505.                 ioLed_Red = ! ioLed_Red;                                                        // 三个灯同时快速闪亮
  506.                 ioLed_Green = ! ioLed_Green;
  507.                 ioLed_Yellow = ! ioLed_Yellow;
  508.                
  509.                 // 蜂鸣器叫：        
  510.                 if(buzzerCallFlag == isCall)
  511.                 {
  512.                         buzzerCall();                                        // 蜂鸣器叫        
  513.                 }
  514.                
  515.                 return isNo;                                                                        // 返回错误信息
  516.         }
  517.         else
  518.         {
  519.                 ulDis = uiD - ulDis;                                        // 当前水位C = 总距离 - 当前检测到的距离
  520.                
  521.                 if(ulDis > uiH)                                                // 如果水位超高
  522.                 {
  523.                         
  524.                         //阀门动作：
  525.                         io_Control_Inlet = isio_Control_Inlet_OFF;
  526.                         io_Control_Outlet = isio_Control_Outlet_ON;        
  527.                         g_flagSwitch = isNo;
  528.                         
  529.                         //指示灯：
  530.                         ioLed_Red = ! ioLed_Red;                        // 红灯闪
  531.                         ioLed_Green = isLedOFF;               
  532.                         ioLed_Yellow = isLedOFF;                                
  533.                         // 蜂鸣器叫：
  534.                         if(ulDis - uiH > (uiD - uiH) / DATA_alarmCoefficient) //当“当前水位”超出最高水位“ （（“总高度减高水位）除以2的值”）时报警
  535.                         {
  536.                                 buzzerCall();                                        // 蜂鸣器叫
  537.                         }
  538.                         
  539.                 }
  540.                 else if(ulDis < uiL)                                        // 如果水位超低
  541.                 {
  542.                         //阀门动作：        
  543.                         if(g_flagSwitch == isYes)
  544.                         {               
  545.                                 io_Control_Outlet = isio_Control_Outlet_OFF;        
  546.                                 io_Control_Inlet = isio_Control_Inlet_ON;        
  547.                                 g_flagSwitch = isNo;
  548.                         }        
  549.                         
  550.                         //指示灯：
  551.                         ioLed_Red = isLedOFF;
  552.                         ioLed_Green = isLedOFF;
  553.                         ioLed_Yellow = ! ioLed_Yellow;        //黄灯闪
  554.                         // 蜂鸣器叫：                                                
  555.                         if( uiL - ulDis > uiL / DATA_alarmCoefficient)//uiL / 2 当“当前水位”低于“低水位” “低水位除以2的值”时报警
  556.                         {
  557.                                 buzzerCall();                                        // 蜂鸣器叫
  558.                         }
  559.                         
  560.                         
  561.                 }
  562.                 else                                                                // 水位在正常范围
  563.                 {        
  564.                         ioLed_Red = isLedOFF;
  565.                         ioLed_Green = ! ioLed_Green;
  566.                         ioLed_Yellow = isLedOFF;        
  567.                         
  568.                 }
  569.                 putThreeCharToLCD1602(lineTow, i, ulDis);
  570.                 return isYes;        
  571.                
  572.         }
  573.         return isYes;
  574. }

  576. void main(void)
  577. {
  578.     initIO();            //初始化IO端口   
  579.     delay500ms();         //启动延时，给器件进入正常工作状态留够时间   
  580.     initLCD1602();     //LCD初始化   
  581.     putLineCharsToLCD1602(lineOne, 8, 8, "D:000cm ");    //显示distance （总）距离（检测探头到水库底部的距离）D
  582.     putThreeCharToLCD1602(lineOne, 8 + 2, uiD);        //显示三位数值
  583.     putLineCharsToLCD1602(lineOne, 0, 8, "H:000cm ");    //显示设定的最高报警水位H
  584.     putThreeCharToLCD1602(lineOne, 0 + 2, uiH);        //显示三位数值
  585.     putLineCharsToLCD1602(lineTow, 0, 8, "L:000cm ");    //显示设定的最低报警水位L
  586.     putThreeCharToLCD1602(lineTow, 0 + 2, uiL);        //显示三位数值
  587.     putLineCharsToLCD1602(lineTow, 8, 8, "C:000cm ");    //显示当前CURRENT水位C
  588.    
  589.     initTimer0();        //初始化定时器0
  590.     initTimer1();
  591.    
  592.     //阀门动作：初始先排水
  593.     io_Control_Inlet = isio_Control_Inlet_OFF;   
  594.     io_Control_Outlet = isio_Control_Outlet_ON;
  595.     g_flagSwitch = isNo;   
  596.    
  597.     while(1)
  598.     {
  599.         io_US_TX = 1;                    //启动超声波模块信号
  600.         delay10us();
  601.         io_US_TX = 0;
  602.         
  603.         while(io_US_RX == 0);            //等待计时开始
  604.         TR0 = 1;                            //开启定时器0，计时开始   
  605.         IT1 = 1;                         //设置外中断INT1输入信号模式(1:Falling only仅下降沿有效 0:Low level低电平有效)
  606.         EX1 = 1;                        //使能外中断INT1        
  607.         
  608.         while(EX1 == 1 && g_flag == isNo)//等待中断或超时退出   
  609.         {
  610.             uchar ucKeyValue = GetKey();                    //在等待中检测按键
  611.             if(ucKeyValue) execute_key_task(ucKeyValue);    //如果有键按下则执行按键任务   
  612.         }
  613.         
  614.         if(CalculatedWaterLevel() == isNo) continue;        //计算水位，如果超出范围返回isNo并重新循环        
  615.         
  616.         TR0 = 0;        //暂时关闭定时器0
  617.         //清零定时器和计数变量以及标志
  618.         TL0 = 0;        
  619.         TH0 = 0;        
  620.         g_flag = isNo;
  621.         ucCount = 0;
  622.         g_flag05s = isNo;
  623.         
  624.         TR0 = 1;        //打开定时器0                    
  625.         while(g_flag05s == isNo)        //延时0.52秒，以防止此期间返回的超声波产生错误信息，并使显示变化放慢，保证视觉效果
  626.         {            
  627.             uchar ucKeyValue = GetKey();
  628.             if(ucKeyValue)
  629.             {
  630.                 if(ucKeyValue == DATA_KEY_DEC)
  631.                 {
  632.                     g_flagBeepTimer = isNo;//用减小按键取消报警标志
  633.                 }

  635.                 execute_key_task(ucKeyValue);    //如果有键按下则执行按键任务   
  636.             }               

  638.         }   
  639.         TR0 = 0;        //暂时关闭定时器0
  640.         //清零定时器和复位标志
  641.         TL0 = 0;   
  642.         TH0 = 0;   
  643.         g_flag = isNo;        
  644.         
  645.         //-----------------------------------
  646.         //水箱清洗提示：
  647.         


复制代码

作者： 小羡， 来源：面包板社区

链接： https://mbb.eet-china.com/blog/uid-me-4026945.html

版权声明：本文为博主原创，未经本人允许，禁止转载！

写原创有奖励！2024面包板原创奖励正在进行中

文章评论（0条评论）

登录后参与讨论
小羡
文章：16 阅读：17954 评论：0 赞：119
好友 私信 个人主页
EE直播间
更多
在线研讨会
更多
我要评论
0
8
关闭 站长推荐上一条 /2 下一条
  • 帖子
  • 博文