找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 23710|回复: 18
收起左侧

单片机全自动洗衣机程序+仿真+原理图设计调试与分析

  [复制链接]
ID:438351 发表于 2018-12-3 21:34 | 显示全部楼层 |阅读模式
0.png

学习电机驱动、继电器的原理及编程方法。
学习键盘的原理及编程方法。
掌握51单片机定时器与中断的使用。

  2、要求
  • 请参照主要技术指标和说明完成本次设计。
  • 画出硬件连接电路图,说明各个控制信号的作用。
  • 画出程序流程图,编写程序,硬件连接调试,直至正确。
  • 编写设计文档。
三、主要技术指标和说明
● 由独立式按键确定功能键,包括“标准”、“经济”、“单独”、“排水”、“强洗”、“弱洗”等等;
● 排水与进水由时间控制;
● 开机默认状态为标准方式、强洗;
● 在洗涤和漂洗过程中,电动机正转一次,反转一次,连续运行;
● 在进水和脱水过程中,相应指示灯亮,继电器吸合;
● 当在执行某个步骤时,只有“K3”键有效,按下暂停,再按下恢复运行。

摘要

全自动洗衣机就是将洗衣的全过程(泡浸-洗涤-漂洗-脱水)预先设定好N个程序,洗衣时选择其中一个程序,打开水龙头和启动洗衣机开关后洗衣的全过程就会自动完成,洗衣完成时由蜂鸣器发出响声。洗衣机的标准洗衣程序是:洗涤——脱水——脱水——漂洗——脱水——漂洗——脱水。经济洗衣程序少一次漂洗和脱水过程。
洗衣机控制器由单片机作为控制器的核心所构成,该控制器具有以下特点:
(1)具有较强的抗干扰能力,当受到外部强干扰,程序出错时,可以自动使系统复位重新执行程序。
(2)采用无噪声、无电磁干扰的双向晶闸管作为控制元件,控制电磁阀和电机。
(3)具有欠压和过压保护,欠压时,控制器不工作;超压时,保护电路起作用。
(4)具有瞬间掉电保护功能,电源短时间停电后,电压恢复时,能够维持原运行程序的工作状态并继续完成洗衣程序。
(5)各种操作和洗衣机的运行状态均用LED显示.
一、设计任务与要求
利用51单片机模拟全自动智能洗衣机。
  • 按键功能要求
  • 通过“K1”键步进改变“标准]经济、单独、排水”四种方式,执行相应的程序。对应指示灯亮。
  • 通过“K2”键步进改变“强洗、弱洗”两种方式,执行相应的程序,对应指示灯亮。
  • 通过“K3”键控制洗衣机运行、暂停和解除报警功能。
  • 方式功能选择要求
一般洗衣机的步骤为:洗涤,漂洗,脱水,当处于某种状态时,对应的指示灯以0.7S周期闪烁,当洗衣机在洗涤过程中,洗涤指示灯闪烁。可以通过方式选择设定具体的运行过程。
  • 标准方式:进水—> 洗涤 —> 排水 —> 进水 —> 漂洗 —> 排水 —>进水 —> 漂洗—> 排水 —> 脱水。
  • 经济方式:进水 —> 洗涤 —> 排水 —> 进水 —> 漂洗 —> 排水 —> 脱水。
  • 单独方式:进水 —> 洗涤。
  • 排水方式:排水 —> 脱水。
  • 强洗即电动机转速快,弱洗即电动机转速慢。
  • 整机功能要求
  • 开机默认状态为标准方式、强洗。
  • 在洗涤和漂洗过程中,电动机正转一次,反转一次,连续运行。
  • 在进水和脱水过程中,相应的指示灯亮,继电器吸合。
  • 当执行某个步骤时,只有“K3”键有效,按下暂停,再按恢复运行。
  • 方案设计与论证
全自动洗衣机的实现方案组成框图如图一所示。它主要有电源、单片机最小系统、开关检测电路、控制按键输入电路和LED指示电路、继电器和电动机电路。
  • 硬件电路设计

图二

  • 电动机驱动模块电路设计
电动机驱动采用LD298电动机驱动芯片,单片机P25、P24与L298的IN1、IN2分别对应相连,ENA直接接VCC,后面所加4个二极管VD3到VD6起连续作用。电动机驱动电路原理图如图二所示。
  • 电源模块电路设计
电动机驱动芯片的电源VCC和VS之间通过0欧的电阻R20进行隔离后,对LD298进行供电。
  • 控制按键
如图二所示,K3键接到单片机的外部中断0,通过中断实现运行、暂停、继续运行的控制功能,当K3键第一次按下时(num2=1)正常运行,当K3键第二次按下时(num2=2)暂停运行。
  • 进水阀和排水阀控制继电器
如图二所示,单片机的P23用来控制排水阀继电器,P22用来控制进水阀继电器,P22和P23对应输出为0时对应的阀打开,输出为1时对应的阀关闭。

软件设计

1)流程图

主程序流程图如图三所示。
  • 程序
程序附在最后

图三

  • 调试与分析

1、软件调试:

写程序代码时应先搭建好硬件电路,然后根据硬件电路写程序代码。在调试程序过程中,先保证程序能够运行无错误,然后在烧到实物中观察结果。

2、硬件调试:

硬件电路设计与软件设计完成后,将程序烧写到单片机中,观察运行结果是否符合要求。如果不符合设计要求,应先检查硬件是否能正常工作,如用实验板自带的正确代码检测硬件电路;然后根据设计要求到程序代码中分模块进行调试,比如该设计需用到液晶、矩阵键盘、定时器、独立键盘、中断和LED灯等,如果测试过程中液晶模块不能正常显示或者显示乱码,应将液晶模块单独分离出来进行测试,其他模块亦是如此。程序调试完成后,应在硬件电路上反复运行,以确保程序和硬件电路的稳定性。

  • 总结

这次单片机程序设计专周,我感觉收获了很多,尤其是在提升自身的工作和自主学习能力方面。我在大二上学期就开始在实验室自学单片机,但是因为是自学,自觉性就很差,而且自学也是一件比较难的事,学习过程中一直都是学习和模仿别人的代码,看着别人写出来的程序代码,总觉得都能看懂,所以自己基本上没有自己构思写程序代码,

唯一做过一次全自动洗衣机也是看着别人写的源程序代码,不停的修修改改。

这次刚拿到设计项目时,本以为不难,一开始还信心满满,然而开始做就感觉有些茫然了,尤其是项目中还有些知识是我还没学过的,比如液晶。所以我们组就必须得先把液晶学了,把需要学习的模块学完后,先是毫无头绪的写主程序,整个过程举步维艰,然后我们去学习了别人的设计方法,开始分工和分模块进行。组内分组搭建硬件电路,和写程序,先把电路搭建好,再写程序。写程序的过程中,我们是把程序分成几个小模块:液晶显示模块、键盘输入模块、抢答模块,然后每个模块写成子程序,在主程序中只需调用各个子程序即可。

在程序调试过程中,也遇到各种问题,但都逐个解决了。在整个设计过程中,我学到了许多课堂上老师无法传授的知识,也真正地做出了一件自己的产品。


单片机源程序如下:


  1.         #include<reg52.h>
  2.         #define uchar unsigned char
  3.         #define uint unsigned int
  4.         uchar num=0,num1=0,num2=0,num3=0,num4=0,num5=0,num6=0,flag=0,flag1=0,flag4=0,flag5=0,circle=0;
  5.         sbit ledbiaozhun=P1^0; //LED指示灯
  6.         sbit ledjingji  =P1^1;
  7.         sbit leddandu   =P1^2;
  8.         sbit ledpaishui =P1^3;
  9.         sbit ledqiangxi =P1^4;
  10.         sbit ledruoxi   =P1^5;
  11.         sbit ledxidi    =P1^6;
  12.         sbit ledpiaoxi  =P1^7;
  13.         sbit ledtuoshui =P2^0;
  14.         
  15.         sbit sshuiwei   =P3^6; //水位开关
  16.         sbit sgai       =P3^7; //盖开关
  17.         sbit paishui=P2^3; //排水阀控制
  18.         sbit jinshui=P2^2; //进水阀控制
  19.         
  20.         sbit U2=P2^4;
  21.         sbit U3=P2^5;
  22.         sbit k1=P3^0;  // 步进改变"标准、经济、单独、排水"四种方式
  23.         sbit k2=P3^1;  //强洗、弱洗
  24.         sbit k3=P3^2;  //运行、暂停和解除报替功能
  25.         void init()
  26.         {
  27.                 uchar a=0,b=0,c=0;
  28.                 TMOD=0x01;                       //T0工作于方式1
  29.                 TH0=(65536-50000)/256; //定时时间50ms
  30.                 TL0=(65536-50000)%256;
  31.                 EA=1;                                   //开总中断
  32.                 ET0=1;                                   //开T0中断
  33.                 TR0=0;                                   //关闭T0
  34.                 EX0=1;                                   //开外部中断0
  35.                 IT0=1;                                   //外部中断0边沿触发方式
  36.                 U2=1;                                   //电机停转
  37.                 U3=1;
  38.                 P0=0xff;
  39.         }
  40.         void delayms(uint xms) //延时
  41.         {
  42.                 uint i,j;
  43.                 for(i=xms;i>0;i--)
  44.                         for(j=110;j>0;j--);
  45.         }
  46.         
  47.         void key()                //控制按键
  48.         {
  49.                 circle=1;
  50.                 if(k1==0)                //标准、经济、单独、排水按下
  51.                 {
  52.                         delayms(10); //延时消抖
  53.                         if(k1==0)         //再判
  54.                         {
  55.                                 num++;         //K1按下次数加1
  56.                                 if(num==4)
  57.                                         num=0;        //等于4,按下次数清0
  58.                                 while(!k1);        //等待按键释放
  59.                         }
  60.                 }
  61.                
  62.                 if(k2==0)                                //强弱选择
  63.                 {
  64.                         delayms(10);   //延时消抖
  65.                         if(k2==0)           //再判
  66.                         {
  67.                                 num1++;         //按下次数加1
  68.                                 if(num1==2)
  69.                                         num1=0;        //等于2,按下次数清0
  70.                                 while(!k2);        //等待按键释放
  71.                         }
  72.                 }
  73.         }
  74.         
  75.         void qiang()                          //强
  76.         {
  77.                 if(flag4==0)  //电机正转
  78.                 {        
  79.                         U2=0;
  80.                         U3=1;
  81.                 }
  82.         
  83.                 if(flag4==1)  //电机反转
  84.                 {
  85.                         U2=1;
  86.                         U3=0;
  87.                 }        
  88.         }
  89.         void ruo()                        //弱
  90.         {
  91.                 if(flag5==0) //电机正转
  92.                 {        
  93.                         U2=0;
  94.                         U3=1;
  95.                 }
  96.         
  97.                 if(flag5==1) //电机反转
  98.                 {
  99.                         U2=1;
  100.                         U3=0;
  101.                 }
  102.         }
  103.         
  104.         void qbiaozhun()                        //强标准
  105.         {
  106.                 /*******洗涤********/
  107.                         num=0;
  108.                         num1=0;
  109.                         ledbiaozhun=0;//标准洗LED亮
  110.                         ledqiangxi=0; //强洗LED亮
  111.                         jinshui=0;          //打开进水阀
  112.                         ledxidi=1;    //洗涤
  113.                         ledpiaoxi=1;  //漂洗LED亮
  114.                         ledtuoshui=1; //脱水LED亮
  115.                         delayms(5000);//水位监测
  116.                         jinshui=1; //关闭进水阀
  117.                         ledxidi=0;
  118.                         flag1=1;        //        
  119.                         TR0=1;            //启动定时器T0
  120.                         while(flag==0)//flag为洗涤次数标志位
  121.                         {         
  122.                                 if(flag==0&&num2==1)
  123.                                 {         
  124.                                         TR0=1;
  125.                                         flag1=1; //
  126.                                         qiang();
  127.                                 }
  128.                                 if(flag==0&&num2==2)
  129.                                 {
  130.                                         TR0=0; //关闭定时器T0
  131.                                         U2=1;  //电机停止
  132.                                         U3=1;
  133.                                 }
  134.                         };
  135.                         //漂洗
  136.                         U2=1;
  137.                         U3=1;                                       
  138.                         TR0=0;
  139.                         flag1=0;
  140.                         paishui=0; //排水
  141.                         ledtuoshui=1;
  142.                         ledpiaoxi=1;
  143.                         ledxidi=1;
  144.                         delayms(5000);
  145.                         paishui=1;        //关闭排水
  146.                         delayms(100);
  147.                         jinshui=0;        //打开进水
  148.                         delayms(5000);
  149.                         jinshui=1;         //关闭进水
  150.                         ledpiaoxi=0;
  151.                         flag1=2;
  152.                         TR0=1;
  153.                         num3=0;
  154.                         num4=0;
  155.                         while(flag==1)
  156.                         {
  157.                                 if(flag==1&&num2==1)//强漂洗
  158.                                 {         
  159.                                         TR0=1;
  160.                                         flag1=2;
  161.                                         qiang();
  162.                                 }
  163.                                 if(flag==1&&num2==2)//暂停强漂洗
  164.                                 {
  165.                                         TR0=0;
  166.                                         U2=1;
  167.                                         U3=1;
  168.                                 }
  169.                         };
  170.                         //漂洗
  171.                         U2=1;
  172.                         U3=1;
  173.                         TR0=0;
  174.                         flag1=0;
  175.                         paishui=0;
  176.                         ledtuoshui=1;
  177.                         ledpiaoxi=0;
  178.                         delayms(5000);
  179.                         paishui=1;
  180.                         delayms(100);
  181.                         jinshui=0;
  182.                         delayms(5000);
  183.                         jinshui=1;
  184.                         flag1=2;
  185.                         TR0=1;
  186.                         num3=0;
  187.                         num4=0;
  188.                         
  189.                         while(flag==2)
  190.                         {
  191.                                  if(flag==2&&num2==1)
  192.                                 {         
  193.                                         TR0=1;
  194.                                         flag1=2;
  195.                                         qiang();
  196.                                 }
  197.                                 if(flag==2&&num2==2)
  198.                                 {
  199.                                         TR0=0;
  200.                                         U2=1;
  201.                                         U3=1;
  202.                                 }
  203.                          }        ;
  204.                         //脱水
  205.                         U2=1;
  206.                         U3=1;
  207.                         TR0=0;
  208.                         flag1=0;
  209.                         paishui=0;//打开排水
  210.                         ledtuoshui=0;
  211.                         ledpiaoxi=1;
  212.                         while(sgai);
  213.                         paishui=1;
  214.                         delayms(1000);
  215.                         flag1=3;
  216.                         TR0=1;
  217.                         num3=0;
  218.                         num4=0;
  219.                         while(flag==3)
  220.                         {
  221.                                 if(flag==3&&num2==1)
  222.                                 {
  223.                                         TR0=1;
  224.                                         U2=0;
  225.                                         U3=1;
  226.                                         flag1=3;
  227.                                 }
  228.                                 if(flag==3&&num2==2)
  229.                                 {
  230.                                         TR0=0;
  231.                                         U2=1;
  232.                                         U3=1;
  233.                                 }
  234.                         };
  235.                         ledtuoshui=1;
  236.                         U2=1;
  237.                         U3=1;
  238.                         flag1=0;                        
  239.         }
  240.         
  241.         void qjingji()                        //强经济
  242.         {
  243.                 /*******洗涤********/
  244.                         num=0;
  245.                         num1=0;
  246.                         ledjingji=0;
  247.                         ledqiangxi=0;
  248.                         ledtuoshui=1;
  249.                         ledpiaoxi=1;
  250.                         ledxidi=1;
  251.                         jinshui=0;
  252.                         delayms(5000);
  253.                         jinshui=1;
  254.                         flag1=1; //控制定时器中的洗涤指示灯
  255.                         TR0=1;
  256.                         while(flag==0)
  257.                         {         
  258.                                 if(flag==0&&num2==1)
  259.                                 {         
  260.                                         TR0=1;
  261.                                         flag1=1;
  262.                                         qiang();
  263.                                 }
  264.                                 if(flag==0&&num2==2)
  265.                                 {
  266.                                         TR0=0;
  267.                                         U2=1;
  268.                                         U3=1;
  269.                                 }
  270.                         };
  271.                         
  272.                         //漂洗                                       
  273.                         TR0=0;
  274.                         U2=1;
  275.                         U3=1;
  276.                         flag1=0;
  277.                         paishui=0;
  278.                         ledjingji=0;
  279.                         ledtuoshui=1;
  280.                         ledxidi=1;
  281.                         delayms(5000);
  282.                         paishui=1;
  283.                         delayms(100);
  284.                         jinshui=0;
  285.                         delayms(5000);
  286.                         jinshui=1;
  287.                         ledpiaoxi=0;
  288.                         flag1=2;
  289.                         TR0=1;
  290.                         num3=0;
  291.                         num4=0;
  292.                         while(flag==1)
  293.                         {
  294.                                 if(flag==1&&num2==1)
  295.                                 {         
  296.                                         TR0=1;
  297.                                         flag1=2;
  298.                                         qiang();
  299.                                 }
  300.                                 if(flag==1&&num2==2)
  301.                                 {
  302.                                         TR0=0;
  303.                                         U2=1;
  304.                                         U3=1;
  305.                                 }
  306.                         };
  307.                         //脱水
  308.                         TR0=0;
  309.                         U2=1;
  310.                         U3=1;        
  311.                         flag1=0;
  312.                         paishui=0;         //打开排水
  313.                         ledjingji=0;
  314.                         ledtuoshui=0;
  315.                         ledpiaoxi=1;
  316.                         delayms(5000);
  317.                         while(sgai);
  318.                         paishui=1;
  319.                         delayms(1000);
  320.                         flag1=3;
  321.                         TR0=1;
  322.                         flag=2;
  323.                         num3=0;
  324.                         num4=0;
  325.                         while(flag==2)
  326.                         {
  327.                                 if(flag==2&&num2==1)
  328.                                 {
  329.                                         TR0=1;
  330.                                         U2=0;
  331.                                         U3=1;
  332.                                         flag1=3;
  333.                                 }
  334.                                 if(flag==2&&num2==2)
  335.                                 {
  336.                                         TR0=0;
  337.                                         U2=1;
  338.                                         U3=1;
  339.                                 }
  340.                         };
  341.                         ledtuoshui=1;
  342.                         U2=1;
  343.                         U3=1;
  344.                         flag1=0;
  345.         }
  346.         
  347.         void qdandu()               //强单独
  348.         {
  349.                 num=0;
  350.                 num1=0;
  351.                 ledqiangxi=0;
  352.                 ledxidi=0;
  353.                 leddandu=0;
  354.                 jinshui=0;
  355.                 delayms(5000);
  356.                 jinshui=1;//关闭进水阀
  357.                 flag1=1;
  358.                 TR0=1;
  359.                 while(flag==0)
  360.                 {
  361.                         if(flag==0&&num2==1)
  362.                                 {         
  363.                                         TR0=1;
  364.                                         flag1=1;
  365.                                         qiang();
  366.                                 }
  367.                                 if(flag==0&&num2==2)
  368.                                 {
  369.                                         TR0=0;
  370.                                         U2=1;
  371.                                         U3=1;
  372.                                 }
  373.                 };
  374.                 flag1=0;
  375.                 U2=1;
  376.                 U3=1;
  377.         }
  378.         
  379.         void rbiaozhun()                        //弱标准
  380.         {
  381.                 /*******洗涤********/
  382.                         num=0;
  383.                         num1=0;
  384.                         ledbiaozhun=0;
  385.                         ledruoxi=0;
  386.                         ledtuoshui=1;
  387.                         ledpiaoxi=1;        
  388.                         jinshui=0;
  389.                         delayms(5000);
  390.                         jinshui=1;
  391.                         ledxidi=0;
  392.                         flag1=1;               
  393.                         TR0=1;        
  394.                         while(flag==0)
  395.                         {         
  396.                                 if(flag==0&&num2==1)
  397.                                 {         
  398.                                         TR0=1;
  399.                                         flag1=1;
  400.                                         ruo();
  401.                                 }
  402.                                 if(flag==0&&num2==2)
  403.                                 {
  404.                                         TR0=0;
  405.                                         U2=1;
  406.                                         U3=1;
  407.                                 }
  408.                         };
  409.                         //漂洗
  410.                         U2=1;
  411.                         U3=1;                                       
  412.                         TR0=0;
  413.                         flag1=0;
  414.                         paishui=0;
  415.                         ledtuoshui=1;
  416.                         ledxidi=1;
  417.                         delayms(5000);
  418.                         paishui=1;
  419.                         delayms(100);
  420.                         jinshui=0;
  421.                         delayms(5000);
  422.                         jinshui=1;
  423.                         ledpiaoxi=0;
  424.                         flag1=2;
  425.                         TR0=1;
  426.                         num3=0;
  427.                         num4=0;
  428.                         while(flag==1)
  429.                         {
  430.                                 if(flag==1&&num2==1)
  431.                                 {         
  432.                                         TR0=1;
  433.                                         flag1=2;
  434.                                         ruo();
  435.                                 }
  436.                                 if(flag==1&&num2==2)
  437.                                 {
  438.                                         TR0=0;
  439.                                         U2=1;
  440.                                         U3=1;
  441.                                 }
  442.                         };
  443.                         //漂洗
  444.                         U2=1;
  445.                         U3=1;
  446.                         TR0=0;
  447.                         flag1=0;
  448.                         paishui=0;
  449.                         ledtuoshui=1;
  450.                         ledpiaoxi=0;
  451.                         delayms(5000);
  452.                         paishui=1;
  453.                         delayms(100);
  454.                         jinshui=0;
  455.                         delayms(5000);
  456.                         jinshui=1;
  457.                         flag1=2;
  458.                         TR0=1;
  459.                         num3=0;
  460.                         num4=0;         
  461.                         while(flag==2)
  462.                         {
  463.                                  if(flag==2&&num2==1)
  464.                                 {         
  465.                                         TR0=1;
  466.                                         flag1=2;
  467.                                         ruo();
  468.                                 }
  469.                                 if(flag==2&&num2==2)
  470.                                 {
  471.                                         TR0=0;
  472.                                         U2=1;
  473.                                         U3=1;
  474.                                 }
  475.                          }
  476.                         //脱水
  477.                         U2=1;
  478.                         U3=1;
  479.                         TR0=0;
  480.                         flag1=0;
  481.                         paishui=0;
  482.                         delayms(5000);
  483.                         ledtuoshui=0;
  484.                         ledpiaoxi=1;
  485.                         while(sgai);
  486.                         paishui=1;
  487.                         delayms(1000);
  488.                         flag1=3;
  489.                         TR0=1;
  490.                         num3=0;
  491.                         num4=0;
  492.                         while(flag==3)
  493.                         {
  494.                                 if(flag==3&&num2==1)
  495.                                 {
  496.                                         TR0=1;
  497.                                         U2=0;
  498.                                         U3=1;
  499.                                         flag1=3;
  500.                                 }
  501.                                 if(flag==3&&num2==2)
  502.                                 {
  503.                                         TR0=0;
  504.                                         U2=1;
  505.                                         U3=1;
  506.                                 }
  507.                         };
  508.                         ledtuoshui=1;
  509.                         U2=1;
  510.                         U3=1;
  511.                         flag1=0;
  512.         }
  513.         
  514.         void rjingji()                        //弱经济
  515.         {
  516.                 /*******洗涤********/
  517.                         num=0;
  518.                         num1=0;
  519.                         ledjingji=0;
  520.                         ledruoxi=0;
  521.                         ledtuoshui=1;
  522.                         ledpiaoxi=1;
  523.                         ledxidi=1;
  524.                         jinshui=0;
  525.                         delayms(5000);
  526.                         jinshui=1;         //打开进水阀,进水
  527.                         flag1=1;
  528.                         TR0=1;
  529.                         while(flag==0)
  530.                         {         
  531.                                 if(flag==0&&num2==1) //弱经济洗
  532.                                 {         
  533.                                         TR0=1;
  534.                                         flag1=1;
  535.                                         ruo();
  536.                                 }
  537.                                 if(flag==0&&num2==2) //弱经济洗暂停
  538.                                 {
  539.                                         TR0=0;
  540.                                         U2=1;
  541.                                         U3=1;
  542.                                 }
  543.                         };
  544.                         
  545.                         //漂洗                                       
  546.                         TR0=0;
  547.                         U2=1;
  548.                         U3=1;
  549.                         flag1=0;
  550.                         paishui=0;        //排水阀打开
  551.                         ledjingji=0;
  552.                         ledtuoshui=1;
  553.                         ledxidi=1;
  554.                         delayms(5000);
  555.                         paishui=1; //排水阀关闭
  556.                         delayms(100);
  557.                         jinshui=0; //进水阀打开
  558.                         delayms(5000);
  559.                         jinshui=1; //进水阀关闭
  560.                         ledpiaoxi=0;
  561.                         flag1=2;
  562.                         TR0=1;
  563.                         num3=0;
  564.                         num4=0;
  565.                         while(flag==1)
  566.                         {
  567.                                 if(flag==1&&num2==1)//漂洗
  568.                                 {         
  569.                                         TR0=1;
  570.                                         flag1=2;
  571.                                         ruo();
  572.                                 }
  573.                                 if(flag==1&&num2==2)//漂洗暂停
  574.                                 {
  575.                                         TR0=0;
  576.                                         U2=1;
  577.                                         U3=1;
  578.                                 }
  579.                         };
  580.                         //脱水
  581.                         TR0=0;
  582.                         U2=1;
  583.                         U3=1;
  584.                         flag1=0;
  585.                         ledjingji=0;
  586.                         ledtuoshui=0;
  587.                         ledpiaoxi=1;
  588.                         paishui=0;         //排水阀打开
  589.                         delayms(5000);
  590.                         while(sgai);
  591.                         paishui=1;
  592.                         delayms(3000);
  593.                         flag1=3;
  594.                         TR0=1;
  595.                         num3=0;
  596.                         num4=0;
  597.                         while(flag==2)
  598.                         {
  599.                                 if(flag==2&&num2==1)
  600.                                 {
  601.                                         TR0=1;
  602.                                         U2=0;
  603.                                         U3=1;
  604.                                         flag1=3;
  605.                                 }
  606.                                 if(flag==2&&num2==2)
  607.                                 {
  608.                                         TR0=0;
  609.                                         U2=1;
  610.                                         U3=1;
  611.                                 }
  612.                         };
  613.                         ledtuoshui=1;
  614.                         U2=1;
  615.                         U3=1;
  616.                         flag1=0;
  617.         }
  618.         
  619.         void rdandu()               //弱单独
  620.         {
  621.                 num=0;
  622.                 num1=0;
  623.                 ledruoxi=0;
  624.                 ledxidi=0;
  625.                 leddandu=0;
  626.                 jinshui=0;  //打开进水阀,进水
  627.                 delayms(5000);
  628.                 jinshui=1;
  629.                 flag1=1;
  630.                 TR0=1;            //启动定时器T0
  631.                 while(flag==0)
  632.                 {
  633.                         if(flag==0&&num2==1)  //弱单独洗
  634.                                 {         
  635.                                         TR0=1;
  636.                                         flag1=1;
  637.                                         ruo();               
  638.                                 }
  639.                                 if(flag==0&&num2==2)//弱单独洗暂停
  640.                                 {
  641.                                         TR0=0;
  642.                                         U2=1;
  643.                                         U3=1;
  644.                                 }
  645.                 };
  646.                 flag1=0;
  647.                 U2=1;
  648.                 U3=1;
  649.         }
  650.         
  651.         void dpaishui()                                 //排水/脱水
  652.         {
  653.                 num=0;
  654.                 num1=0;
  655.                 ledpaishui=0;
  656.                 ledtuoshui=0;
  657.                 jinshui=1;
  658.                 paishui=0;
  659.                 delayms(3000);
  660.                 while(sgai);
  661.                 delayms(3000);
  662.                 flag1=3;
  663.                 TR0=1;
  664.                 num3=0;
  665.                 num4=0;
  666.                 while(flag==0)
  667.                 {
  668.                         if(flag==0&&num2==1) //脱水
  669.                                 {         
  670.                                         TR0=1;
  671.                                         flag1=3;
  672.                                         U2=0;
  673.                                         U3=1;
  674.                                 }
  675.                                 if(flag==0&&num2==2)//暂停脱水
  676.                                 {
  677.                                         TR0=0;
  678.                                         U2=1;
  679.                                         U3=1;
  680.                                 }
  681.                 };
  682.                 U2=1;
  683.                 U3=1;
  684.                 flag1=0;
  685.                 ledtuoshui=1;
  686.                 paishui=1; ////排水阀关闭
  687.         }                          
  688.         
  689.         void main()
  690.         {
  691.                 init();
  692.                 while(1)
  693.                 {
  694.                         key();                   //键扫描
  695.                         if((num1==0&&num==0)&&circle==1)        //标准 强洗
  696.                         {
  697.                                 ledruoxi=1;   //关闭弱洗LED
  698.                                 ledpaishui=1; //关闭排水LED
  699.                                 ledbiaozhun=0;//强标准LED亮        
  700.                                 ledqiangxi=0; //强洗LED亮
  701.                                 if(num2==1)
  702.                                 {
  703.                                         qbiaozhun(); //强标准洗
  704.                                 }
  705.                                 if(num2>1)                 //K3键按下次数为2,暂停洗涤
  706.                                 {
  707.                                         ;           
  708.                                 }
  709.                                 circle=0;
  710.                         }
  711.                         if(num1==0&&num==1)         //经济 强洗
  712.                         {
  713.                                 ledruoxi=1;           
  714.                                 ledbiaozhun=1;
  715.                                 ledqiangxi=0;
  716.                                 ledjingji=0;
  717.                                 if(num2==1)
  718.                                 {
  719.                                         qjingji();        //强经济洗
  720.                                         ledjingji=1;
  721.                                 }
  722.                                 circle=0;
  723.                         }
  724.                         if(num1==0&&num==2)         //单独 强洗
  725.                         {
  726.                                 ledruoxi=1;
  727.                                 ledjingji=1;
  728.                                 ledqiangxi=0;
  729.                                 leddandu=0;
  730.                                 if(num2==1)
  731.                                 {
  732.                                         qdandu(); //强单独洗
  733.                                         leddandu=1;
  734.                                 }
  735.                                 circle=0;
  736.                         }
  737.                         if(num1==0&&num==3)
  738.                         {
  739.                                 ledruoxi=1;          //排水 强洗
  740.                                 leddandu=1;
  741.                                 ledqiangxi=0;
  742.                                 ledpaishui=0;
  743.                                 if(num2==1)
  744.                                 {
  745.                                         dpaishui();        //单排水
  746.                                         ledpaishui=1;
  747.                                 }
  748.                                 circle=0;
  749.                         }
  750.                         if(num1==1&&num==0)          //弱 标准
  751.                         {
  752.                                 ledqiangxi=1;
  753.                                 ledpaishui=1;
  754.                                 ledruoxi=0;
  755.                                 ledbiaozhun=0;
  756.                                 if(num2==1)
  757.                                 {
  758.                                         rbiaozhun(); //弱标准洗
  759.                                         ledruoxi=1;
  760.                                 }
  761.                                 circle=0;
  762.                         }
  763.                         if(num1==1&&num==1)         //弱经济
  764.                         {
  765.                                 ledqiangxi=1;
  766.                                 ledbiaozhun=1;
  767.                                 ledruoxi=0;
  768.                                 ledjingji=0;
  769.                                 if(num2==1)
  770.                                 {
  771.                                         rjingji();        //弱经济洗
  772.                                         ledruoxi=1;
  773.                                         ledjingji=1;
  774.                                 }
  775.                                 circle=0;
  776.                         }
  777.                         if(num1==1&&num==2)
  778.                         {
  779.                                 ledqiangxi=1;
  780.                                 ledjingji=1;
  781.                                 ledruoxi=0;
  782.                                 leddandu=0;
  783.                                 if(num2==1)
  784.                                 {
  785.                                         rdandu();        //弱单独洗
  786.                                         ledruoxi=1;
  787.                                         leddandu=1;
  788.                                 }
  789.                                 circle=0;
  790.                         }
  791.                         if(num1==1&&num==3)
  792.                         {
  793.                                 ledqiangxi=1;
  794.                                 leddandu=1;
  795.                                 ledruoxi=0;
  796.                                 ledpaishui=0;
  797.                                 if(num2==1)        //K3键
  798.                                 {
  799.                                         dpaishui();         //单排水
  800.                                         ledpaishui=1;
  801.                                 }
  802.                                 circle=0;
  803.                         }
  804.                         num2=0;
  805.                 }
  806.         }
  807.         
  808.         void T0_time() interrupt 1           //定时
  809.         {
  810.                 TH0=(65536-50000)/256;        //重赋初值
  811.                 TL0=(65536-50000)%256;
  812.                 num3++;                                    //定时计数加1
  813.                 if(num3==20)        //1秒时间到
  814.                 {
  815.                         num3=0;                //计数清0
  816.                         if(flag1==1)
  817.                                 ledxidi=~ledxidi;  //洗涤指示取反
  818.                         if(flag1==2)
  819.                                 ledpiaoxi=~ledpiaoxi; //漂洗指示取反
  820.                         if(flag1==3)
  821.                                 ledtuoshui=~ledtuoshui;        //脱水指示取反
  822.                         num4++;
  823.                         num5++;
  824.                         num6++;
  825.                         if(num4==15)         //洗涤定时,15秒到
  826.                         {
  827.                                 num4=0;                         //清0
  828.                                 flag++;                 //标志洗涤次数
  829.                         }
  830.                         if(num5==5)                         //强洗周期,5秒到
  831.                         {
  832.                                 num5=0;
  833.                                 flag4++;         //强洗标志加1
  834.                                 if(flag4==2)
  835.                                         flag4=0;
  836.                         }
  837.                         if(num6==3)                        //弱洗周期        ,3秒到
  838.                         {
  839.                                 num6=0;
  840.                                 flag5++;            //弱洗标志加1
  841.                                 if(flag5==2)
  842.                                         flag5=0;
  843.                         }
  844.                 }
  845.         }
  846.         
  847.         void int0() interrupt 0           //外部中断0 ,K3键
  848.         {
  849.                 num2++;          //K3按下计数加1 ,num2为1运行,num2为2暂停

  850. ……………………

  851. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:

资料.7z (578.78 KB, 下载次数: 754)

评分

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

查看全部评分

回复

使用道具 举报

ID:1 发表于 2018-12-4 03:33 | 显示全部楼层
好资料,51黑有你更精彩!!!
回复

使用道具 举报

ID:549337 发表于 2019-5-28 15:45 | 显示全部楼层
挺不错的很实用
回复

使用道具 举报

ID:647522 发表于 2019-11-22 22:15 | 显示全部楼层
很详细 太好用了
回复

使用道具 举报

ID:656473 发表于 2019-12-5 09:46 | 显示全部楼层
太好用了!
回复

使用道具 举报

ID:656544 发表于 2019-12-5 10:30 | 显示全部楼层
很详细 太好用了
回复

使用道具 举报

ID:566697 发表于 2020-2-19 20:40 | 显示全部楼层
非常感谢
回复

使用道具 举报

ID:711753 发表于 2020-3-19 17:45 | 显示全部楼层
参考看看,看看
回复

使用道具 举报

ID:733317 发表于 2020-5-25 17:23 来自手机 | 显示全部楼层
代码是用keil软件写的吗?
回复

使用道具 举报

ID:927585 发表于 2021-5-26 14:49 | 显示全部楼层
很详细,文档参考看看
回复

使用道具 举报

ID:974748 发表于 2021-10-28 08:41 | 显示全部楼层
不错,很有用
回复

使用道具 举报

ID:1012580 发表于 2022-3-28 09:40 | 显示全部楼层
好资料,51黑有你更精彩!!!
回复

使用道具 举报

ID:495817 发表于 2023-5-31 22:39 | 显示全部楼层
学与致用,很实用教程
回复

使用道具 举报

ID:67838 发表于 2023-8-31 01:19 | 显示全部楼层

好资料,51黑有你更精彩!!!
回复

使用道具 举报

ID:689425 发表于 2023-8-31 19:54 | 显示全部楼层
太详细了,好资料,楼主辛苦
回复

使用道具 举报

ID:1081482 发表于 2023-9-8 21:21 | 显示全部楼层
看起来不错
回复

使用道具 举报

ID:1076950 发表于 2023-9-13 09:58 | 显示全部楼层
楼主可以参考一下你的实物图吗,真的很需要,非常感谢。
回复

使用道具 举报

ID:1093404 发表于 2023-9-13 10:39 | 显示全部楼层
很有用,参考看看
回复

使用道具 举报

ID:67838 发表于 2024-2-3 17:19 | 显示全部楼层

很详细,文档参考看看
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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