单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1852|回复: 2
打印 上一主题 下一主题
收起左侧

单片机全自动洗衣机控制系统Proteus仿真程序设计

[复制链接]
跳转到指定楼层
楼主
本实践以单片机为基础,实现了全自动洗衣机控制系统设计。系统包含单片机、LCD显示屏、水位传感器、温度传感器等。全自动洗衣机包含的功能有:标准洗衣、经济洗衣、单独洗衣以及排水四种洗衣方式,有强洗、弱洗及运行/暂停、显示及报警功能,有自动烘干功能等。

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


单片机源程序如下:
  1. #include<reg51.h>                                  //定义头文件
  2. #define uint unsigned int                  //定义字符uint
  3. #define uchar unsigned char                  //定义字符uchar
  4. #define TIME0H 0xff                                  //定时器0计数器高位
  5. #define TIME0L 0x9c                                  //定时器0计数器低位
  6. #define TIME1H 0x3c                                  //定时器1计数器高位
  7. #define TIME1L 0xb0                                  //定时器1计数器低位
  8. #define MOTOR_COUNT 100                          //PWM波输出周期计数
  9.                                                                                
  10. #define sol 0x6c                                 //将"so"宏定义为低音"5"的频率 784Hz
  11. #define Dol 0x44                                 //将"Do"宏定义为中音"1"的频率 523Hz
  12. #define Rel 0xac                                 //将"Re"宏定义为中音"2"的频率 587Hz
  13. #define Mil 0x09                                 //将"Mi"宏定义为中音"3"的频率 659Hz
  14. #define Fal 0x34                                 //将"Fa"宏定义为中音"4"的频率 698Hz
  15. #define Sol 0x82                                 //将"So"宏定义为中音"5"的频率 784Hz
  16. #define Lal 0xc8                                 //将"La"宏定义为中音"6"的频率 880Hz
  17. #define Sil 0x05                                 //将"Si"宏定义为中音"7"的频率 523H

  18. #define soh 0xfc                                 //将"so"宏定义为低音"5"的频率 784Hz
  19. #define Doh 0xfc                                 //将"Do"宏定义为中音"1"的频率 523Hz
  20. #define Reh 0xfc                                 //将"Re"宏定义为中音"2"的频率 587Hz
  21. #define Mih 0xfd                                 //将"Mi"宏定义为中音"3"的频率 659Hz
  22. #define Fah 0xfd                                 //将"Fa"宏定义为中音"4"的频率 698Hz
  23. #define Soh 0xfd                                 //将"So"宏定义为中音"5"的频率 784Hz
  24. #define Lah 0xfd                                 //将"La"宏定义为中音"6"的频率 880Hz
  25. #define Sih 0xfe                                 //将"Si"宏定义为中音"7"的频率 523H
  26.                                                                   //定义宏变量
  27. sbit speaker =P2^6;                            //蜂鸣器控制引脚
  28. sbit RS=P1^5;                                    //LCD RS引脚
  29. sbit R_W=P1^6;                                    //LCD 读写信号
  30. sbit EN=P1^7;                                    //LCD 使能引脚
  31. sbit motor_high=P1^0;                    //PWM输出高电平引脚
  32. sbit motor_low=P1^1;                    //PWM输出低电平引脚
  33. sbit motor_1_en=P1^2;                    //进水阀门引脚
  34. sbit motor_2_en=P1^3;                    //出水阀门引脚
  35. sbit motor_3_en=P1^4;                    //洗衣机电动使能引脚
  36. sbit EOC=P2^4;                                    //AD EOC
  37. sbit START=P2^5;                            //AD START
  38. sbit con=P3^5;                                    //AD CON
  39. sbit add_A=P3^0;                            //位选信号A
  40. sbit lock_OE=P3^1;                            //74ls373锁存控制引脚

  41.                                                             //定义全局变量
  42. uchar process;                                    //当前洗衣机运行状态全局变量
  43. uchar method;                                    //当前洗衣机运行方式全局变量
  44. uchar speed;                                    //当前电动机速度全局变量
  45. uchar flag;                                                //标志位
  46. uchar state;                                        //洗衣机运行状态选择
  47. uint ad_level;                                    //水位采样全局变量
  48. uint ad_voltage;                            //电压采样全局变量
  49. uint time_count;                            //定时器0中断次数全局变量
  50. uint time_count1;                            //定时器1中断次数全局变量
  51. uint MOTOR_ON,MOTOR_NOW;            //电动机pwm控制计数,高电平脉冲数和当前脉冲数
  52. uchar st_pau;                                    //当前洗衣机运行全局变量
  53. uchar step;                                            //当前洗衣机运行步骤全局变量

  54. uint Cl=0;                                                //
  55. uint Ch=0;                                                //
  56. uchar close=0;
  57.                                                             //声明子函数
  58. void init_LCM();                            //lcd初始化函数
  59. void clearLCD();                            //lcd清屏函数
  60. void write_data(char date);            //lcd写数据函数
  61. void write_com(char command);   //lcd写指令函数
  62. void display()reentrant;                //lcd显示函数
  63. void check_BF();                            //lcd检查忙碌函数
  64. void fangshi1();                            //洗衣机运行方式1
  65. void fangshi2();                            //洗衣机运行方式2
  66. void fangshi3();                            //洗衣机运行方式3
  67. void fangshi4();                            //洗衣机运行方式4
  68. void translate(int keycode);    //按键值释放函数
  69. void clrpara();                                    //复位所有参数
  70. void speaker_on();                                //蜂鸣器
  71. void delay();                                         //80ms延时程序
  72.                                
  73. unsigned char f_TAB[][2]={ /**/{Sol,Soh},{Lal,Lah},{Sol,Soh},{Fal,Fah},{Mil,Mih},{Dol,Doh},//,                                                                 //音调
  74.                                                           /**/{Sol,Soh},{Lal,Lah},{Sol,Soh},{Fal,Fah},{Mil,Mih},{Dol,Doh},/**/{Dol,Doh},{sol,soh},{Dol,Doh},
  75.                                                         /**/{Dol,Doh},{sol,soh},{Dol,Doh},/**/{0xff,0xff}};                                                                                               
  76. uchar time_TAB[]={3,1,3,1,4,4,/**/3,1,3,1,4,4,/**/4,4,4,8,/**/4,4,4,8};        //节拍
  77.                                                          
  78. /*****************************80ms延时*****************************/
  79. void delay()                                                                                                                                                                                        
  80. {                                                                                                                                                                                                                                               
  81.         uchar i,j;                                         //定义变量i,j
  82.         for(i=0;i<100;i++)                        //外循环
  83.         for(j=0;j<250;j++);                        //内循环
  84. }
  85. /***************************按键信息翻译***************************/                                                         
  86. void translate(int keycode)                               
  87. {
  88.         int key;                                                         //定义临时变量key,用来判断(开始/暂停)按键次数
  89.         switch(keycode)                                                //根据不同传入的keycode值,进行全局变量赋值
  90.         {
  91.                 case 0:                                                        //方式一                       
  92.                         method = '1';                                //将方式全局变量赋值为‘1’
  93.                         //return '0';                                //返回‘0’结果
  94.                         break;                                                 //跳出分支判断
  95.                 case 1:                                                 //方式三
  96.                         method = '3';                                //将方式全局变量赋值为‘3’
  97.                         //return '1';                                //返回‘1’结果
  98.                         break;                                                 //跳出分支判断
  99.                 case 2:                                                 //速度1/4
  100.                         speed = '1';                                //赋值速度全局变量为1
  101.                         MOTOR_ON = 25;                                //设置PWM占空比为25/100
  102.                         //return '2';                                //返回‘2’结果
  103.                         break;                                                 //跳出分支判断
  104.                 case 3:                                                 //速度3/4
  105.                         speed = '3';                                //赋值速度全局变量为3
  106.                         MOTOR_ON = 75;                                //设置PWM占空比为75/100
  107.                         //return '3';                                //返回‘3’结果
  108.                         break;                                                 //跳出分支判断
  109.                 case 4:                                                 //方式二
  110.                         method = '2';                                //将方式全局变量赋值为‘2’
  111.                         //return '4';                                //返回‘4’结果
  112.                         break;                                                 //跳出分支判断
  113.                 case 5:                                                 //方式四
  114.                         method = '4';                                //将方式全局变量赋值为‘4’
  115.                         //return '5';                                //返回‘5’结果
  116.                         break;                                                //跳出分支判断
  117.                 case 6:                                                 //速度2/4
  118.                         speed = '2';                                //赋值速度全局变量为2
  119.                         MOTOR_ON = 50;                                //设置PWM占空比为50/100
  120.                         //return '6';                                //返回‘6’结果
  121.                         break;                                                //跳出分支判断
  122.                 case 7:                                                 //速度4/4
  123.                         speed = '4';                                //赋值速度全局变量为4
  124.                         MOTOR_ON = 100;                                //设置PWM占空比为100/100
  125.                         //return '7';                                //返回‘7’结果
  126.                         break;                                                //跳出分支判断
  127.                 case 8:                                                 //ON
  128.                         state =1;                                        //赋值洗衣机运行状态选择1
  129.                         //return '8';                                //返回‘8’结果
  130.                         break;                                                //跳出分支判断
  131.                 case 9:                                                 //OFF
  132.                         state = 0;                                        //赋值洗衣机运行状态选择0
  133.                         //return '9';                                //返回‘9’结果
  134.                         break;                                                //跳出分支判断
  135.                 case 10:                                                //START/PAUSE
  136.                 {                                                       
  137.                         if(key==0)                                        //判断开始/暂停键是否按下,是继续
  138.                         {       
  139.                                 st_pau=1;                                //赋值洗衣机运行全局变量为1
  140.                                 key++;                                        //key自加1
  141.                         }
  142.                         else                                               
  143.                         {
  144.                                 st_pau=2;                                //当前洗衣机运行全局变量为2
  145.                                 key--;                                        //key自减1
  146.                         }
  147.                         //return 'A';                                //返回‘A’结果
  148.                         break;                                                //跳出分支判断
  149.                  }
  150.         }
  151. }

  152. /*****************************LCD显示******************************/                                                         
  153. void display()reentrant
  154. {
  155.   int level_1,level_2,level_3,voltage_1,voltage_2,voltage_3;
  156.   //定义水位、电压显示百位、十位、各位。由于显示直接采用返回AD转换值,所以需要按照百、十、个位进行显示
  157.   clearLCD();                                                                //LCD清屏
  158.   //process: 1浸泡,2脱水,3洗涤,4进水,5漂洗,
  159.   //method:1方式一,2方式二,3方式三,4方式四
  160.   //speed:1速度1/4,2速度2/4,3速度3/4,4速度4/4
  161.   level_1 = ad_level / 100 + 48;                        //获得水位检测百位,同时转化为ASCII码
  162.   level_2 = (ad_level %100 ) /10 + 48;                //获得水位检测值十位,同时转化为ASCII码
  163.   level_3 = (ad_level %10 ) + 48;                    //获得水位检测值个位,同时转化为ASCII码
  164.   voltage_1 = ad_voltage / 100 + 48;            //获得电压转换值百位,转化为ASCII码
  165.   voltage_2 = (ad_voltage %100 ) /10 + 48;        //获得电压转换值十位,转化为ASCII码
  166.   voltage_3 = (ad_voltage %10 ) + 48;                //获得电压转换值个位,转化为ASCII码
  167.   if (state == 1)                                                        //如果洗衣机当前运行状态为on开启状态
  168.   {                               
  169.           switch(process)                                            //根据不同的运行状态,在LCD第一行显示运行状态信息
  170.           {
  171.                   case '1':                                                          //进水
  172.                   write_data('J');                                        //显示字符‘J’
  173.                   write_data('I');                                        //显示字符‘I’
  174.                   write_data('N');                                        //显示字符‘N’
  175.                   write_data('S');                                        //显示字符‘S’
  176.                   write_data('H');                                        //显示字符‘H’
  177.                   write_data('U');                                        //显示字符‘U’
  178.                   write_data('I');                                        //显示字符‘I’
  179.                   write_data(' ');                                    //显示空字符
  180.                   write_data(' ');                                    //显示空字符
  181.                   write_data(' ');                                    //显示空字符
  182.                   write_data(' ');                                        //显示空字符
  183.                   write_data('L');                                        //显示字符‘L’
  184.                   write_data(level_1);                                //显示水位检测百位值
  185.                   write_data(level_2);                                //显示水位检测十位值
  186.                   write_data(level_3);                                //显示水位检测个位值
  187.                   write_data(' ');                                        //显示空字符
  188.                   write_data('V');                                        //显示字符‘V’
  189.                   write_data(voltage_1);                        //显示电压检测百位值
  190.                   write_data(voltage_2);                        //显示电压检测十位值
  191.                   write_data(voltage_3);                        //显示电压检测个位值
  192.                   motor_1_en = 1;                                        //进水阀电动机驱动打开
  193.                   motor_2_en = 0;                                        //排水阀电动机驱动关闭
  194.                   motor_3_en = 0;                                        //洗衣机电动机驱动关闭
  195.                   break;                                                        //跳出分支判断

  196.                 case '2':                                                          //浸泡       
  197.                   write_data('J');                                        //显示字符‘J’
  198.                   write_data('I');                                        //显示字符‘I’
  199.                   write_data('N');                                        //显示字符‘N’
  200.                   write_data('P');                                        //显示字符‘P’
  201.                   write_data('A');                                        //显示字符‘A’
  202.                   write_data('O');                                        //显示字符‘O’
  203.                   write_data(' ');                                        //显示空字符
  204.                   write_data(' ');                                        //显示空字符
  205.                   write_data(' ');                                        //显示空字符
  206.                   write_data(' ');                                        //显示空字符
  207.                   write_data(' ');                                        //显示空字符
  208.                   write_data('L');                                        //显示字符‘L’
  209.                   write_data(level_1);                                //显示水位检测百位值
  210.                   write_data(level_2);                                //显示水位检测十位值
  211.                   write_data(level_3);                                //显示水位检测个位值
  212.                   write_data(' ');                                        //显示空字符
  213.                   write_data('V');                                        //显示字符‘V’
  214.                   write_data(voltage_1);                        //显示电压检测百位值
  215.                   write_data(voltage_2);                        //显示电压检测十位值
  216.                   write_data(voltage_3);                        //显示电压检测个位值
  217.                   motor_1_en = 0;                                        //进水阀电动机驱动关闭
  218.                       motor_2_en = 0;                                        //排水阀电动机驱动关闭
  219.                     motor_3_en = 0;                                    //洗衣机电动机驱动关闭
  220.                   break;                                                        //跳出分支判断

  221.                 case '3':                                                          //洗涤
  222.                   write_data('X');                                        //显示字符‘X’
  223.                   write_data('I');                                        //显示字符‘I’
  224.                   write_data('D');                                    //显示字符‘D’
  225.                   write_data('I');                                        //显示字符‘I’
  226.                   write_data(' ');                                        //显示空字符
  227.                   write_data(' ');                                        //显示空字符
  228.                   write_data(' ');                                        //显示空字符
  229.                   write_data(' ');                                        //显示空字符
  230.                   write_data(' ');                                    //显示空字符
  231.                   write_data(' ');                                    //显示空字符
  232.                   write_data(' ');                                        //显示空字符
  233.                   write_data('L');                                        //显示字符‘’
  234.                   write_data(level_1);                            //显示水位检测百位值
  235.                   write_data(level_2);                                //显示水位检测十位值
  236.                   write_data(level_3);                                //显示水位检测个位值
  237.                   write_data(' ');                                        //显示空字符
  238.                   write_data('V');                                        //显示字符‘V’
  239.                   write_data(voltage_1);                        //显示电压检测百位值
  240.                   write_data(voltage_2);                        //显示电压检测十位值
  241.                   write_data(voltage_3);                        //显示电压检测个位值
  242.                   motor_3_en = 1;                                        //洗衣机电动机驱动打开
  243.                   motor_1_en = 0;                                        //进水阀电动机驱动关闭
  244.                   motor_2_en = 0;                                        //排水阀电动机驱动关闭
  245.                   break;                                                        //跳出分支判断

  246.                  case '4':                                                          //漂洗
  247.                   write_data('P');                                        //显示字符‘P’
  248.                   write_data('I');                                        //显示字符‘I’
  249.                   write_data('A');                                        //显示字符‘A’
  250.                   write_data('O');                                        //显示字符‘O’
  251.                   write_data('X');                                        //显示字符‘X’
  252.                   write_data('I');                                        //显示字符‘I’
  253.                   write_data(' ');                                        //显示空字符
  254.                   write_data(' ');                                        //显示空字符
  255.                   write_data(' ');                                        //显示空字符
  256.                   write_data(' ');                                        //显示空字符
  257.                   write_data(' ');                                        //显示空字符
  258.                   write_data('L');                                        //显示字符‘L’
  259.                   write_data(level_1);                                //显示水位检测百位值
  260.                   write_data(level_2);                                //显示水位检测十位值
  261.                   write_data(level_3);                                //显示水位检测个位值
  262.                   write_data(' ');                                        //显示空字符
  263.                   write_data('V');                                        //显示字符‘V’
  264.                   write_data(voltage_1);                        //显示电压检测百位值
  265.                   write_data(voltage_2);                        //显示电压检测十位值
  266.                   write_data(voltage_3);                        //显示电压检测个位值
  267.                   motor_3_en = 1;                                        //洗衣机电动机驱动打开
  268.                   motor_1_en = 0;                                        //进水阀电动机驱动关闭
  269.                   motor_2_en = 0;                                    //排水阀电动机驱动关闭
  270.                   break;                                                        //跳出分支判断

  271.                 case '5':                                                          //脱水
  272.                   write_data('T');                                        //显示字符‘T’
  273.                   write_data('U');                                        //显示字符‘U’
  274.                   write_data('O');                                        //显示字符‘O’
  275.                   write_data('S');                                        //显示字符‘S’
  276.                   write_data('H');                                        //显示字符‘H’
  277.                   write_data('U');                                        //显示字符‘U’
  278.                   write_data('I');                                        //显示字符‘I’
  279.                   write_data(' ');                                        //显示空字符
  280.                   write_data(' ');                                        //显示空字符
  281.                   write_data(' ');                                        //显示空字符
  282.                   write_data(' ');                                        //显示空字符
  283.                   write_data('L');                                        //显示字符‘L’
  284.                   write_data(level_1);                                //显示水位检测百位值
  285.                   write_data(level_2);                                //显示水位检测十位值
  286.                   write_data(level_3);                                //显示水位检测个位值
  287.                   write_data(' ');                                        //显示空字符
  288.                   write_data('V');                                        //显示字符‘V’
  289.                   write_data(voltage_1);                        //显示电压检测百位值
  290.                   write_data(voltage_2);                        //显示电压检测十位值
  291.                   write_data(voltage_3);                        //显示电压检测个位值
  292.                   motor_1_en = 0;                                        //进水阀电动机驱动关闭
  293.                   motor_2_en = 1;                                        //排水阀电动机驱动打开
  294.                   motor_3_en = 0;                                        //洗衣机电动机驱动关闭
  295.                   break;                                                        //跳出分支判断
  296.                 }
  297.                 if(st_pau==2)                                                //当前洗衣机运行全局变量为2
  298.                 {
  299.               write_data(' ');                                //显示空字符
  300.                           write_data(' ');                                //显示空字符
  301.                           write_data(' ');                                //显示空字符
  302.                           write_data(' ');                                //显示空字符
  303.                           write_data(' ');                                //显示空字符
  304.                           write_data(' ');                                //显示空字符
  305.                           write_data(' ');                            //显示空字符
  306.                           write_data('P');                                //显示字符‘P’
  307.                           write_data('A');                                //显示字符‘A’
  308.                           write_data('U');                                //显示字符‘U’
  309.                           write_data('S');                                //显示字符‘S’
  310.                           write_data('E');                            //显示字符‘E’
  311.                 }
  312.                 else                                                               
  313.                 {                               
  314.                         switch(method)                                        //判断方式全局变量
  315.                         {
  316.                             case '1':                                         //方式一
  317.                                   write_data('M');                        //显示字符‘M’
  318.                                   write_data('E');                        //显示字符‘E’
  319.                                   write_data('T');                        //显示字符‘T’
  320.                                   write_data('H');                        //显示字符‘H’
  321.                                   write_data('O');                        //显示字符‘O’
  322.                                   write_data('D');                        //显示字符‘D’
  323.                                   write_data(':');                        //显示字符‘:’
  324.                                   write_data('1');                        //显示字符‘1’
  325.                                   write_data(' ');                        //显示空字符
  326.                                   break;                                        //跳出分支判断
  327.                             case '2':                                         //方式二
  328.                                   write_data('M');                        //显示字符‘M’
  329.                                   write_data('E');                        //显示字符‘E’
  330.                                   write_data('T');                        //显示字符‘T’
  331.                                   write_data('H');                        //显示字符‘H’
  332.                                   write_data('O');                        //显示字符‘O’
  333.                                   write_data('D');                        //显示字符‘D’
  334.                                   write_data(':');                        //显示字符‘:’
  335.                                   write_data('2');                        //显示字符‘2’
  336.                                   write_data(' ');                        //显示空字符
  337.                                   break;                                        //跳出分支判断
  338.                             case '3':                                         //方式三
  339.                                   write_data('M');                        //显示字符‘M’
  340.                                   write_data('E');                        //显示字符‘E’
  341.                                   write_data('T');                        //显示字符‘T’
  342.                                   write_data('H');                        //显示字符‘H’
  343.                                   write_data('O');                        //显示字符‘O’
  344.                                   write_data('D');                        //显示字符‘D’
  345.                                   write_data(':');                        //显示字符‘:’
  346.                                   write_data('3');                        //显示字符‘3’
  347.                                   write_data(' ');                        //显示空字符
  348.                                   break;                                        //跳出分支判断
  349.                             case '4':                                         //方式四
  350.                                   write_data('M');                        //显示字符‘M’
  351.                                   write_data('E');                        //显示字符‘E’
  352.                                   write_data('T');                        //显示字符‘T’
  353.                                   write_data('H');                        //显示字符‘H’
  354.                                   write_data('O');                        //显示字符‘O’
  355.                                   write_data('D');                        //显示字符‘D’
  356.                                   write_data(':');                        //显示字符‘:’
  357.                                   write_data('4');                    //显示字符‘4’
  358.                                   write_data(' ');                        //显示空字符
  359.                                   break;                                        //跳出分支判断
  360.                           }
  361.                           switch(speed)                                        //判断速度全局变量
  362.                           {
  363.                             case '1':                                         //速度一
  364.                                   write_data('S');                        //显示字符‘S’
  365.                                   write_data('P');                        //显示字符‘P’
  366.                                   write_data('E');                        //显示字符‘E’
  367.                                   write_data('E');                        //显示字符‘E’
  368.                                   write_data('D');                        //显示字符‘D’
  369.                                   write_data(':');                        //显示字符‘:’
  370.                                   write_data('1');                        //显示字符‘1’
  371.                                   break;                                        //跳出分支判断
  372.                             case '2':                                         //速度二
  373.                                   write_data('S');                        //显示字符‘S’
  374.                                   write_data('P');                        //显示字符‘P’
  375.                                   write_data('E');                        //显示字符‘E’
  376.                                   write_data('E');                        //显示字符‘E’
  377.                                   write_data('D');                        //显示字符‘D’
  378.                                   write_data(':');                        //显示字符‘:’
  379.                                   write_data('2');                    //显示字符‘2’
  380.                                   break;                                        //跳出分支判断
  381.                             case '3':                                         //速度三
  382.                                   write_data('S');                        //显示字符‘S’
  383.                                   write_data('P');                        //显示字符‘P’
  384.                                   write_data('E');                        //显示字符‘E’
  385.                                   write_data('E');                        //显示字符‘E’
  386.                                   write_data('D');                        //显示字符‘D’
  387.                                   write_data(':');                        //显示字符‘:’
  388.                                   write_data('3');                    //显示字符‘3’
  389.                                   break;                                        //跳出分支判断
  390.                             case '4':                                         //速度四
  391.                                   write_data('S');                    //显示字符‘S’
  392.                                   write_data('P');                    //显示字符‘P’
  393.                                   write_data('E');                        //显示字符‘E’
  394.                                   write_data('E');                        //显示字符‘E’
  395.                                   write_data('D');                        //显示字符‘D’
  396.                                   write_data(':');                        //显示字符‘:’
  397.                                   write_data('4');                        //显示字符‘4’
  398.                                   break;                                        //跳出分支判断
  399.                                 }                          
  400.                    }
  401.         }
  402.         else
  403.         {
  404.                   write_data('N');                                        //显示字符‘N’
  405.                   write_data('O');                                        //显示字符‘O’
  406.                   write_data('W');                                        //显示字符‘W’
  407.                   write_data(' ');                                        //显示空字符
  408.                   write_data('M');                                        //显示字符‘M’
  409.                   write_data('A');                                        //显示字符‘A’
  410.                   write_data('C');                                        //显示字符‘C’
  411.                   write_data('H');                                        //显示字符‘H’
  412.                   write_data('I');                                        //显示字符‘I’
  413.                   write_data('N');                                        //显示字符‘N’
  414.                   write_data('E');                                        //显示字符‘E’
  415.                   write_data(' ');                                        //显示空字符
  416.                   write_data('I');                                    //显示字符‘I’
  417.                   write_data('S');                                        //显示字符‘S’
  418.                   write_data(' ');                                        //显示空字符
  419.                   write_data('O');                                        //显示字符‘O’
  420.                   write_data('F');                                        //显示字符‘F’
  421.                   write_data('F');                                        //显示字符‘F’
  422.                   write_data(' ');                                        //显示空字符
  423.                   write_data(' ');                                           //显示空字符
  424.         }
  425.   //P0 = 0XFF;
  426. }

  427. /****************************LCD初始化*****************************/                                                         
  428. void init_LCM()                                               
  429. {
  430.         write_com(0x30);                                //发送控制命令0x30
  431.         write_com(0x30);                                //发送控制命令0x30
  432.         write_com(0x30);                                //发送控制命令0x30,做一个延时
  433.         write_com(0x38);                                //发送控制命令0x38
  434.         write_com(0x08);                                //发送控制命令0x08
  435.         write_com(0x01);                                //发送控制命令0x01
  436.         write_com(0x06);                                //发送控制命令0x06
  437.         write_com(0x0e);                                //发送控制命令0x0e
  438. }

  439. /***************************LCD写数据函数**************************/
  440. void write_data(char date)
  441. {
  442.         RS=1;                                                        //写指令电平置为高,进入写数据状态
  443.         R_W=0;                                                        //读指令电平置为低,无效
  444.         EN=1;                                                        //使能信号开
  445.         P0=date;                                                //将数据送入p0口
  446.         EN=0;                                                        //使能信号关
  447.         check_BF();                                                //等待LCD繁忙状态结束
  448. }

  449. /***************************LCD写指令函数**************************/
  450. void write_com(char command)               
  451. {               
  452.    
  453.         RS=0;                                                        //写指令电平置为低,进入写指令状态
  454.         R_W=0;                                                        //读写指令命令置为低电平
  455.         EN=1;                                                        //使能信号开
  456.         P0=command;                                                //将数据送入p0口
  457.         EN=0;                                                        //使能信号关
  458.         check_BF();                                                //等待LCD繁忙状态结束
  459. }                                                                                         

  460. /**************************LCD检查忙碌函数*************************/
  461. void check_BF()
  462. {
  463.         char i,x=0x80;                                        //定义字符变量i,x                                       
  464.         P0=0xff;                                                //P0口输出高电平,使得P0口电平输入允许
  465.         while(x&0x80)                                        //当LCD还是处于繁忙状态时,进入循环
  466.         {                                                               
  467.           RS=0;                                                        //写指令置为1,读取指令状态
  468.           R_W=1;                                                //读引脚电平置为高,为读取信息状态
  469.           EN=1;                                                        //LCD使能信号开
  470.           P0=0XFF;                                                //P0口输出高电平,使得P0口电平输入允许
  471.           x=P0;                                                        //将P0口电平信息赋给x
  472.           EN=0;                                                        //LCD使能信号关闭
  473.           for (i=0;i<10;i++);                        //循环等待
  474.         }
  475.         EN=0;                                                        //关闭使能信号
  476. }

  477. /****************************LCD清屏函数***************************/
  478. void clearLCD()
  479. {
  480.   write_com(0x01);                                        //写入LCD清屏指令
  481. }

  482. /******************************方式一******************************/                                                         
  483. void fangshi1()
  484. {
  485.         switch(step)                                        //判断洗衣机当前运行步骤
  486.         {
  487.                 case 0:                                                //步骤0
  488.                         process = '1';                        //进水
  489.                         break;                                        //跳出分支判断
  490.                 case 1:                                                //步骤1
  491.                         process = '2';                        //浸泡
  492.                         break;                                        //跳出分支判断
  493.                 case 2:                                                //步骤2
  494.                         process = '3';                        //洗涤
  495.                         break;                                        //跳出分支判断
  496.                 case 3:                                                //步骤3
  497.                         process = '5';                        //脱水
  498.                         break;                                        //跳出分支判断
  499.                 case 4:                                                //步骤4
  500.                         process = '1';                        //进水
  501.                         break;                                        //跳出分支判断
  502.                 case 5:                                                //步骤5
  503.                         process = '4';                        //漂洗
  504.                         break;                                        //跳出分支判断
  505.                 case 6:                                                //步骤6
  506.                         process = '5';                        //脱水
  507.                         break;                                        //跳出分支判断
  508.                 case 7:                                                //步骤7
  509.                         process = '1';                        //进水
  510.                         break;                                        //跳出分支判断
  511.                 case 8:                                                //步骤8
  512.                         process = '4';                        //漂洗
  513.                         break;                                        //跳出分支判断
  514.                 case 9:                                                //步骤9
  515.                         process = '5';                        //脱水
  516.                         break;                                        //跳出分支判断
  517.                 case 10:                                        //步骤10
  518.                         clrpara();                                //复位所有参数
  519.                         break;                                        //跳出分支判断
  520.         }
  521. }

  522. /******************************方式二******************************/                                                         
  523. void fangshi2()
  524. {
  525.         switch(step)                                        //判断洗衣机当前运行步骤
  526.         {
  527.                 case 0:                                                //步骤0
  528.                         process = '1';                        //进水
  529.                         break;                                          //跳出分支判断
  530.                 case 1:                                                //步骤1
  531.                         process = '3';                        //洗涤
  532.                         break;                                        //跳出分支判断
  533.                 case 2:                                                //步骤2
  534.                         process = '5';                        //脱水
  535.                         break;                                        //跳出分支判断
  536.                 case 3:                                                //步骤3
  537.                         process = '1';                        //进水
  538.                         break;                                        //跳出分支判断
  539.                 case 4:                                                //步骤4
  540.                         process = '4';                        //漂洗
  541.                         break;                                        //跳出分支判断
  542.                 case 5:                                            //步骤5
  543.                         process = '5';                        //脱水
  544.                         break;                                        //跳出分支判断
  545.                 case 6:                                                //步骤6
  546.                         process = '1';                        //进水
  547.                         break;                                        //跳出分支判断
  548.                 case 7:                                                //步骤7
  549.                         process = '4';                        //漂洗
  550.                         break;                                        //跳出分支判断
  551.                 case 8:                                                //步骤8
  552.                         process = '5';                        //脱水
  553.                         break;                                        //跳出分支判断
  554.                 case 9:                                                //步骤9
  555.                         clrpara();                                //复位所有参数
  556.                         break;                                        //跳出分支判断
  557.                        
  558.         }
  559. }

  560. /******************************方式三******************************/                                                         
  561. void fangshi3()
  562. {
  563.         switch(step)                                        //判断洗衣机当前运行步骤
  564.         {
  565.                 case 0:                                                //步骤0
  566.                         process = '1';                        //进水
  567.                         break;                                        //跳出分支判断
  568.                 case 1:                                                //步骤1
  569.                         process = '3';                        //洗涤
  570.                         break;                                        //跳出分支判断
  571.                 case 2:                                                //步骤2
  572.                         process = '5';                        //脱水
  573.                         break;                                        //跳出分支判断
  574.                 case 3:                                                //步骤3
  575.                         process = '1';                        //进水
  576.                         break;                                        //跳出分支判断
  577.                 case 4:                                                //步骤4
  578.                         process = '4';                        //漂洗
  579.                         break;                                        //跳出分支判断
  580.                 case 5:                                                //步骤5
  581.                         process = '5';                        //脱水
  582.                         break;                                        //跳出分支判断
  583.                 case 6:                                                //步骤6
  584.                         clrpara();                                //复位所有参数
  585.                         break;                                        //跳出分支判断
  586.         }
  587. }

  588. /******************************方式四******************************/                                                         
  589. void fangshi4()
  590. {
  591.         switch(step)                                        //判断洗衣机当前运行步骤
  592.         {
  593.                 case 0:                                                //步骤0
  594.                         process = '5';                        //脱水
  595.                         break;                                        //跳出分支判断
  596.                 case 1:                                                //步骤1
  597.                         clrpara();                                //复位所有参数
  598.                         break;                                        //跳出分支判断
  599.         }
  600. }

  601. /*******************************复位*******************************/                                                         
  602. void clrpara()
  603. {
  604.         EX0=0;                                         
  605.         TR0=0;
  606.         st_pau=2;                                                //洗衣机是否运行全局变量为2
  607.         step=0;                                                        //洗衣机运行步骤全局变量为0
  608.         //P2=0xff;                                                //P0输出0xff信息
  609.         state=0;                                                //洗衣机运行状态设置为OFF状态
  610.         process='1';                                        //洗衣机过程全局变量为1
  611.         method='1';                                                //洗衣机方式全局变量为1
  612.         speed='1';                                                //电动机速度全局变量为1
  613.         ad_level=0;                                                //水位AD监测值为0
  614.         ad_voltage=0;                                        //电压AD检测值为0
  615.         motor_1_en = 0;                                        //进水阀驱动机关闭
  616.           motor_2_en = 0;                                        //排水阀驱动机关闭
  617.         motor_3_en = 0;                                        //洗衣机电动机关闭
  618.         TR1=0;
  619.         flag=1;                                                        //标志位为1,开始播放音乐
  620.         //TR1=1;                                                        //启动定时器0
  621.         init_LCM();                                                //LCD初始化程序
  622.         display();                                                //LCD刷新显示
  623.         //speaker_on();                                        //音乐播放程序
  624. }

  625. /***************************音乐播放程序***************************/
  626. void speaker_on()
  627. {
  628.         uchar i,j;                                                //定义变量i,j
  629.     i=0;                                        //变量i赋值为0
  630.         while(f_TAB[i][0]!=0xff)//判断
  631.         {
  632.                 Ch=f_TAB[i][1];                //TH0赋值
  633.                 Cl=f_TAB[i][0];                //TL0赋值
  634.                 TH1=Ch;                                //TH0赋值
  635.                 TL1=Cl;                                //TL0赋值
  636.                 TR1=1;
  637.                 for(j=0;j<time_TAB[i];j++)                          //控制节拍数
  638.                 delay();                                                          //延时 1 个节拍单位
  639.                 TR1=0;                                                                  //关闭定时器 T0
  640.                 i++;                                                                  //播放下一个音符  
  641.         }

  642. }
  643. /****************************主程序入口****************************/                                                         
  644. void main()
  645. {

  646.         //中断0按键
  647.         IT0 = 1;                                                //中断方式为下降沿
  648.         EX0 = 1;                                                //开启外部中断
  649.        
  650.         //定时器0、1,定时器0、1中断,用于状态改变计数,pwm调制计数
  651.         TMOD = 0x11;                                        //定时器为定时中断模式1
  652.         TH0 = TIME0H;                                        //定时器0计数高位加载
  653.         TL0 = TIME0L;                                        //定时器0计数低位加载
  654.         TH1 = TIME1H;                                        //定时器1计数高位加载
  655.         TL1 = TIME1L;                                        //定时器1计数低位加载
  656.         ET0 = 1;                                                //定时器0中断允许
  657.         ET1 = 1;                                                //定时器1中断允许
  658.         TR0 = 1;                                                //定时器0计数器启动
  659.         TR1 = 1;                                                //定时器1计数器启动
  660.         P2 = 0xff;                                                //P0输出0xff信息
  661.         state = 0;                                                //洗衣机运行状态设置为OFF状态
  662.         process = '1';                                        //洗衣机过程全局变量为‘1’
  663.         method = '1';                                        //洗衣机方式全局变量为‘1’
  664.         speed = '1';                                        //电动机速度全局变量为‘1’
  665.         st_pau = '0';                                        //洗衣机是否运行全局变量为‘0’
  666.         step = 0 ;                                          //洗衣机运行步骤全局变量为‘0’
  667.         MOTOR_ON = 25;                                        //电动机PWM控制计数为25
  668.         ad_level = 0;                                        //水位AD监测值为0
  669.         ad_voltage = 0;                                        //电压AD检车值为0
  670.         time_count = 0;                                        //定时0中断计数器全局变量为0
  671.         time_count1 = 0;                                //定时1中断计数器全局变量为0
  672.         flag=0;                                                        //标志位为0
  673.         speaker = 0;                                        //蜂鸣器关闭
  674.         init_LCM();                                                //初始化LCD
  675.         display();                                                //刷新显示
  676.         EA = 1;                                                        //开启单片机中断允许位,允许中断开始
  677.         P0 = 0xff;                                                //P0输出高电平,使得可以进行外部电压信号输入

  678.         while(1)                               
  679.         {
  680.                 //测试水位
  681.                 while(flag==0)
  682.                 {
  683.                         con = 0;                                        //AD转换输出关闭
  684.                         add_A = 0;                                        //选择水位模拟信号进行AD转换
  685.                         START = 1;                                        //设置START引脚为高电平
  686.                         START = 0;                                        //设置START引脚为低电平,得到下降沿,启动AD检测
  687.                                                        
  688.                         while(!EOC);                                //等待AD转换结束
  689.                         lock_OE = 0;                                //74ls373锁存信号为低,通道开启
  690.                         P0 = 0xff;                                        //P0引脚输出高电平,允许引脚电平的读入
  691.                         con = 1;                                        //AD转换芯片输出使能
  692.                         ad_level = P0;                                //将AD转换赋值为AD_LEVEL全局变量
  693.                         con = 0;                                        //AD转换芯片输出禁止
  694.                         lock_OE = 1;                                //74ls373锁存信号开启,进行电平锁存
  695.                         add_A = 1;                                        //选择AD模块为1号通道信号进行模数转换,即电压信号
  696.                         START = 1;                                        //START引脚输出高电平
  697.                         START = 0;                                        //START引脚输出低电平,开始AD转换
  698.                         while(!EOC);                                //等待AD转换结束
  699.                         lock_OE = 0;                                //74ls373锁存信号关闭,AD转换信号可以输出
  700.                         P0 = 0xff;                                        //P0输出高电平,使得外部电压可以进行输入
  701.                         con = 1;                                        //AD转换结果使能
  702.                         ad_voltage = P0;                        //将P0引脚的AD转换结果赋值给电压检测全局变量
  703.                         con = 0;                                        //AD转化结果输出关闭
  704.                         lock_OE = 1;                                //74ls373锁存信号开启,使得P0口与AD转换引脚隔离
  705.                 }
  706.                 if(flag==1)
  707.                 {
  708.                         speaker_on();
  709.                         flag=0;
  710.                 }
  711.                        
  712.         }

  713. }

  714. /**************************外部中断0子程序*************************/                                                         
  715. void int_0() interrupt 0
  716. {
  717.         uint temp;                                                //定义变量temp,用来读取P2信息
  718.         temp = P2;                                                //temp读取P2信息
  719.         translate(temp&0x0f);                        //与0x0f相与,得到低四位电平信号,并传入translate()函数       
  720.         display();                                                //LCD显示刷新
  721. }

  722. /***************************定时0中断入口**************************/                                                         
  723. void time_0() interrupt 1
  724. {
  725.         time_count1 ++;                                        //全局定时中断计数自加1
  726.         if (time_count1 > 6)                        //如果全局定时中断次数大于6,则
  727.         {
  728.           time_count1 = 0;                                //全局定时中断次数置零
  729.         }
  730.         //只考虑正转
  731.         if(st_pau==1)                                        //如果洗衣机处于运行状态,则
  732.         {
  733.                 MOTOR_NOW++;                                //PWM计数次数自加1
  734.                 if (MOTOR_NOW > MOTOR_ON)   //如果PWM计数次数大于高电平计数值
  735.                 {
  736.                   motor_high = 0;                        //PWM高电平引脚输出低电平
  737.                  }
  738.                 else
  739.                 {
  740.                   motor_high = 1;                        //PWM高电平输出高电压
  741.                 }
  742.                 if (MOTOR_NOW >  MOTOR_COUNT) //如果PWM计数值大于PWM计数周期
  743.                 {
  744.                   MOTOR_NOW = 0;                        //PWM计数值置零
  745.                 }
  746.                 motor_low = 0;                                //PWM低电平输出低电平
  747.         }
  748.         TH0=TIME0H;                                                //定时器0高位计数载入
  749.         TL0=TIME0L;                                                //定时器低位计数载入
  750.        
  751. }

  752. /***************************定时1中断入口**************************/                                                         
  753. void vTimer0() interrupt 3
  754. {
  755.         if(flag==0)
  756.         {
  757.                 TR1=0;
  758.                 if(st_pau==1)
  759.                 {
  760.                         time_count++;
  761.                         if(time_count> 5)
  762.                         {
  763.                                 time_count=0;
  764.                                 step++;
  765.                                 display();
  766.                         }
  767.                 }
  768.                 switch(method)
  769.                 {
  770.                         case '1':                                 //方式一
  771.                                 fangshi1();
  772.                                 break;                       
  773.                         case '2':                                 //方式二
  774.                                 fangshi2();
  775.                                 break;
  776.                         case '3':                                 //方式三
  777.                                 fangshi3();
  778.                                 break;       
  779.                         case '4': //方式四
  780.                                 fangshi4();       
  781.                                 break;
  782.                 }                                                                                               
  783.                 TH1=TIME1H;
  784.                 TL1=TIME1L;
  785.                 TR1=1;
  786.         }
  787.         else
  788.         {
  789.                         speaker=~speaker;                                                  //取反
  790.                         TH1=Ch;                                                         //TH1赋值
  791.                         TL1=Cl;                                                         //TL1赋值
  792.         }
  793.        
  794. }
复制代码

所有资料51hei提供下载:
333.rar (71.56 KB, 下载次数: 130)


评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 转播转播 分享分享1 分享淘帖 顶2 踩
回复

使用道具 举报

沙发
被窝 发表于 2019-12-12 10:30 来自手机 | 只看该作者
怎么找到仿真图的,没有找到仿真图
回复

使用道具 举报

板凳
akalzw 发表于 2020-6-30 14:19 | 只看该作者
请问烘干和温度传感器在哪啊,也没看到加热电路啊
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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