找回密码
 立即注册

QQ登录

只需一步,快速开始

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

PROTEUS 双层卸灰阀仿真

[复制链接]
跳转到指定楼层
楼主
ID:72519 发表于 2015-1-21 21:31 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式








  1. #include <reg52.h>

  2. #define uchar unsigned char                 //宏定义uchar为无符型字节

  3. #define uint unsigned int                 //宏定义uint为无符型整数

  4. #define RCOMMAND 0x01                        //宏定义读命令

  5. #define WCOMMAND 0x02                        //宏定义写命令

  6. #define ECOMMAND 0x03                        //宏定义擦写命令

  7. #define WAITTIME 0x01



  8. sfr ISP_DATA=0xe2;                               //定义数据寄存器地址

  9. sfr ISP_ADDRH=0xe3;                               //定义地址寄存器地址高位

  10. sfr ISP_ADDRL=0xe4;                               //定义地址寄存器地址低位

  11. sfr ISP_CMD=0xe5;                               //定义命令寄存器地址

  12. sfr ISP_TRIG=0xe6;                               //定义触发命令地址

  13. sfr ISP_CONTR=0xe7;                               //定义控制寄存器地址



  14. sbit duan=P1^6 ;              //定义段选

  15. sbit wei=P1^7  ;              //定义位选



  16.        /*指示灯led*/

  17. sbit yx_led=P2^0;          //运行灯

  18. sbit jsms_led=P2^1;   //计时灯

  19. sbit jsums_led=P2^2;  //计数灯

  20. sbit sgdw_led=P2^3;   // 上关到位灯

  21. sbit skdw_led=P2^4;   // 上开到位灯

  22. sbit xgdw_led=P2^5;   //  下关到位灯

  23. sbit xkdw_led=P2^6;  //       下开到位灯



  24. /*按钮*/

  25. sbit ms_key=P1^0;         //       模式按钮

  26. sbit shang_key=P1^1;  //       向上键

  27. sbit seding_key=P1^2;       //       设定按钮

  28. sbit qiting_key=P1^3;       //       启停按钮

  29. sbit xia_key=P1^4;          //       向下按钮

  30. sbit rest_key=P1^5;  //       复位按钮



  31.    /*阀门位置信号*/

  32. sbit skdw_in=P3^0;   //    上阀开到位信号

  33. sbit sgdw_in=P3^1;   //  上阀关到位信号

  34. sbit xkdw_in=P3^2;         //    下阀开到位信号

  35. sbit xgdw_in=P3^3;   //    下阀关到位信号



  36. /*输出启动电机*/

  37. sbit skq=P3^4;       //    上阀电机开得电

  38. sbit sgq=P3^5;       //    上阀电机关得电

  39. sbit xkq=P3^6;       //    下阀电机开得电

  40. sbit xgq=P3^7;       //    下阀电机关得电



  41. uchar table[8];         //定义字符数组存放EEPROM里存的变量,和调整后存入EEPROM里



  42. uchar ms,shang,xia,seding,qiting,rest,sfk,xfk,xfg,sfg,dj;

  43. uchar jsgz=1,flg,x,err;                     //计时间隔,计时工作时间 e工作数 fl计时工作开始标志

  44. uchar js_jg=10,js_gz=20,jsu_cs,un,jisu;

  45. char e,jsjg,time,time2=3,flg1,flg2,fqwz,fqwz2=3,sd1,ys,ys1=5,flag3,cbz;

  46. /******************变量名称***************************

  47. ms 模式状态  shang按钮上  xia按钮下键   seding设定键值  qiting启停键变量   rest复位键变量

  48. sfk上阀开  sfg上阀关   xfk下阀开  xfg下阀关   dj定时器延时标志位

  49. jsgz计时工作   flg计时工作工作时间倒计时减标志位  x阀位连续开关状态    err错误时用闪烁

  50. e计时工作时间     jsjg计时工作间隔时间   time阀开到位等待进放料时间   

  51. time2阀门开到位等待时间存在E2ROM值   flg1阀开到位倒计时标志位    flg2上下阀启动但位置信号不复位

  52. fqwz上下阀开关启动多久位置没变化       fqwz2上下阀开关启动多久们没变化设定值

  53. sd1设定有逻辑故障是否继续工作          ys测试阀电机得电几秒钟没到位    flag3阀电机得电没到位标志位倒计时

  54. ys1存EEPROM阀得电几秒没到位       js_jg能调整数值EEPROM存,赋给值   js_gz能调整数值EEPROM存,赋值

  55. jisu计数倒计数值  cbz错标志位复位用

  56. //jisu time2 js_jg js_gz        */

  57.                                  

  58. /*led数码管段选位选*/

  59. uchar code dm[]={0xc0,0xf9,0xa4,0xb0,0x99,

  60. 0x92,0x82,0xd8,0x80,0x90,0xaf,0xa3,0xfb,0xab,0x7f,0x86,0x87};

  61. uchar code wm[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01,0x00,} ;



  62. /**************毫秒延时函数*****************/

  63. void delay(unsigned int a)

  64. {

  65.        unsigned int i,x;

  66.        for(i=0;i<a;i++)

  67.           for(x=0;x<110;x++);

  68. }

  69.        /*********按键扫描函数************/

  70. void  key_scan()

  71. {

  72.    // uchar k;                //定义变量返回值

  73.        ms_key=1;                //送高电平到模式位

  74.        if(ms_key!=1)         //检测如果不等于高电平

  75.        {

  76.               delay(5);         //延时

  77.               if(ms_key!=1)

  78.               ms=ms+1;                     //       确定,计时模0或计数模式1

  79.               if(ms>=2)ms=0;  

  80.               while(ms_key!=1);  //等侍按键抬起            

  81.        }                                                                        

  82. //       else ms=0;                 //如果还是低电平返回0

  83.       

  84.        if(shang_key!=1)  //如果检测上键不是高电平

  85.        {

  86.               delay(5);              // 延时

  87.               if(shang_key!=1)

  88.               shang=1;                     //如果上键还是低电平返回1            

  89.        }

  90.        else shang=0;

  91.        if(seding_key!=1)          //如果检测设定不是高电平

  92.        {

  93.               delay(5);       //延时

  94.               if(seding_key!=1)

  95.               seding++;                 //如果检测设定还是低电平返回1

  96.               if(seding>=3)seding=0;

  97.               while(seding_key!=1);

  98.        }

  99.        if(qiting_key!=1)          //检测起动按钮如果是低电平

  100.        {                              

  101.               delay(5);         //延时

  102.               if(qiting_key!=1)

  103.               qiting=1;                 //如果启动还是低电平返回1

  104.               else qiting=0;

  105.        }

  106.        if(xia_key!=1)           //如果下检测是低电平

  107.        {

  108.               delay(5);              //延时

  109.               if(xia_key!=1)

  110.               xia=1;                     //如果下不是低电平返回1

  111.        }

  112.        else xia=0;

  113.        if(rest_key!=1)              //检测复位按钮如果是低电平

  114.        {

  115.               delay(5);              //延时

  116.               if(rest_key!=1)

  117.            rest=1;                     //如果复位按钮还是低电平返回1

  118.               else rest=0;

  119.        }

  120. }

  121.        /********阀门位置扫描***********/

  122. void fmwz()

  123. {

  124.        if(skdw_in!=1)                     //       测试如果上阀在开的位置

  125.        {

  126.               delay(5);              //延时

  127.               if(skdw_in!=1)

  128.               sfk=1;                     //上阀如果真的在开的位置SF复位0

  129.        }

  130.        else sfk=0;

  131.        if(sgdw_in!=1)                     //       测试如果上阀在关的位置      

  132.        {

  133.               delay(5);              //延时

  134.               if(sgdw_in!=1)

  135.               sfg=1;                     //上阀如果真的在关的位置SF置位1

  136.        }

  137.        else sfg=0;

  138.        if(xkdw_in!=1)                     //测试如果下阀在开的位置

  139.        {

  140.               delay(5);              //延时

  141.               if(xkdw_in!=1)

  142.               xfk=1;                     //如果下阀还在开的位置,复位XF为0

  143.        }

  144.        else xfk=0;

  145.        if(xgdw_in!=1)                     // 测试如果下阀在关的位置

  146.        {

  147.               delay(5);              //延时

  148.               if(xgdw_in!=1)

  149.               xfg=1;

  150.                                    //如果下阀还是在关位置,置XF为1

  151.        }

  152.        else xfg=0;

  153. }

  154. /************阀门位置指示灯****************************/

  155. void fled()

  156. {

  157.        sgdw_led=!sfg;                    //上阀在关的位置,上关到位灯亮

  158.        skdw_led=!sfk;                              //上阀在开的位置,上开到位灯亮

  159.        xgdw_led=!xfg;                            //下阀在关的位置,下关到位灯亮

  160.        xkdw_led=!xfk;                            //下阀在开的位置,下开到位灯亮

  161.        if(ms)                                          //如果模式是不是0

  162.        {   

  163.          jsums_led=0;                            //计数LED灯亮

  164.          jsms_led=1;                            //计时模式LED灯灭

  165.        }

  166.        else                                             //如果模式是0

  167.        {

  168.           jsms_led=0;                              //计时LED灯亮

  169.           jsums_led=1;                              //计数LED灯灭

  170.        }

  171. }

  172. /****************显示数码管函数*********************/

  173. void display(uchar a,uchar b)

  174. {

  175.        duan=1;                                      //开段选

  176.        P0=dm[a];                               //段码给P0口

  177.        duan=0;                                      //关段选

  178.        wei=1;                                      //开位选

  179.        P0=wm[b];                               //位码给P0口

  180.        wei=0;                                      //关位选

  181.        P0=0xff;                               //消隐

  182.     delay(2);      

  183. }



  184. /**************ISP使能**********************************/

  185. void enable()

  186. {                                                                      //关闭总中断

  187.        EA=0;

  188.        ISP_CONTR=ISP_CONTR|WAITTIME;              //写入硬件等待时间

  189.        ISP_CONTR|=0x80;                                   //启动ISP

  190. }



  191. /***************ISP 禁止*******************************/

  192. void disable()

  193. {

  194.        ISP_CONTR=ISP_CONTR&0x7f;                     //关闭ISP

  195.        ISP_TRIG=0x00;                                          //清0

  196.        EA=1;                                                        //开总中断

  197. }



  198. /*******************触发********************************/

  199. void goon()

  200. {

  201.        enable();

  202.        ISP_TRIG|=0x46;

  203.        ISP_TRIG|=0xb9;

  204. }



  205. /******************读一个字节**************************/

  206. uchar read_byte(uint a)

  207. {

  208.        ISP_ADDRH=(uchar)((a>>8)|ISP_ADDRH);         //地址高位写入

  209.        ISP_ADDRL=(uchar)(a|0x00ff);                       //地址低位写入

  210.        ISP_CMD=ISP_CMD&0xf8;                                     //清低3位

  211.        ISP_CMD=ISP_CMD|RCOMMAND;                              //写入读命令

  212.        goon();                                                                 //触发

  213.        disable();                                                        //关闭

  214.        return ISP_DATA;                                            //返回读出数据

  215. }



  216. /*****************写一个字节****************************/

  217. void write_byte(uint b,uchar c)

  218. {

  219.        ISP_ADDRH=(uchar)((b>>8)|ISP_ADDRH);          //赋值地址高位

  220.        ISP_ADDRL=(uchar)(b|0x00ff);                        //赋值地址低位

  221.        ISP_CMD=ISP_CMD&0xf8;                                      //清低3位

  222.        ISP_CMD=ISP_CMD|WCOMMAND;                               //写入写命令

  223.        goon();                                                                  //触发

  224. //       disable();                                                           //关闭

  225.        ISP_DATA=c;                                                           //把要写入字节赋给寄存器

  226. }            



  227. /******************擦除扇区*****************************/

  228. void sector_erase(uint a)

  229. {

  230.        ISP_ADDRH=(uchar)((a>>8)|ISP_ADDRH);       //赋值地址高位

  231.        ISP_ADDRL=0;                                                 //赋值低位

  232.        ISP_CMD=ISP_CMD&0xf8;                                   //清低3位

  233.        ISP_CMD=ISP_CMD|ECOMMAND;                            //写入擦除命令

  234.        goon();                                                               //触发

  235.        disable();                                                        //关闭

  236. }



  237. /*******************写入调整好的数值数组到EEPROM******************/

  238. void write()

  239. {

  240.     uchar *pa=0x2000;                 //定义指针变量地址是2000

  241.     uchar x,y;

  242.        table[0]=js_gz;                //计时工作工作时间  (e)

  243.        table[1]=js_jg;                       //计时间隔数值         (jsjg)

  244.        table[2]=jisu;            //计数数值                (jisu)

  245.        table[3]=time2;                       //阀门开到位待待进,放料时间  (time)

  246.        table[4]=ys1;             //电机得电检测没到位时间         (ys)

  247.        table[5]=fqwz2;           //电机启动检测没离开位置时间  (fqwz)

  248.        sector_erase(pa);                //擦除2000地址扇区

  249.        for(x=0;x<8;x++)                 //循环

  250.        {

  251.               write_byte(pa+x,table[x]);              //把数组写入EEPROM里

  252.        }

  253.        disable();                                                 //关ISP

  254. }





  255. /***********开机初始化阀门回关位置显示INI**************/

  256. void initia()

  257. {                                                      

  258.      uchar a=4,x;                            //定义延时变量

  259.        uchar *pa=0x2000;              //定义指针变量并赋值为2000                    

  260.       P3=0x0f;                                   //把P3口初化下

  261.          for(x=0;x<8;x++)                     //循环

  262.          {

  263.                 table[x]=read_byte(pa+x);       //读出EEPROM 2000以后连续数赋给数组

  264.          }

  265.          js_gz=table[0];                //把读出来数赋给计时工作变量

  266.          js_jg=table[1];                //把读出来数赋给计时间隔变量

  267.          jisu=table[2];                 //把读出来数赋给计数变量

  268.          time2=table[3];                //把读出来数赋给阀开到位进,放料等待变量

  269.          ys1=table[4];                  //把读出来数赋给检测电机得电多久没到位变量

  270.        // fqwz2=table[5];                //把读出来数赋给检测电机得电多久位置没动变量

  271.        fqwz2=5;//臨時測試

  272.        while(a|((sfg&xfg)!=1))        //如果延时和上阀关下阀关都等于1

  273.     {

  274.          fmwz();                                   //检测阀门位置

  275.          fled();                                   //阀门位置LED

  276.          if(dj)a--;                            //阀门延时变量4秒--

  277.       display(12,5);                     //显示I

  278.       display(13,4);                      //显示N

  279.       display(12,3);                     //显示I

  280.       if(sfg!=1)sgq=1;                     //如果上阀没在关的位置,启动关上阀电机

  281.          else sgq=0;                            //或者上阀关电机停

  282.          if(xfg!=1)xgq=1;                     //如果下阀没在关的位置,启协关下阀电机

  283.          else xgq=0;                            //或者下阀关电机停

  284.        }         

  285. }



  286. /********************显示错误码Error****************/

  287. void error()

  288. {

  289.                     display(15,6);               //显示字符E

  290.                  display(10,5);              //显示字符R

  291.                  display(10,4);              //显示字符R

  292.                  display(11,3);              //显示字符O

  293.                  display(10,2);              //显示字符R

  294.                  cbz=1;                 //错误标志位





  295. //              display(0xff,0x08);       //全部不显示

  296. //              delay(60);                     //延时

  297.   

  298.                                                 

  299. }

  300. /************扫描错阀位置逻辑错误*****************/

  301. void scan_error()

  302. {

  303.        if(sfk&sfg) error(); //如果上阀开,关到位信号同时来显示错误

  304.        if(xfk&xfg) error(); //如果下阀开,关到位信号同时来显示错误

  305.    

  306.        if(skq)                                      //上阀开电机启动

  307.        {

  308.               flag3=1;                        //置标志位FLAG3为1

  309.               if(sfk&(ys>0))flag3=0;    //如果上阀在开位和倒计时大于0成立,清FLAG3为0

  310.               while(!sfk&(ys==0))              //如果过了设定延时,上开位还没到进行死循环

  311.               {

  312.                      error();                        //显示错误码

  313.                      if(err)skdw_led=~skdw_led;         //上阀开到位LED灯闪烁

  314.                      skq=0;                                            //关开上阀电机

  315.                      ys=0;                                          //延时赋0

  316.                      if(!sfg)sgq=1;                            //如果上阀没在关的位置,关上阀电机启动

  317.                      else sgq=0;                                   //或在关位置,停关上阀电机

  318.                      if(!xfg)xgq=1;                            //如果下阀没在关的位置,下阀关电机启动

  319.                      else xgq=0;                                   //或者关下阀电机停止

  320.               }

  321.        }

  322.        if(sgq)                                      //上阀关电机启动

  323.        {

  324.               flag3=1;                        //置标志位FLAG3为1

  325.               if(sfg&(ys>0))flag3=0;    //如果上阀在关位和倒计时大于0成立,清FLAG3为0

  326.               while(!sfg&(ys==0))              //如果过了设定延时,上关位还没到进行死循环

  327.               {

  328.                      error();                        //显示错误码

  329.                      if(err)sgdw_led=~sgdw_led;         //上阀关到位LED灯闪烁

  330.                      sgq=0;                                            //关上阀电机停

  331.                      ys=0;                                          //延时赋0

  332.                      if(!sfg)sgq=1;                            //如果上阀没在关的位置,关上阀电机启动

  333.                      else sgq=0;                                   //或在关位置,停关上阀电机

  334.                      if(!xfg)xgq=1;                            //如果下阀没在关的位置,下阀关电机启动

  335.                      else xgq=0;                                   //或者关下阀电机停止

  336.               }

  337.        }      

  338.        if(xkq)                                      //下阀开电机启动

  339.        {

  340.               flag3=1;                        //置标志位FLAG3为1

  341.               if(xfk&(ys>0))flag3=0;    //如果下阀在开位和倒计时大于0成立,清FLAG3为0

  342.               if(xfk&(ys>0))flag3=0;    //如果下阀在开位和倒计时大于0成立,清FLAG3为0

  343.               while(!xfk&(ys==0))              //如果过了设定延时,下开位还没到进行死循环

  344.               {

  345.                      error();                        //显示错误码

  346.                      if(err)xkdw_led=~xkdw_led;         //下阀开到位LED灯闪烁

  347.                      xkq=0;                                            //关开下阀电机

  348.                      ys=0;                                          //延时赋0

  349.                      if(!sfg)sgq=1;                            //如果上阀没在关的位置,关上阀电机启动

  350.                      else sgq=0;                                   //或在关位置,停关上阀电机

  351.                      if(!xfg)xgq=1;                            //如果下阀没在关的位置,下阀关电机启动

  352.                      else xgq=0;                                   //或者关下阀电机停止

  353.               }

  354.        }      

  355.        if(xgq)                                      //下阀关电机启动

  356.        {

  357.               flag3=1;                        //置标志位FLAG3为1

  358.               if(xfg&(ys>0))flag3=0;    //如果下阀在关位和倒计时大于0成立,清FLAG3为0

  359.               while(!xfg&(ys==0))              //如果过了设定延时,下关位还没到进行死循环

  360.               {

  361.                      error();                        //显示错误码

  362.                      if(err)xgdw_led=~xgdw_led;         //下阀关到位LED灯闪烁

  363.                      xgq=0;                                            //下关阀电机停

  364.                      ys=0;                                          //延时赋0

  365.                      if(!sfg)sgq=1;                            //如果上阀没在关的位置,关上阀电机启动

  366.                      else sgq=0;                                   //或在关位置,停关上阀电机

  367.                      if(!xfg)xgq=1;                            //如果下阀没在关的位置,下阀关电机启动

  368.                      else xgq=0;                                   //或者关下阀电机停止

  369.               }

  370.        }

  371.       

  372.             





  373.        if(skq)                            //如果上阀开电机得电,

  374.        {

  375.               flg2=1;                     //置倒计时标志位为1

  376.               if(sfk)flg2=0;       //如果上阀在开位置,倒计时标志位清0

  377.               else                       //如果上阀没在开的位置

  378.               {

  379.               if((fqwz==0)&sfg)         //倒计时数等于0时间到,上阀还在关的位置

  380.             

  381.                  {       sd1=1;

  382.                        while(sd1)                              //如果设定数为(内参)进行循环显示错误码

  383.                      {

  384.                             error();                       //错误函数

  385.                             if(err)sgdw_led=~sgdw_led;          //上关到位LED灯闪烁

  386.                             skq=0;                                             //关上阀开电机

  387.                      }

  388.               //       if(err)sgdw_led=~sgdw_led;                 //如果设定(内参)为0只上关到位LED闪显示

  389.               }                    

  390.                  }

  391.        }

  392.           if(sgq)                             //如果上阀关电机得电,

  393.        {

  394.               flg2=1;                     //置倒计时标志位为1

  395.               if(sfg)flg2=0;              //如果上阀在关位置,倒计时标志位清0

  396.               else                            //如果上阀没在关的位置

  397.                 if((fqwz==0)&sfk)       //倒计时数等于0时间到,上阀还在开的位置

  398.               {       sd1=1;

  399.                        while(sd1)                //如果设定数为(内参)进行循环显示错误码

  400.                      {

  401.                             error();              //错误函数

  402.                             if(err)skdw_led=~skdw_led;       //上开到位LED灯闪烁

  403.                             sgq=0;                                          //关上阀关电机

  404.                      }

  405.               //       if(err)skdw_led=~skdw_led;              //如果设定(内参)为0只上开到位LED闪显示

  406.               }                    

  407.                

  408.        }

  409.           if(xkq)                             //如果下阀开电机得电,

  410.        {

  411.               flg2=1;                     //置倒计时标志位为1

  412.               if(xfk)flg2=0;                       //置倒计时标志位为1

  413.               else if((fqwz==0)&xfg)         //倒计时数等于0时间到,下阀还在关的位置

  414.               {       sd1=1;

  415.                        while(sd1)                       //如果设定数为(内参)进行循环显示错误码

  416.                      {

  417.                             error();                 //错误函数

  418.                             if(err)xgdw_led=~xgdw_led;       //下关到位LED灯闪烁

  419.                             xkq=0;                                            //关下阀关电机

  420.                      }                                                      

  421.        //              if(err)xgdw_led=~xgdw_led;              //如果设定(内参)为0只下关到位LED闪显示

  422.               }                    

  423.                

  424.        }

  425.               if(xgq)                            //如果下阀关电机得电,

  426.        {

  427.               flg2=1;                        //置倒计时标志位为1

  428.               if(xfg)flg2=0;                     //置倒计时标志位为1

  429.               else if((fqwz==0)&xfk)       //倒计时数等于0时间到,下阀还在开的位置

  430.               {       sd1=1;

  431.                        while(sd1)                     //如果设定数为(内参)进行循环显示错误码

  432.                      {

  433.                             error();                //错误函数

  434.                             if(err)xkdw_led=~xkdw_led;         //下开到位LED灯闪烁

  435.                             skq=0;

  436.                      }                                                          //关下阀开电机

  437.        //              if(err)xkdw_led=~xkdw_led;                //如果设定(内参)为0只下开到位LED闪显示

  438.               }                    

  439.                

  440.        }

  441. }

  442. /*************待机状态*************/

  443. void jsdaiji()

  444. {

  445.     uchar a,b,c,d;

  446.             a=js_jg/10;                                   //计时间隔十位

  447.          b=js_jg%10;                                   //计时间隔个位

  448.          c=js_gz/10;

  449.          d=js_gz%10;

  450.   if(dj)                                           //如果变量DJ等于1

  451.       {                                                  

  452.           display(10,7);                     //显示R字符            

  453.        display(a,2);                     //显示间隔数字十位

  454.        display(b,1);                     //显示间隔数字个位

  455.          }      

  456.   else                                                  //或者变量DJ等于0

  457.       {

  458.            display(11,7);

  459.                 display(c,2);                     //显示工作时间0

  460.               display(d,1);                     //显示工作时间

  461.          }                     

  462. }



  463. /**********计时工作运行函数***************/

  464. void jsigzuo()

  465. {

  466.   

  467.      uchar a,b,c,d;

  468.       

  469.        yx_led=0;                              //运行灯点亮

  470.        a=jsjg/10;                                   //计时间隔十位

  471.        b=jsjg%10;                                   //计时间隔个位

  472.        c=e/10;

  473.        d=e%10;

  474.        if(e<1)                         //计时工作倒计时小于1,计时间隔开始工作

  475.        {      

  476.                  flg=0;                    //计时工作减标志位置0

  477.          if(jsjg==0)                 //如果计时间隔数值倒计时为0

  478.            {

  479.                 e=js_gz;                        //把计时工作时间重新赋给E

  480.                 TR1=0;                        //关闭定时器1,停止计时间隔倒计时

  481.               }

  482.           if(dj)display(10,7);                     //每隔一秒闪一次显示间隔字符

  483.        display(14,7);                       //点小数点

  484.           display(a,2);                            //显示间隔时间

  485.           display(b,1);                            //显示间隔时间



  486.           if(xfg&sfg)                                   //工作模式工作没完成,上下阀都在关

  487.           {

  488.                         skq=0;                                   //开上阀电机停

  489.                      xkq=0;                                   //开下阀电机停

  490.                      sgq=0;                                   //关上阀电机停

  491.                      xgq=0;                                   //关下阀电机停

  492.           }

  493.           else

  494.            {

  495.                      switch(x)

  496.                 {

  497.                     case 0:                                   //状态等于0执行上阀开动作

  498.                           {   if(sfk==0)skq=1;              //如果上阀没要开位,上开阀电机得电启动

  499.                            else

  500.                              {

  501.                                   skq=0;                            //或者上开阀电机停

  502.                                   flg1=1;                            //阀开到位倒计时标志位

  503.                                if(time==1)x=1;              //改状态为1       //上阀开到位,等待时间到

  504.                                 }

  505.                              }       break;            

  506.                  case 1:                     //如果状态是1执行上阀关

  507.                        {

  508.                               flg1=0;              //阀开到位倒计时标志位            

  509.                         sgq=1;                            //上阀关电机启动

  510.                                  if(sfg==1)         //如果上阀关到位,上阀电机停

  511.                                 {

  512.                                    sgq=0;              //上阀关电机启动

  513.                                    x=3;                  //改状态为3

  514.                                 }

  515.                        } break;               

  516.                           case 3:                            //如果状态为3执行下阀开电机启动

  517.                

  518.                            {

  519.                                  if(xfk==0)xkq=1;         //如果下阀没开到位下开电机得电

  520.                                  else

  521.                                        {

  522.                                    xkq=0;              //或下阀开到位,下阀开电机停

  523.                                       flg1=1;              //阀开到位倒计时标志位

  524.                                       if(time==1)x=4;       //等待时间到改状态字为4

  525.                                     }

  526.                               }

  527.                                   break;

  528.                        case 4:                                   //状态字为4执行下阀关

  529.                              {

  530.                                   flg1=0;                     //阀开到位倒计时标志位

  531.                                   if(xfk==1) xgq=1;         //如果状态为4下阀关电机启动

  532.                                if(xfg==1)                       // 如果下阀到关位置,

  533.                                    {

  534.                                        xgq=0;         //下阀关电机停

  535. //                                       z=0;

  536.                                        x=0;         //状态字改为0

  537.                                 }

  538.                           }break;

  539.                 }

  540.               }

  541.     }

  542.        if(e>=1)                                   //计时工铁倒计时小于等于1,开始工作

  543.      {                                       

  544.            

  545.               flg=1;                             //置计时工作减标志为1

  546.           if(dj)display(11,7);                     //每隔一秒闪一次显示工作字符

  547.               display(14,7);

  548.               display(c,2);

  549.               display(d,1);                     //显示工作时间

  550.               if(e==1)                            //如果计时工作变量倒计时等于1

  551.               {

  552.                  jsjg=js_jg;                 //重新给计时间隔赋值

  553.                  TR1=1;                        //开定时器1,启动计时间隔减



  554.               }

  555.          switch(x)

  556.          {

  557.            case 0:                                   //状态等于0执行上阀开动作

  558.                  {   if(sfk==0)skq=1;              //如果上阀没要开位,上开阀电机得电启动

  559.                else

  560.                   {

  561.                         skq=0;                            //或者上开阀电机停

  562.                         flg1=1;                            //阀开到位倒计时标志位

  563.                      if(time==1)x=1;              //改状态为1       //上阀开到位,等待时间到

  564.                      }

  565.               }       break;            

  566.         case 1:                     //如果状态是1执行上阀关

  567.             {

  568.                    flg1=0;              //阀开到位倒计时标志位            

  569.              sgq=1;                            //上阀关电机启动

  570.                      if(sfg==1)         //如果上阀关到位,上阀电机停

  571.                        {

  572.                         sgq=0;              //上阀关电机启动

  573.                         x=3;                  //改状态为3

  574.                        }

  575.              } break;               

  576.                  case 3:                            //如果状态为3执行下阀开电机启动

  577.                

  578.                   {

  579.                         if(xfk==0)xkq=1;         //如果下阀没开到位下开电机得电

  580.                         else

  581.                                {

  582.                             xkq=0;              //或下阀开到位,下阀开电机停

  583.                                flg1=1;              //阀开到位倒计时标志位

  584.                                if(time==1)x=4;       //等待时间到改状态字为4

  585.                             }

  586.                        }

  587.                        break;

  588.               case 4:                                   //状态字为4执行下阀关

  589.                   {

  590.                      flg1=0;                     //阀开到位倒计时标志位

  591.                      if(xfk==1) xgq=1;         //如果状态为4下阀关电机启动

  592.                    if(xfg==1)                       // 如果下阀到关位置,

  593.                             {

  594.                                        xgq=0;         //下阀关电机停

  595.               //                         z=0;

  596.                                        x=0;         //状态字改为0

  597.                           }

  598.                   }break;

  599.            }

  600.        }               

  601. }



  602. /*****************计数待机模式********************/

  603. void jsudaiji()

  604. {            

  605.        uchar a,b;

  606.           a=jisu/10;

  607.           b=jisu%10;                           

  608.           display(16,7);                     //显示倒计数字符            

  609.        display(a,2);                     //显示倒计数字十位

  610.        display(b,1);                     //显示倒计数数字个位

  611. }

  612. /****************计数模式运行函数*****************/

  613. void jsugzuo()

  614. {

  615.        uchar a,b,c,d;

  616.        a=jisu/10;

  617.        b=jisu%10;

  618.        yx_led=0;                                 //运行灯点亮

  619.        if(dj)display(16,7);              //显示倒计数字符

  620.        display(c,2);                     //显示倒计数字十位

  621.      display(d,1);                     //显示倒计数数字个位



  622. }



  623. /************计时计数工作模式数值调整************/

  624. void jstz()

  625. {

  626.        uchar a,b,c,d,e,f;

  627.        if((ms==0)&(~qiting)&(seding==1))                 //如果工作在计时待机模式,调整间隔数值

  628.        {

  629.           a=js_jg/10;

  630.           b=js_jg%10;

  631.          

  632.           display(10,7);                         //显示R字符            

  633.        if(dj)                                          //如果T0里计时变量DJ是1

  634.            {

  635.                  display(a,2);                     //显示间隔数字十位

  636.            display(b,1);                     //显示间隔数字个位

  637.               }

  638.         if(shang)js_jg++;                     //如果上按键按下,计时间隔变量加1

  639.            if(xia)js_jg--;                            //如果下按键按下,计时间隔变量减1

  640.            while(shang|xia)                     //检测等待上,下按键抬起

  641.            {

  642.                  key_scan();                            //循环扫描按键

  643.            }                    

  644.        }

  645.        if((ms==0)&(~qiting)&(seding==2))  //如果工作在计时待机模式,调整计时工作数值

  646.        {

  647.           c=js_gz/10;

  648.           d=js_gz%10;

  649.           display(11,7);                     //显示o字符            

  650.        if(dj)                                   //如果T0里计时变量DJ是1

  651.            {

  652.                  display(c,2);                     //显示间隔数字十位

  653.            display(d,1);                     //显示间隔数字个位

  654.               }

  655.       if(shang)js_gz++;                            //如果上按键按下,计时工作变量加1

  656.          if(xia)js_gz--;                            //如果下按键按下,计时工作变量减1

  657.          while(shang|xia)                            //等待上,下按键抬起

  658.            {

  659.                  key_scan();                            //循环扫按键

  660.            }

  661.               write();                    //把修改后数值写入EEPROM

  662.        }

  663.        if((ms==1)&(~qiting)&(seding==1))//如果工作在计数待机模式,调整计数数值      

  664.        {

  665.            e=jisu/10;

  666.               f=jisu%10;

  667.               display(16,7);                     //显示倒计数字符            

  668.         if(dj)

  669.               {

  670.                   display(e,2);                     //显示倒计数字十位

  671.             display(f,1);                     //显示倒计数数字个位

  672.               }

  673.               if(shang)jisu++;                     //如果上按键按下,计数变量加1

  674.            if(xia)jisu--;                            //如果下按键按下,计数变量减1

  675.            while(shang|xia)                     //检测等待上,下按键抬起

  676.            {

  677.                  key_scan();                            //循环扫描按键

  678.            }

  679.                      write();                    //把修改后数值写入EEPROM                                 

  680.        }                    

  681. }

  682. /*********定时器0初始化***********/

  683. void initime0()

  684. {

  685.     TMOD=0X11;             //开启定时器0

  686.        TH0=(65536-45782)/256; //装初值

  687.        TL0=(65536-45782)%256; //装初值

  688.        TH1=(65536-45782)/256;

  689.        TH0=(65536-45782)%256;

  690.        EA=1;                               //开总中断

  691.        ET0=1;                               //开定时器0中断

  692.        ET1=1;

  693.        TR0=1;

  694.        TR1=1;                               //启动定时器0

  695.        time=time2;            //阀门开到位等待时间赋值

  696.        ys=ys1;                //阀门电机得电多久没到位时间赋值

  697. }

  698. /****************计时,计数变量赋值*******************/

  699. void fz()

  700. {

  701.       

  702. }



  703. void main()

  704. {      

  705. //   uchar d ,c;                            //定义变量

  706.          initime0();                            //定时器初始化

  707.        initia();                            //开机初始化

  708.          while(1)                                            //大循环

  709.        {        

  710.          

  711.                 fmwz();                                     //阀门位置

  712.           fled();                                     //阀门位置灯

  713.                 key_scan();                               //键盘扫描

  714.                 if(cbz&rest)ISP_CONTR=0x20;   //如果有错误复位按键按下

  715.        //   if((sfk&sfg)||(xfk&xfg))            //如果阀门位置有逻辑错误

  716.              scan_error();                               //检测阀位置逻辑错误

  717.     //       else

  718.       

  719.            {      

  720.                     jstz();                                //计时数值调整函数

  721.                   if((qiting==0)&(ms==0)&(seding==0))       //启停按钮,模式,设定都是0,执行待机程序

  722.                      {

  723.                         jsdaiji();                                            //计时待机

  724.                         jsjg=js_jg;                                          //把设定的好的计时间隔时间传递给计时间隔变量

  725.                         e=js_gz;

  726.                      }

  727.                   if(qiting&(ms==0))          //启停按钮和计时模式都是1,执行计时程序

  728.                      {

  729.                         jsigzuo();                   //计时工作函数

  730.             

  731.                      }

  732.                      if((qiting==0)&(ms==1))jsudaiji();         //如果启停按钮和计数模式都是1,执行计数程序

  733.                   if(qiting&(ms==1)) jsugzuo();                //计数工作函数

  734.            }

  735.        }

  736. }

  737.    /**********定时器0中断函数***************/

  738. void time0()interrupt 1

  739. {

  740.     static a,er;                                   //定义静态变量A

  741.        TH0=(65536-45872)/256;              //重新装初值

  742.        TL0=(65536-45872)%256;

  743.        a++;                                          //变量A加1

  744.        er++;



  745.        if(er>=30)

  746.        {

  747.            er=0;

  748.            err=~err;              //错误显示如果ER变量中断大于等于30次

  749.        }

  750.        if(a>=20)                                   //如果计满大于等于20次次      

  751.        {

  752.               a=0;                                   //A清0

  753.               if(flg1)time--;                     //阀门开到位等待标志位是1,倒计时减1

  754.               else time=time2;        //如果阀门开到位标志位是0,重新把设定值赋给

  755.               if(flag3)ys--;          //如果阀电机得电标志位,几秒没到是1延时变量值减1

  756.               else ys==ys1 ;            //如果是0重新赋值

  757.               dj=~dj;                                   //变量DJ取反

  758.               if(flg)                                   //如果计时工作变量标志是1

  759.               {

  760.                      e--;                            //计时工作变量E减1

  761.               }

  762.               if(flg2)fqwz--;

  763.               else fqwz=fqwz2;                                 

  764.        }

  765. }

  766. /**********定时器1中断函数****************/

  767. void time1()interrupt 3

  768. {

  769.     static b;

  770.        TH1=(65536-45782)/256;

  771.        TL1=(65536-45782)%256;

  772.        b++;                                     //中断一次B增加1

  773.        if(b>=20)                              //如果中断20次就是一秒

  774.        {

  775.               b=0;                              //变量赋0

  776.               jsjg--;                       //计时间隔变量减1

  777.                     

  778.        }

  779. }
复制代码



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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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