GC23005/Machine/XinYeMachine/XYChuantou_HeLian.c

#include "global.h"

#if XIN_YE_MACHINE  ==  1

void XY_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag);
void XY_CTHL_ManualAction(void);
void XY_CTHL_AutoStepAction(void);
void XY_CTHL_TableAction(void);
void XY_CTHL_TD_Motor(void);
void XY_CTHL_CL_Motor(void);
void XY_CTHL_CheckStart(void);
void XY_CTHL_TLiao_Step(void);  //推料(推拉头)
void XY_CTHL_AlarmProtect(void);
void XY_CTHL_ZLT_Step(void);
void XY_CTHL_ZhenDongAction(void);
void XY_CTHL_bFKCXTDDWStep(void);
void XY_CTHL_bCXCRStep(void);
void XY_CTHL_bCLFirstStep(void);


void ExtiAcitionX02(void)
{
  if(bCheckEN_FLG)
  {  
    bCheckEN_FLG = 0;
    XY_CTHL_CheckInX02PosBuff = GetPos(X_AXIS);
  }    
}

//故障报警
void XY_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag)
{
  SetAlarmCode(XY_CTHL_ALARM_ADDR,alarm_code);
  //  bAlarmStop = 0;
  // if(cStopFlag)
  if(!cWULATOUCnt && !cXiaoChaCNT && !cCHULIANBAOJIN)
  {
    bAlarmStop = 1;
  }
  else
  {
    cWULATOUCnt=0;
  }
  
  
  
}

//初始化动作
void XY_CTHL_InitAction(void)
{
  float buff_pulse,buff_dist;
  
  buff_pulse  = XY_CTHL_PARAM_CYCLE_PULSE;
  buff_dist   = XY_CTHL_PARAM_CYCLE_LENGTH; 
  
  XGearRatio  =  buff_pulse/buff_dist; 
  
  buff_pulse  = 2000;//XY_CTHL_PARAM_CYCLE_PULSE;
  buff_dist   = 750;//XY_CTHL_PARAM_CYCLE_LENGTH;
  YGearRatio  =  buff_pulse/buff_dist;
  
  
  
  bYFirstDingWeiFlg = 1;
  user_datas[121] = 0;
  user_datas[122] = 0;
  user_datas[123] = 0;
  
  SetEnReverse(X_AXIS, 1);
  SetEnReverse(Y_AXIS, 1);
  SetEnReverse(Z_AXIS, 1);
  
  SetDirReverse(X_AXIS, 0);
  SetDirReverse(Y_AXIS, 0);
  SetDirReverse(Z_AXIS, 0);
  
  SetEn(X_AXIS, MOTOR_DISEN);
  SetEn(Y_AXIS, MOTOR_DISEN);
  SetEn(Z_AXIS, MOTOR_DISEN);
  
  SetAlarmCode(XY_CTHL_ALARM_ADDR,0); 
  //    QDCT_SZ_OUT   = QDCT_MOTOR_DISEN;
}

void XY_CTHL_Action(void)
{ 
  user_datas[121] = XY_CTHL_LianLengSave;
  //   user_datas[122] =axis_x->cur_speed;
  //  user_datas[123] = XY_CTHL_bCXCR_Step;
  dwXRealPos = GetPos(X_AXIS);
  dwYRealPos = GetPos(Y_AXIS);
  dwZRealPos = GetPos(Z_AXIS);  
  user_datas[124] = dwXRealPos;
  user_datas[125] = dwYRealPos;
  
  user_datas[126] = XY_CTHL_CL_MotorStep;
  user_datas[127] = XY_CTHL_TD_MotorStep;
  user_datas[128] = XY_CTHL_AutoStep;  
  
  XY_CTHL_ZhenDongAction();
  XY_CTHL_AlarmProtect();
  XY_CTHL_CheckStart();    
  XY_CTHL_ZLT_Step();
  XY_CTHL_TLiao_Step();
  
  XY_CTHL_TD_Motor();
  XY_CTHL_CL_Motor();
  XY_CTHL_bFKCXTDDWStep();
  XY_CTHL_bCXCRStep();
  XY_CTHL_bCLFirstStep();
  XY_CTHL_ManualAction();
  
  XY_CTHL_AutoStepAction();  
}

void XY_CTHL_AlarmProtect(void)
{ 
  
  
  
}


//自动动作
void XY_CTHL_AutoStepAction(void)
{  
  
  
  
  if(bRunning)
  {
    switch(XY_CTHL_AutoStep)
    {
    case 1:
      if(XY_CTHL_SF_Origin_IN || cBanAuTo)
      {
        /*       XY_CTHL_AutoStep = 10;       //测试拖带定位
        XY_CTHL_AutoDelay = dwTickCount + 1000;
        break; */
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
          XY_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
          XY_CTHL_FKGD_VAVLE = 0;     //方块固定关
          //    XY_CTHL_XKDW_VAVLE = 1;
          XY_CTHL_AutoStep = 2;
          //     XY_CTHL_AutoDelay = dwTickCount + 10;
          if(XY_CTHL_ZhuangLiaoStep == 0)
          { 
            XY_CTHL_ZhuangLiaoStep = 1;
            XY_CTHL_TryCnt = 0;
          }   
        }
      }
      break;
    case 2: 
      if(!XY_CTHL_XKTD_Origin_IN)// && (dwTickCount >= XY_CTHL_AutoDelay))  //斜口推带原位离开
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 3;
          XY_CTHL_XKDW_VAVLE = 1;
          XY_CTHL_AutoDelay = dwTickCount + 20;
        }
      }  
      break;
    case 3://斜口定位
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {                   
        XY_CTHL_AutoStep = 4;
        //         XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XKDW_TD_DELAY;
      }  
      break;
    case 4:
      if(!cBanAuTo)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          AxisMovePosAccDecNotStop(X_AXIS,1600,1500,600,1000,15,30,00); 
          XY_CTHL_AutoStep = 5;
          XY_CTHL_XSavePosBuff = dwXRealPos;
          //       SetPos(X_AXIS, 0);  //启动位置设为0点
          if(cZipCnt < 1)
            XY_CTHL_AutoDelay = dwTickCount +350;
          else
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_FKJD_DELAY;
        }
      }
      else
      {
        XY_CTHL_AutoStep = 5;
        XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_FKJD_DELAY;
        XY_CTHL_XSavePosBuff = dwXRealPos;
      }
      
      break;
    case 5:
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
        
      }
      if(bCL_EN_FLG && (dwXRealPos >= 230) && XY_CTHL_XKSC_Limit_IN)
      {                    
        XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
      }
      
      if(XY_CTHL_XKSC_Limit_IN)   //方块上止到位
      {
        AxisEgmStop(X_AXIS);
        // AxisMovePosAccDec(X_AXIS,1200,10,1200,1200,6,6,0); 
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_QDXK_VAVLE = 1;
          XY_CTHL_FKJD_VAVLE=0;
          
          XY_CTHL_AutoStep = 6;
          //                   
          
          XY_CTHL_bLTCHECK_Delay = dwTickCount + 20;
          //电机穿入可以启动
          bCL_OK_FLG = 1;   //不用穿合链的话认为已经完成
          if(bCL_EN_FLG)
          {
            bCL_OK_FLG = 0;
            XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
            XY_CTHL_CL_MotorStep = 1;
            XY_CTHL_CL_MotorDelay = dwTickCount + XY_CTHL_PARAM_HLJJ_CL_DELAY;
            
            XY_CTHL_AutoDelay = dwTickCount + 50 + XY_CTHL_PARAM_HLJJ_CL_DELAY;  
          }
          else
          {
            XY_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭      
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;       
          }   
        }
      }
      else if(dwXRealPos >= (XY_CTHL_XSavePosBuff + 3000))
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_FKCXDW_ALARM,bRunning);  //方块插销定位异常警告
        
      }  
      break;
    case 6:
      if((dwYRealPos > 1000) || XY_CTHL_CL_MotorStep==0)
      {
        XY_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭      
        XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;    
      }  
      
      if(XY_CTHL_XKTD_Origin_IN)      //斜口推带回到原位
      {
        if(bZhuangLiaoOkFlg && (XY_CTHL_ZhuangLiaoStep == 0))
        {
          if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
          {
            if(dwTickCount >= XY_CTHL_bLTCHECK_Delay)
            {
              if(bSingOneFlg)
              {
                XY_CTHL_AutoStep = 0;
                bRunning = 0;
              }     
              else
              {   
                if(!XY_CTHL_LTou_Check)
                {
                  if(XY_CTHL_PARAM_TDFZ_LENTH && !X_DRV)  //拖带电机反转
                  {
                    AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_DXKFZ_LENTH,800,600,6,6,0); 
                    if(!XY_CTHL_PARAM_NLSL_MODE)
                      XY_CTHL_FKJD_VAVLE= 0;   //方块夹带气缸关
                    
                  }
                  if(XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE = 1;
                  XY_CTHL_CTXM_VAVLE = 1; //穿头下模上升
                  XY_CTHL_AutoStep = 7;
                  XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
                }
                else
                {
                  cWULATOUCnt=1;
                  XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);  // 没有拉头                               
                }
              }
            }
          } 
        }
      }
      else if((dwTickCount >= XY_CTHL_AutoDelay) && !XY_CTHL_XKTD_VAVLE  && !cBanAuTo) 
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_Origin_ALARM,bRunning); //斜口推带回到异常
      }
      break;
    case 7: 
      if(!XY_CTHL_CTM_Origin_IN)
      {
        XY_CTHL_JLTou_VAVLE = 0;    //接拉头
      }
      if(XY_CTHL_CTM_Limit_IN) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          if(XY_CTHL_PARAM_NLSL_MODE)
          {
            
            XY_CTHL_XKTD_VAVLE=1;
          }
          XY_CTHL_JLTou_VAVLE = 0;
          XY_CTHL_AutoStep = 8;    
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_DXKYS_DELAY;
        }
        
      }  
      else if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Limit_ALARM,bRunning);  //穿头下模上升异常
      }
      break;
      
    case 8:
      if(!X_DRV)  //延时顶斜口
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          if((dwTickCount >= XY_CTHL_AutoDelay) || (XY_CTHL_PARAM_NLSL_MODE))
          {  
            if(!XY_CTHL_PARAM_NLSL_MODE)
              XY_CTHL_DXK_VAVLE=1;
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_DXK_XKDW_Off_DELAY;
            XY_CTHL_AutoStep = 9;
          }
        }
        
      }
      break;
    case 9: 
      if((dwTickCount >= XY_CTHL_AutoDelay) && (bCL_OK_FLG))  //顶斜口延时退斜口上止定位
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          //                   AxisMovePosAccDec(X_AXIS,2000,-150,1200,1200,3,6,0);  //反转1.5CM
          XY_CTHL_XKDW_VAVLE = 0;    //斜口上止定位关
          XY_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
          XY_CTHL_AutoStep = 10;    
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XK_CR_DELAY;
        }
      }              
      break;
    case 10:  
      if(!cBanAuTo)
      {
        if((dwTickCount >= XY_CTHL_AutoDelay) && !X_DRV)
        {
          if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
          {
            XY_CTHL_TD_MotorStep = 10;   //启动拖带穿入            
            XY_CTHL_AutoStep = 11;  
          }
          
        }
      }
      else
      {
        XY_CTHL_AutoStep = 801; 
        XY_CTHL_AutoDelay = dwTickCount + 1000;
        cCHULIANBAOJIN=1;
      }
      break;
    case 801:
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        
        bRunning=0;
        cBanAuTo=0;
        XY_CTHL_QDXK_VAVLE=0;
        XY_CTHL_XKTD_VAVLE = 0;
        XY_CTHL_DXK_VAVLE=0;
        XY_CTHL_AutoStep = 0; 
        
      }
      break;
    case 11:
      
      if(XY_CTHL_TD_MotorStep == 0)  //穿入定位完成
      {      
        /*   //测试拖带定位  
        XY_CTHL_AutoStep = 1;       
        XY_CTHL_AutoDelay = dwTickCount + 1000;
        if(cZipCnt<3)
        cZipCnt++;
        break;  */
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          
          XY_CTHL_XKDW_VAVLE = 0;    //斜口上止定位关
          XY_CTHL_XKTD_VAVLE = 1;     //斜口推带气缸输出 
          XY_CTHL_CXSCDW_VAVLE = 1;   //Y21 插销上止定位电磁阀
          cXcxcrCnt = 0;
          if(XY_CTHL_CL_MotorStep == 0)
          {                          
            XY_CTHL_CXQJD_VAVLE = 1;
          }                 
          XY_CTHL_AutoStep = 12; 
          XY_CTHL_AutoDelay = dwTickCount;
        }
        
      }  
      break;        
    case 12: 
      if(XY_CTHL_CL_MotorStep == 0)  //插销前夹带回到原位
      {
        if(XY_CTHL_SF_Origin_IN)
        {
          if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
          {
            XY_CTHL_AutoStep = 14; 
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XCQJD_XCDW_DELAY;
            if(cXcxcrCnt != 1)
            {                        
              XY_CTHL_CXQJD_VAVLE = 1;                    
            }
          }
        }
        else if(!XY_CTHL_SF_Origin_IN)
        {
          XY_CTHL_CL_MotorStep = 50;  //伺服回原点  
          
        }
        
      }
      break;
    case 14:
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_XKDW_VAVLE = 1; //斜口定位 
          XY_CTHL_AutoStep = 15; 
          XY_CTHL_FKGD_VAVLE = 1;     //方块固定
          //Y轴启动插销
          if(cXcxcrCnt != 1)
          {   
            XY_CTHL_CL_MotorStep = 20;  //插销定位     
          }
        }
      }
      break;
    case 15:   
      if(XY_CTHL_CL_MotorStep == 0)   //插销定位完成
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 16; 
          XY_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
          XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
          XY_CTHL_AutoDelay = dwTickCount + 10;  //延时插销下移
        }
      }  
      break;
    case 16: 
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 17; 
          if(XY_CTHL_PARAM_CXXY_MODE)
            XY_CTHL_CXXY_VAVLE = 0;
          else
            XY_CTHL_CXXY_VAVLE = 1;     //Y06 插销下移电磁阀
          XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
        }
      }
      break;
    case 17:   
      if(XY_CTHL_PARAM_CXXY_MODE)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          if(XY_CTHL_CXXY_Limit_IN)
          {
            XY_CTHL_AutoStep = 18; 
            if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
            {
              AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);               
            }
            XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀     
            XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
            XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_SCDWOff_CXDW_DELAY;
          }
          
        }  
        else if(dwTickCount >= XY_CTHL_AutoDelay)  
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_CXXY_Limit_ALARM,bRunning); //插销下移异常
          
        }
      }
      else
      {        
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 18; 
          if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
          {
            AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);               
          }
          XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
          XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关   
          
          XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_SCDWOff_CXDW_DELAY;    
        }
      }
      break;
    case 18:   
      //              if(START_IN_UP)
      {
        if(dwTickCount >= XY_CTHL_AutoDelay) 
        {
          if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
          {
            XY_CTHL_AutoStep = 19; 
            cBAOHUCNT=0;
            XY_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
            XY_CTHL_AutoDelay = dwTickCount + 500;  //插销穿入到位异常时间
            XY_CTHL_CL_MotorStep = 50;  //合链电机回原点
          }
        }
      }
      break;
    case 19:   
      
      if(XY_CTHL_CX_Limit_IN && (cXcxcrCnt<4))
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          cXcxcrCnt=0;
          cXiaoChaCNT=0;
          user_datas[100]=0;
          bZhuangLiaoOkFlg = 0;
          XY_CTHL_CXXY_VAVLE=0;
          XY_CTHL_AutoStep = 901;
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_FKGD_DELAY; //退方块固定时间
          XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
        }
        
      }  
      else if ((dwTickCount >= XY_CTHL_AutoDelay) && (cXcxcrCnt<3) )
      {
        cXcxcrCnt++;
        XY_CTHL_CXHJD_VAVLE=0;
        XY_CTHL_CXHDW_VAVLE=0;
        if(!XY_CTHL_PARAM_CXXY_MODE)
          XY_CTHL_CXXY_VAVLE=0;
        else
          XY_CTHL_CXXY_VAVLE=1;
        if(cXcxcrCnt<3)
        {
          XY_CTHL_CXSCDW_VAVLE=1;
          XY_CTHL_AutoStep = 12;
          XY_CTHL_AutoDelay = dwTickCount + 120;
        }
      }
      else if((dwTickCount >= (XY_CTHL_AutoDelay +3000))  && !XY_CTHL_CX_Limit_IN )
      {
        cXiaoChaCNT=1;
        if(!XY_CTHL_PARAM_CXXY_MODE)
          XY_CTHL_CXXY_VAVLE=0;
        else
          XY_CTHL_CXXY_VAVLE=1; 
        XY_CTHL_CXHJD_VAVLE =0;
        
        cBAOHUCNT=1;
        XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
      }
      
      if( cXcxcrCnt > 2) 
      {
        cXiaoChaCNT=1;
        
        XY_CTHL_CXXY_VAVLE=0;
        XY_CTHL_CXHJD_VAVLE =0;
        cBAOHUCNT=1;
        XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
      }
      
      break;
      
    case 901:
      if(dwTickCount >= XY_CTHL_AutoDelay)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
          XY_CTHL_AutoStep = 20;
          if(!cBAOHUCNT)
            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
          else
          {
            XY_CTHL_AutoDelay = dwTickCount + 1000;//手动插销保护时间
            cBAOHUCNT=0;
          }
        }
        
      }
      break;
    case 20:  
      if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 21;
          XY_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
        }
      }
      break;
    case 21:   
      if(!XY_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 22;
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
        }
      }
      else if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
      }
      break;
    case 22:
      if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 23;
          XY_CTHL_MGuo_VAVLE = 0;     //码勾退
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_MGOff_XiaMo_DELAY;
          XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
          XY_CTHL_FKJD_VAVLE=0;
          XY_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
          XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀关
        }
      } 
      break;
    case 23:  
      if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 24;
          XY_CTHL_CTXM_VAVLE = 0; //穿头下模下降
          XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
        }
      } 
      break;
    case 24: 
      if(!XY_CTHL_CTM_Limit_IN)
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 25;
          XY_CTHL_AutoDelay = dwTickCount + 20;  //一次穿入延时返回
        }
      }
      else if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);//穿头下模下降异常
      }
      break;
    case 25:
      if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          XY_CTHL_AutoStep = 26;
          XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
          XY_CTHL_AutoDelay = dwTickCount + 5;
          XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
          //退下出错警告
          XY_CTHL_AutoDelay1 = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
          XY_CTHL_AutoStep1 = 1;
        }
      }
      break;
      
      
    case 26: 
      if(dwTickCount >= XY_CTHL_AutoDelay) 
      {
        if(!XY_CTHL_bDanBu || XY_CTHL_START_IN_UP)
        {
          if(!cCXCONE)
          {
            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出   
            XY_CTHL_FKGD_VAVLE = 0;     //方块固定关            
            XY_CTHL_AutoStep = 2;
            bCL_EN_FLG = 1;
            cXcxcrCnt=0;
            AddToTal(XY_CTHL_TOTAL_ADDR);
            
            CalProSP(XY_CTHL_SPEED_ADDR);
            if(cZipCnt<3)
              cZipCnt++;
          }
          else
          {
            bRunning=0;
            cCXCONE=0;
            XY_CTHL_AutoStep = 0;
            
          }
        }
        
      }
      break;
      
    }   
  }       
  //退下模后启动送拉头
  switch(XY_CTHL_AutoStep1)
  {   
  case 1:
    if(cStopMode==1)
    {
      bCL_EN_FLG=1;
      cStopMode=2;
      bStop=1;
    }
    if(XY_CTHL_CTM_Origin_IN && XY_CTHL_First_CT_Origin_IN)
    {
      XY_CTHL_ZhuangLiaoStep = 1;
      XY_CTHL_TryCnt = 0;
      XY_CTHL_AutoStep1 = 0;
      XY_CTHL_MGuo_VAVLE = 0;
      XY_CTHL_JLTou_VAVLE = 0;
    }
    else if(dwTickCount >= XY_CTHL_AutoDelay1) 
    {
      //穿头模和一次穿入回位异常
      if(!XY_CTHL_CTM_Origin_IN)
        XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);
      else if(!XY_CTHL_First_CT_Origin_IN)
        XY_CTHL_SetAlarmCode(XY_CTHL_First_CT_Origin_ALARM,bRunning);                    
    } 
    break;
    
  }  
  
}





void XY_CTHL_CheckStart(void)
{
  //监控
  if(cBanAuTo)
  {
    XY_CTHL_PARAM_XCRU=1;
  }
  else
  {
    XY_CTHL_PARAM_XCRU=0;
  }
  //监控
  if(cCXCONE)
  {
    XY_CTHL_PARAM_CXCR=1;
  }
  else
  {
    XY_CTHL_PARAM_CXCR=0;
  }
  
  if(cXCXQXQD)
  {
    if(XY_CTHL_START_IN_UP || bStart)
    {
      bStart=0;
      if(!bRunning)
      {
        if(XY_CTHL_SafeDoor_IN )
        {
          bRunning=1;             
          cXCXQXQD =0;  
          XY_CTHL_TD_MotorStep = 0;   
          XY_CTHL_AutoStep=11;
        }
        else
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
        }
      }
    }
    
    
  }
  if(cWULATOUCnt) // 无拉头警告后按
  {
    if(XY_CTHL_START_IN_UP || bStart)
    {
      bStart=0;
      if(!bRunning)
      {
        if(XY_CTHL_SafeDoor_IN)
        {  
          bRunning=1;
          XY_CTHL_TryCnt=0;
          cWULATOUCnt=0;
          XY_CTHL_ZhuangLiaoStep = 1; 
          XY_CTHL_AutoStep=6;
          bTuiLaTouOkFlg = 1;
          bZhuangLiaoOkFlg= 0;
          XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
          XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
        }
        else
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
        }
      }
    }
  }
  if(!XY_CTHL_SafeDoor_IN && bRunning && !cBanAuTo && !cCXCONE)
  {
    bStop=1;
    XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
  }
  
  //启动    自动启动 单一自动	 			
  if((XY_CTHL_START_IN_UP || bStart ) && !cWULATOUCnt  && !cXCXQXQD)
  {
    if(cCHULIANBAOJIN) //无链停机启动
    {
      cCHULIANBAOJIN=0;
      SetEn(X_AXIS, MOTOR_EN);
      //      dwXRealPos=0;
      XY_CTHL_TD_MotorStep=9;
      
      
      if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
      {
        SetClr(Y_AXIS, MOTOR_NOALARM);
        SetClr(X_AXIS, MOTOR_NOALARM); 
        SetEn(X_AXIS, MOTOR_DISEN);
        SetEn(Y_AXIS, MOTOR_DISEN);
        XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
      }
      cZipCnt=0;
      XY_CTHL_TD_MotorDelay = dwTickCount + 500;
      XY_CTHL_AutoDelay = dwTickCount + 150;
      if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
        SetAlarmCode(XY_CTHL_ALARM_ADDR,0);   
      
    }
    
    if(!bRunning)
    {
      if(XY_CTHL_SafeDoor_IN)
      {  
        cStopMode=0;
        bRunning = 1;
        cWULATOUCnt=0;
        cHeLian=0;
        SetEn(X_AXIS, MOTOR_EN);
        SetEn(Y_AXIS, MOTOR_EN);        
        XY_CTHL_CL_MotorStep = 40;
        XY_CTHL_AutoStep = 1;
        bTuiLaTouOkFlg = 1;
        XY_CTHL_PARAM_ZDP_AUTO= 0;
        bZhuangLiaoOkFlg= 0;
        XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
        XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
        //   bCL_EN_FLG = 0;
        cZipCnt = 0;
        cQDXK_DXK=0;
        XY_CTHL_LianLengthCheck = 0;
        cStopInCnt = 0;
      }
      else
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
      }            
    }  
    bStart = 0;
  }   
  
  //停止
  if(XY_CTHL_STOP_IN_UP || bStop)
  {	
    
    if(cStopMode < 2)
      cStopMode++;
    if(bRunning && cStopMode==2)
    {   
      cBanAuTo=0;
      cCXCONE=0;
      bRunning=0;
      cStopMode=0;
      cXcxcrCnt=0;
      cXCXQXQD=0;
      cCHULIANBAOJIN=0;
      cWULATOUCnt=0;
      AxisEgmStop(X_AXIS);
      AxisEgmStop(Y_AXIS);
      XY_CTHL_AutoStep = 0; 
      XY_CTHL_CL_MotorStep =0;      
      XY_CTHL_bCLFirst_Step=0;  
      XY_CTHL_ZhuangLiaoStep=0;
      //  XY_CTHL_XKTD_VAVLE = 0; 
      cQDXK_DXK=0;
      //   XY_CTHL_XKDW_VAVLE =0;
      if(XY_CTHL_SF_ALR_IN )
      {
        XY_CTHL_SF_ALR_CLR=1;
        XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
      }
      if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
      {
        SetClr(Y_AXIS, MOTOR_NOALARM);
        SetClr(X_AXIS, MOTOR_NOALARM);
        XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
      }
      if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
        SetAlarmCode(XY_CTHL_ALARM_ADDR,0);    
      
    }
    else if(!bRunning)
    {
      cBanAuTo=0;
      cCXCONE=0;
      bRunning=0;
      cXcxcrCnt=0;
      cStopMode=0;
      cCHULIANBAOJIN=0;
      cXCXQXQD=0;
      cWULATOUCnt=0;
      bCL_EN_FLG=0;
      AxisEgmStop(X_AXIS);
      AxisEgmStop(Y_AXIS);
      SetEn(X_AXIS, MOTOR_DISEN);
      SetEn(Y_AXIS, MOTOR_DISEN);
      cStopMode=0;
      cQDXK_DXK=0;
      if(XY_CTHL_SF_ALR_IN )
      {
        XY_CTHL_SF_ALR_CLR=1;
        XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
      }
      if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
      {
        SetClr(Y_AXIS, MOTOR_NOALARM);
        SetClr(X_AXIS, MOTOR_NOALARM);
        XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
      }
      XY_CTHL_TLiao_VAVLE=0;             
      XY_CTHL_HSLiao_VAVLE  =0;    
      XY_CTHL_JLTou_VAVLE  =0;     
      XY_CTHL_XKTD_VAVLE  =0;        
      XY_CTHL_XKDW_VAVLE  =0;       
      XY_CTHL_DXK_VAVLE  =0;         
      XY_CTHL_CXXY_VAVLE  =0;         
      XY_CTHL_CTXM_VAVLE =0;         
      XY_CTHL_First_CT_VAVLE =0;     
      XY_CTHL_FKGD_VAVLE =0;         
      XY_CTHL_CXQJD_VAVLE =0;        
      XY_CTHL_CXDWZ_VAVLE  =0;       
      XY_CTHL_CXHJD_VAVLE =0;        
      XY_CTHL_CXHDW_VAVLE =0;        
      XY_CTHL_FKJD_VAVLE  =0;        
      XY_CTHL_HLJJ_VAVLE  =0;                       
      XY_CTHL_CXSCDW_VAVLE =0;
      XY_CTHL_MGuo_VAVLE =0;
      XY_CTHL_QDXK_VAVLE=0;
      
      XY_CTHL_AutoStep = 0;
      XY_CTHL_ZhuangLiaoStep=0;
      XY_CTHL_TLiaoStep=0;
      XY_CTHL_TD_MotorStep=0;
      XY_CTHL_JiaLianStep  =0;        
      XY_CTHL_SongLiaoStep   =0;     
      XY_CTHL_CL_MotorStep =0;      
      XY_CTHL_AutoStep1  =0;
      XY_CTHL_bFKCXTDDW_Step=0;
      XY_CTHL_bCXCR_Step=0;
      XY_CTHL_bCLFirst_Step=0;
      if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
        SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
      SetPos(X_AXIS, 0); 
      
      XY_CTHL_TLiaoStep = 0; 
      XY_CTHL_AutoStep = 0;
      
      //穿合链电机是往零点方向时可以停止
      if(GetDir(Y_AXIS) == DIR_N)
        AxisEgmStop(Y_AXIS);
      
    }
    bStop=0;
  }
  
  if(bAlarmStop)
  {   
    bRunning   = 0;
    bAlarmStop=0;
    cStopMode=0;
    cXcxcrCnt=0;
    AxisEgmStop(X_AXIS);
    AxisEgmStop(Y_AXIS);
    XY_CTHL_AutoStep = 0; 
    cQDXK_DXK=0;
    XY_CTHL_CL_MotorStep =0;      
    XY_CTHL_bCLFirst_Step=0;  
    XY_CTHL_SongLiaoStep =0;
    XY_CTHL_ZhuangLiaoStep=0;
    // XY_CTHL_XKTD_VAVLE = 0; 
    // XY_CTHL_XKDW_VAVLE =0;
    
  }
}   

//拖带电机控制动作  X轴
void XY_CTHL_TD_Motor(void)	 //
{   
#if 1
  switch(XY_CTHL_TD_MotorStep)
  {
    //1步开始，纯定位, 没有穿入
  case 1:
    if(dwTickCount >= XY_CTHL_TD_MotorDelay)  //给锁轴时间
    {
      bCheckEN_FLG = 1;
      XY_CTHL_CheckInX02PosBuff= 0;
      XY_CTHL_TD_MotorStep = 2;   
      SetPos(X_AXIS, 0);  //启动位置设为0点
      AxisContinueMoveAcc(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,DIR_P,800,600,15,15);
      XY_CTHL_X_CXPosBuff=0;
    }  
    break;
  case 2://检测到过链
    if(dwXRealPos > 400)    //穿入2CM后退
    {
      if(XY_CTHL_PARAM_NLSL_MODE)
      {
        XY_CTHL_XKTD_VAVLE=0;
      }
      XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关  
      XY_CTHL_QDXK_VAVLE = 0;
    }    
    if(dwXRealPos >= XY_CTHL_PARAM_WLCDSHEZHI_LENTH)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机              
    }
    if(XY_CTHL_FK_Check)
    {
      XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
      XY_CTHL_QDXK_VAVLE = 0;
      XY_CTHL_XSavePosBuff = dwXRealPos;
      XY_CTHL_TD_MotorStep = 3;  
      user_datas[123] = dwXRealPos - XY_CTHL_CheckInX02PosBuff;
      if((dwXRealPos >= XY_CTHL_CheckInX02PosBuff) && XY_CTHL_CheckInX02PosBuff)
        AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,XY_CTHL_PARAM_first_length,
                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,300,50); 
      else
        AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,XY_CTHL_PARAM_first_length,
                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,300,50); 
    }
    break;
  case 3:    
    if(XY_CTHL_CXSC_Limit_IN_UP)
    {
      XY_CTHL_X_CXPosBuff = dwXRealPos;
      
    }  
    
    if(!X_DRV || (dwXRealPos >= (XY_CTHL_XSavePosBuff + XY_CTHL_PARAM_FKDW_Length)))
    {
      AxisEgmStop(X_AXIS);
      XY_CTHL_TD_MotorStep =4 ; 
      XY_CTHL_LianLengthAutoCheck = dwXRealPos;
    }
    break;
  case 4:
    if(XY_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
    {
      
      if ((dwXRealPos - XY_CTHL_X_CXPosBuff) > (XY_CTHL_PARAM_XCX_LENTH + XY_CTHL_PARAM_XCXWC_LENTH)) 
      {
        //                    user_datas[121] = 1;
        XY_CTHL_TD_MotorStep = 0;
        XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
        
      }         
      
      else if(XY_CTHL_X_CXPosBuff == 0)
      {
        //                    user_datas[121] = 3;
        XY_CTHL_TD_MotorStep = 0;
        XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
      }   
      else
      {
        XY_CTHL_TD_MotorStep = 0;
        XY_CTHL_X_CXPosBuff=dwXRealPos;
        
      }
      
    }
    else
    {
      XY_CTHL_TD_MotorStep = 0;
      //     XY_CTHL_X_CXPosBuff=dwXRealPos;
    }
    break;
  case 9:
    if(dwTickCount >= XY_CTHL_TD_MotorDelay)
    {
      XY_CTHL_TD_MotorStep = 10;
      XY_CTHL_TD_MotorDelay=dwTickCount+500;
      SetEn(X_AXIS, MOTOR_EN);
      
    }
    break;
    //穿拉头定位
  case 10:   
    if(dwTickCount >= XY_CTHL_TD_MotorDelay)
    {
      
      XY_CTHL_TD_MotorStep = 11;
      SetPos(X_AXIS, 0);  //启动位置设为0点
      dwXRealPos = 0;
      AxisContinueMoveAcc(X_AXIS,XY_CTHL_PARAM_TDCR_LowSpeed,DIR_P,1200,1200,15,15);   
      XY_CTHL_CheckInX02PosBuff= 0;
      XY_CTHL_X_CXPosBuff=0;
      bCheckEN_FLG = 1;
    }
    break;
  case 11:  
    if(dwXRealPos > 350)    //穿入2CM后退
    {
      if(XY_CTHL_PARAM_NLSL_MODE)
      {
        XY_CTHL_XKTD_VAVLE=0;
      }
      XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
      XY_CTHL_QDXK_VAVLE =0;
    }
    if(dwXRealPos > XY_CTHL_PARAM_TDCR_LowSpeedLength)    //穿入2CM后退
    {
      
      XY_CTHL_CheckInX02PosBuff= 0;
      XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
      XY_CTHL_QDXK_VAVLE = 0;
      if(XY_CTHL_PARAM_NLSL_MODE)
      {
        XY_CTHL_XKTD_VAVLE=0;
      }
      XY_CTHL_TD_MotorStep = 12;
      if((cZipCnt < 2) || (XY_CTHL_LianLengthCheck < XY_CTHL_PARAM_TDCR_LowSpeedLength))
        AxisContinueMoveAcc(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,DIR_P,3000,600,10,10); 
      else ////两段速度移动距离                
      {  
        
        AxisMovePosAccDecNotStop(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed ,XY_CTHL_LianLengthCheck-(XY_CTHL_PARAM_TDCR_LowSpeedLength),1500,7000,30,300,250); 
        
      }
    }
    
    if(XY_CTHL_FK_Check)    //在这里检测到说明速度还没有起来
    {
      //   XY_CTHL_SongDai_VAVLE=1;
      XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
      XY_CTHL_QDXK_VAVLE = 0;
      if(XY_CTHL_PARAM_NLSL_MODE)
      {
        XY_CTHL_XKTD_VAVLE=0;
      }
      XY_CTHL_TD_MotorDelay= dwTickCount + XY_CTHL_PARAM_FKJDSECONG_DEALY;
      XY_CTHL_LianLengthReal = dwXRealPos;
      
      XY_CTHL_XSavePosBuff = dwXRealPos;
      XY_CTHL_TD_MotorStep = 13;  
      //     user_datas[122] = XY_CTHL_PARAM_FKDW_Length - (dwXRealPos- XY_CTHL_CheckInX02PosBuff);
      
      if((dwXRealPos >= XY_CTHL_CheckInX02PosBuff) && XY_CTHL_CheckInX02PosBuff)
        AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed,XY_CTHL_PARAM_FKDW_Length - (dwXRealPos- XY_CTHL_CheckInX02PosBuff),
                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,250,40); 
      else
        AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed,XY_CTHL_PARAM_FKDW_Length,
                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,250,40); 
      //XY_CTHL_TD_MotorStep = 0;  
    }
    else if(XY_CTHL_CXSC_Limit_IN_UP)
    {
      AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed * 2/3,XY_CTHL_PARAM_FKDW_Length,
                        XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,250,50); 
      
    }
    else if(XY_CTHL_CXSC_Limit_IN_DW)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_DK_ERROR_ALARM,bRunning);
    }
    break;
  case 12://检测到过链  
    
    if(cZipCnt<2)
    { 
      if(dwXRealPos >= XY_CTHL_PARAM_WLCDSHEZHI_LENTH)
      {
        if(bRunning)
        {
          cCHULIANBAOJIN=1;
          SetEn(X_AXIS, MOTOR_DISEN);
          AxisEgmStop(X_AXIS);
          SetPos(X_AXIS, 0);  //启动位置设为0点
          //     dwXRealPos=0;
        }
        XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机             
      }
    }
    else
    {
      if(dwXRealPos >= XY_CTHL_LianLengthAutoCheckERROR + XY_CTHL_PARAM_WUCD_LENTH)
      {
        if(bRunning)
        {
          cCHULIANBAOJIN=1;
          SetEn(X_AXIS, MOTOR_DISEN);
          AxisEgmStop(X_AXIS);
          SetPos(X_AXIS, 0);  //启动位置设为0点
          //     dwXRealPos=0;
        }
        XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机             
      }
      
    }
    if(XY_CTHL_FK_Check)
    {
      
      XY_CTHL_TD_MotorDelay= dwTickCount + XY_CTHL_PARAM_FKJDSECONG_DEALY;
      XY_CTHL_LianLengthReal = dwXRealPos;
      //if(cZipCnt == 1)
      //   user_datas[122] = dwXRealPos;
      //               user_datas[121] = dwXRealPos;
      if((cZipCnt == 1)  || dwXRealPos < (XY_CTHL_LianLengthCheck*0.85) || dwXRealPos>(XY_CTHL_LianLengthCheck*1.3))
        XY_CTHL_LianLengthCheck = dwXRealPos;
      
      XY_CTHL_LianLengthCheckOLD=XY_CTHL_LianLengthNEWCheck;
      XY_CTHL_LianLengthNEWCheck  = dwXRealPos; 
      //break;
      XY_CTHL_XSavePosBuff = dwXRealPos;
      XY_CTHL_TD_MotorStep = 13;  
      //     user_datas[122] = XY_CTHL_PARAM_FKDW_Length - (dwXRealPos- XY_CTHL_CheckInX02PosBuff);
      if(cZipCnt > 1 )
      {
        if((dwXRealPos >= XY_CTHL_CheckInX02PosBuff) && XY_CTHL_CheckInX02PosBuff)
          AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,XY_CTHL_PARAM_FKDW_Length - (dwXRealPos- XY_CTHL_CheckInX02PosBuff),
                            XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,300,50); 
        else
          AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,XY_CTHL_PARAM_FKDW_Length,
                            XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,300,50); 
      }
      else
      {
        
        AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed*2/3,XY_CTHL_PARAM_first_length,
                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,30,300,50); 
      }
      //XY_CTHL_TD_MotorStep = 0;  
    }
    else if(XY_CTHL_CXSC_Limit_IN_UP)
    {
      AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed * 2/3,XY_CTHL_PARAM_FKDW_Length,
                        XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,10,150,50); 
      
    }
    else if(XY_CTHL_CXSC_Limit_IN_DW)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_DK_ERROR_ALARM,bRunning);
    }
    
    break;   
  case 13:
    
    if(dwTickCount >= XY_CTHL_TD_MotorDelay)
    {
      XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
      
    }
    if(XY_CTHL_CXSC_Limit_IN_DW)
    {
      XY_CTHL_X_CXPosBuff = dwXRealPos;
      
    }  
    if((!X_DRV ))// || (dwXRealPos >= (XY_CTHL_XSavePosBuff + XY_CTHL_PARAM_FKDW_Length)))
    {
      // user_datas[123] = dwXRealPos-XY_CTHL_CheckInX02PosBuff;
      
      AxisEgmStop(X_AXIS);
      XY_CTHL_TD_MotorStep = 14; 
      /*       if(cZipCnt>2)
      {
      if(((XY_CTHL_LianLengthNEWCheck+XY_CTHL_LianLengthCheckOLD)*0.5) < (XY_CTHL_LianLengthCheck*0.95))
      {
      cZipCnt=0;  
      cHeLian=1;
    }
    }*/
      if(cZipCnt==1)
        XY_CTHL_LianLengthAutoCheckERROR = dwXRealPos;
      
      if(cZipCnt==1)
        XY_CTHL_LianLengSave=dwXRealPos;
      
      XY_CTHL_LianLengthAutoCheck = dwXRealPos;
      //  user_datas[122] = dwXRealPos-XY_CTHL_X_CXPosBuff;
    }
    break;
  case 14:
    
    if(XY_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
    {
      
      if ((dwXRealPos - XY_CTHL_X_CXPosBuff) > (XY_CTHL_PARAM_XCX_LENTH + XY_CTHL_PARAM_XCXWC_LENTH)) 
      {
        //  user_datas[121] = 1;
        XY_CTHL_TD_MotorStep = 0;
        cXCXQXQD=1;
        XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
        
      }         
      else if((dwXRealPos - XY_CTHL_X_CXPosBuff) < (XY_CTHL_PARAM_XCX_LENTH - XY_CTHL_PARAM_XCXWC_LENTH))
      {
        //   user_datas[121] = 2;
        XY_CTHL_TD_MotorStep = 0;
        cXCXQXQD=1;
        XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
      }    
      else if(XY_CTHL_X_CXPosBuff == 0)
      {
        //    user_datas[121] = 3;
        XY_CTHL_TD_MotorStep = 0;
        cXCXQXQD=1;
        XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
      }   
      else
      {
        
        XY_CTHL_TD_MotorStep = 15;
      }
      
    }
    else
    {
      
      XY_CTHL_TD_MotorStep = 15;
    }
    break;
  case 15:
    //          if(XY_CTHL_START_IN_UP)
    XY_CTHL_TD_MotorStep = 0;
    
    
    break;     
  }   
#endif    
}
//穿入电机动作，Y轴
void XY_CTHL_CL_Motor(void)	 //
{   
#if 0
  //1步开始,  穿链长度开始
  //20步开始  插销定位开始
  //40步,回原点为
  switch(XY_CTHL_CL_MotorStep)
  {
    //穿入长度位置
  case 1:
    
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      // SetDir(Y_AXIS, DIR_P);
      if(XY_CTHL_PARAM_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
        XY_CTHL_PARAM_CL_Length = XY_CTHL_PARAM_CL_MAX_Length;
      //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
      if((XY_CTHL_LianLengthAutoCheck < (XY_CTHL_PARAM_CL_Length + 500 )) && bRunning) 
        AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_LianLengthAutoCheck-500),800,600,6,6,50);       
      else
        AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_PARAM_CL_Length-100),800,600,6,6,50); 
      XY_CTHL_CL_MotorStep = 2; 
    }
    break;
  case 2:
    if((dwYRealPos + 120) > XY_CTHL_PARAM_CL_Length)
      XY_CTHL_HLJJ_VAVLE = 0;
    if(!Y_DRV || dwYRealPos >= XY_CTHL_PARAM_CL_Length)  
    {
      XY_CTHL_HLJJ_VAVLE = 0;
      XY_CTHL_CL_MotorStep = 3;  
      bCL_OK_FLG = 1;
      XY_CTHL_CL_MotorDelay = dwTickCount + 40;  //延时数控回零点
    }
    break; 
  case 3: 
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 50;  
    }
    break;
    //夹带插销到穿入位置  
  case 20: //此处最好算好定位长度相减
    if(cXcxcrCnt > 0)
    {
      XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length + 30; 
      XY_CTHL_CL_MotorStep = 21;
    }
    else
    {
      XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length ;
      XY_CTHL_CL_MotorStep = 21;
    }         
    break;
  case 21:
    SetDir(Y_AXIS, DIR_P);
    AxisMovePosAccDec(Y_AXIS,8000,XY_CTHL_LENTH,800,500,6,6,50);            
    XY_CTHL_CL_MotorStep = 22; 
    break;
  case 22: 
    if(!Y_DRV || (dwYRealPos >= XY_CTHL_LENTH)) //插销定位已经结束
    {
      AxisEgmStop(Y_AXIS);
      XY_CTHL_YsaveCXDWPosBuff = 0;
      XY_CTHL_CL_MotorStep = 0;                       
    } 
    break;
    //回原点开始
  case 40: 
    //要先离开    
    if(XY_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
    {
      XY_CTHL_CL_MotorStep = 41; 
      SetDir(Y_AXIS, DIR_P);
    }    
    else  
    {
      SetDir(Y_AXIS, DIR_N);
      XY_CTHL_CL_MotorStep = 46;
      
    }    
    if(GetEn(Y_AXIS) == MOTOR_DISEN) 
    {
      SetEn(Y_AXIS, MOTOR_EN);
      XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
      
    }
    else  //已经锁轴
      XY_CTHL_CL_MotorDelay = dwTickCount + 5;            
    break;
  case 41:
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 42; 
      AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
    }
    break;
  case 42:
    if(!XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 43; 
      XY_CTHL_YSavePosBuff = dwYRealPos;
    }
    break;
  case 43:    
    //离开原点5CM停止
    if((dwYRealPos - XY_CTHL_YSavePosBuff) >= 800)
    {
      AxisEgmStop(Y_AXIS);
      XY_CTHL_CL_MotorStep = 46; //留空几步备用
      XY_CTHL_CL_MotorDelay = dwTickCount + 50;  
    }
    break;
  case 46:  
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 47; //检测回到原位
      if(!XY_CTHL_SF_Origin_IN)
        AxisContinueMoveAcc(Y_AXIS,1500,DIR_N,1000,800,15,10);
    }
    break;
  case 47: 
    if(XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 0;       
      AxisEgmStop(Y_AXIS); 
      SetPos(Y_AXIS, 0);
    }    
    break;
    //数控回原位 (条件为自动工作，SON一直没有松开)  
  case 50: 
    if(dwYRealPos > 150)
    {  //回零速度
      SetDir(Y_AXIS, DIR_N);
      AxisMovePosAccDecNotStop(Y_AXIS,XY_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos + 150,5000,2000,10,50,50);
      
      
    } 
    else
      AxisContinueMoveAcc(Y_AXIS,1000,DIR_N,1000,1000,15,15);
    XY_CTHL_CL_MotorStep = 51; 
    break;
  case 51: 
    if(XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 0;       
      AxisEgmStop(Y_AXIS); 
      SetPos(Y_AXIS, 0);
    } 
    break;
    
  }
#endif
  
#if 1
  //1步开始,  穿链长度开始
  //20步开始  插销定位开始
  //40步,回原点为
  switch(XY_CTHL_CL_MotorStep)
  {
    //穿入长度位置
  case 1:     
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      if(XY_CTHL_SF_Origin_IN)
      {
        if(!XY_CTHL_PARAM_AUTO_MODE) 
        {
          //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
          if(XY_CTHL_LianLengthAutoCheck <= 700)
          {
            XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-200;
            if(XY_CTHL_Y_CL_Length<10)
              XY_CTHL_Y_CL_Length=200;
            if(XY_CTHL_Y_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
              XY_CTHL_Y_CL_Length = XY_CTHL_PARAM_CL_MAX_Length-40;  
            AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,XY_CTHL_Y_CL_Length,800,600,6,6,50);     
          }
          else if(XY_CTHL_LianLengthAutoCheck>700)
          {
            
            user_datas[123] =XY_CTHL_LianLengthAutoCheck;
            if(cZipCnt>1)
              XY_CTHL_Y_CL_Length=XY_CTHL_LianLengSave-XY_CTHL_PARAM_HLTSY_LENTH-300;
            else
            {
              if(cZipCnt<1)
                XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-XY_CTHL_PARAM_HLTSY_LENTH-100;
              else
                XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-XY_CTHL_PARAM_HLTSY_LENTH-300; 
            }
            
            if(XY_CTHL_Y_CL_Length<200)
              XY_CTHL_Y_CL_Length=200;   
            if(XY_CTHL_Y_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
              XY_CTHL_Y_CL_Length = XY_CTHL_PARAM_CL_MAX_Length-40;  
            AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,XY_CTHL_Y_CL_Length,800,600,6,6,50); 
            
          }
          
        }
        
        else
        {
          if(XY_CTHL_PARAM_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
            XY_CTHL_PARAM_CL_Length = XY_CTHL_PARAM_CL_MAX_Length;
          //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
          if((XY_CTHL_LianLengthAutoCheck < (XY_CTHL_PARAM_CL_Length + 500 )) && bRunning) 
            AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_LianLengthAutoCheck-500),800,600,6,6,50);       
          else
            AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_PARAM_CL_Length-100),800,600,6,6,50); 
          
        }
        XY_CTHL_CL_MotorStep = 2; 
      }
    }
    break;
  case 2:
    if(XY_CTHL_PARAM_AUTO_MODE)
    {
      if((dwYRealPos + 120) > XY_CTHL_PARAM_CL_Length)
        XY_CTHL_HLJJ_VAVLE = 0;
      if(!Y_DRV || dwYRealPos >= XY_CTHL_PARAM_CL_Length)  
      {
        XY_CTHL_HLJJ_VAVLE = 0;
        XY_CTHL_CL_MotorStep = 3;  
        bCL_OK_FLG = 1;
        XY_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
      }
    }
    else
    {
      if((dwYRealPos + 120) > XY_CTHL_Y_CL_Length)
        XY_CTHL_HLJJ_VAVLE = 0;
      if(!Y_DRV || dwYRealPos >= XY_CTHL_Y_CL_Length)  
      {
        XY_CTHL_HLJJ_VAVLE = 0;
        XY_CTHL_CL_MotorStep = 3;  
        bCL_OK_FLG = 1;
        XY_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
      }
      
    }
    break; 
  case 3: 
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 50;  
    }
    break;
    //夹带插销到穿入位置  
  case 20: //此处最好算好定位长度相减
    if(cXcxcrCnt > 0)
    {
      if(cXcxcrCnt==1)
        XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length+XY_CTHL_PARAM_TDFZ_LENTH + 50; 
      if(cXcxcrCnt>1)
        XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length +XY_CTHL_PARAM_TDFZ_LENTH + 120;
      XY_CTHL_CL_MotorStep = 21;
    }
    else
    {
      XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length ;
      XY_CTHL_CL_MotorStep = 21;
    }    
    break;
  case 21:
    if(XY_CTHL_SF_Origin_IN)
    {
      SetDir(Y_AXIS, DIR_P);
      XY_CTHL_Y_CL_PosBuff = dwYRealPos;
      AxisMovePosAccDec(Y_AXIS,20000,XY_CTHL_LENTH,800,500,6,6,50);            
      XY_CTHL_CL_MotorStep = 22; 
    }
    break;
  case 22: 
    if(dwYRealPos >= XY_CTHL_Y_CL_PosBuff+XY_CTHL_LENTH-XY_CTHL_PARAM_CXDW_Length) //插销定位已经结束
    {
      XY_CTHL_CXSCDW_VAVLE = 1;                     
    }
    
    if(!Y_DRV || (dwYRealPos >= XY_CTHL_Y_CL_PosBuff+XY_CTHL_LENTH)) //插销定位已经结束
    {
      AxisEgmStop(Y_AXIS);
      XY_CTHL_YsaveCXDWPosBuff = 0;
      XY_CTHL_CL_MotorStep = 0;                       
    } 
    
    break;
  case 30:
    XY_CTHL_YsaveCXDWPosBuff = 0;
    XY_CTHL_CL_MotorStep = 0;  
    break;
    //回原点开始
  case 40: 
    //要先离开    
    if(XY_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
    {
      XY_CTHL_CL_MotorStep = 41; 
      SetDir(Y_AXIS, DIR_P);
    }    
    else  
    {
      SetDir(Y_AXIS, DIR_N);
      XY_CTHL_CL_MotorStep = 46;
      
    }    
    if(GetEn(Y_AXIS) == MOTOR_DISEN) 
    {
      SetEn(Y_AXIS, MOTOR_EN);
      XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
      
    }
    else  //已经锁轴
      XY_CTHL_CL_MotorDelay = dwTickCount + 5;            
    break;
  case 41:
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 42; 
      AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
    }
    break;
  case 42:
    if(!XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 43; 
      XY_CTHL_YSavePosBuff = dwYRealPos;
    }
    break;
  case 43:    
    //离开原点5CM停止
    if((dwYRealPos - XY_CTHL_YSavePosBuff) >= 800)
    {
      AxisEgmStop(Y_AXIS);
      XY_CTHL_CL_MotorStep = 46; //留空几步备用
      XY_CTHL_CL_MotorDelay = dwTickCount + 50;  
    }
    break;
  case 46:  
    if(dwTickCount >= XY_CTHL_CL_MotorDelay)
    {
      XY_CTHL_CL_MotorStep = 47; //检测回到原位
      if(!XY_CTHL_SF_Origin_IN)
        AxisContinueMoveAcc(Y_AXIS,1500,DIR_N,1000,800,15,10);
    }
    break;
  case 47: 
    if(XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 0;       
      AxisEgmStop(Y_AXIS); 
      SetPos(Y_AXIS, 0);
    }    
    break;
    //数控回原位 (条件为自动工作，SON一直没有松开)  
  case 50: 
    if(dwYRealPos > 151)
    {  //回零速度          
      SetDir(Y_AXIS, DIR_N);
      AxisMovePosAccDecNotStop(Y_AXIS,XY_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos + 150,5000,2500,30,200,00);
    } 
    else
      AxisContinueMoveAcc(Y_AXIS,1000,DIR_N,1000,1000,15,15);
    XY_CTHL_CL_MotorStep = 51; 
    break;
  case 51: 
    if(XY_CTHL_SF_Origin_IN)
    {
      XY_CTHL_CL_MotorStep = 0;       
      AxisEgmStop(Y_AXIS); 
      SetPos(Y_AXIS, 0);
    } 
    break;
    
  }
#endif      
}



//装拉头动作
void XY_CTHL_ZLT_Step(void)
{
  
  switch(XY_CTHL_ZhuangLiaoStep)
  {
  case 1:
    
    if(bZhuangLiaoOkFlg)
    {
      XY_CTHL_ZhuangLiaoStep = 0;
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      
      if(((XY_CTHL_MGuo_VAVLE && XY_CTHL_LTou_Check) || (!XY_CTHL_MGuo_VAVLE)) && !XY_CTHL_JLiao_Limit_IN  )//说明没有拉头
      {       
        //穿头模和一次穿入必须在原位,接料不能有输出
        if(XY_CTHL_CTM_Origin_IN && !XY_CTHL_CTXM_VAVLE)
        {  
          XY_CTHL_First_CT_VAVLE = 0;
          XY_CTHL_JLTou_VAVLE = 0;
          XY_CTHL_MGuo_VAVLE = 0;                     
          if(XY_CTHL_TLiaoStep == 0)
          {
            XY_CTHL_TLiaoStep = 1;        
            XY_CTHL_ZhuangLiaoStep = 2; 
          }
        }
        
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay + 500)  //警告横送拉必须保证穿头模和一次穿入在原位,接料不能有输出
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);
          
        }  
      }
      else  //已经有拉头直接跳到结束
      {
        XY_CTHL_ZhuangLiaoDelay = dwTickCount + 40;
        XY_CTHL_ZhuangLiaoStep = 9;
      }  
    }
    break;            
  case 2:        
    if(XY_CTHL_TLiaoStep == 0)  //推料已经完成
    {
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
      XY_CTHL_JLTou_VAVLE = 0;
      XY_CTHL_MGuo_VAVLE = 0;   
      if(!XY_CTHL_JLiao_Limit_IN && XY_CTHL_First_CT_Origin_IN)
      {
        XY_CTHL_ZhuangLiaoStep = 3;
        XY_CTHL_HSLiao_VAVLE = 1;   
      }
    }
    break;
  case 3:
    //横送到位
    if(XY_CTHL_HSLiao_Limit_IN && !XY_CTHL_HSLiao_Origin_IN)
    {
      XY_CTHL_ZhuangLiaoStep = 4;
      //                XY_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + 5;
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Limit_ALARM,bRunning);
    }
    break;
  case 4:
    if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      XY_CTHL_ZhuangLiaoStep = 5;
      XY_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
    }  
    break;
  case 5:    
    if(XY_CTHL_JLiao_Limit_IN)
    {
      XY_CTHL_ZhuangLiaoStep = 6;
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_MaGou_DELAY;
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)  //接拉头(接料)到们信号异常
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_JLiao_Limit_ALARM,bRunning);
    }
    break;
  case 6:       
    if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)  //延时码勾
    {
      XY_CTHL_MGuo_VAVLE = 1; //码勾输出
      XY_CTHL_ZhuangLiaoStep = 7;
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_HSLiaoOff_DELAY;
      bTuiLaTouOkFlg = 0;   //认为拉头没法带出
    }
    break;
  case 7:  
    if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      XY_CTHL_HSLiao_VAVLE = 0; 
      XY_CTHL_ZhuangLiaoStep = 8;
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
    }
    break;
  case 8:  
    if(!XY_CTHL_HSLiao_Limit_IN)  //
    {
      XY_CTHL_ZhuangLiaoStep = 9;
      XY_CTHL_TLiaoStep = 1; //推拉头
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_CheckLT_DELAY;   //也是给下模能上升的时间
    }          
    else if (XY_CTHL_LTou_Check)  //时间内信号这说明没有拉头
    {
      //重送3次
      XY_CTHL_TryCnt++;
      XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
      XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
      if(XY_CTHL_TryCnt >= 3)
      {
        XY_CTHL_TryCnt = 0;
        bZhuangLiaoOkFlg = 0;
        XY_CTHL_ZhuangLiaoStep = 0;
        XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);
        cWULATOUCnt=1;
      }
      else
      {
        XY_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
        XY_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
      }  
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Limit_ALARM,bRunning);
      if(bRunning)
      {
        XY_CTHL_ZhuangLiaoStep = 0 ;
      }  
    }  
    break;
  case 9:   
    if(XY_CTHL_LTou_Check)  //时间内信号这说明没有拉头
    {
      XY_CTHL_TryCnt++;
      XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
      XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
      if(XY_CTHL_TryCnt >= 3)
      {
        XY_CTHL_TryCnt=0;
        bZhuangLiaoOkFlg = 0;
        XY_CTHL_ZhuangLiaoStep = 0;
        XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);
        cWULATOUCnt=1;
      }
      else
      {
        XY_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
        XY_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
      }  
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      bZhuangLiaoOkFlg = 1;
      XY_CTHL_ZhuangLiaoStep = 0;
    }
    break;
    //装拉头不成攻重新送拉头
  case 20: 
    if(XY_CTHL_HSLiao_Origin_IN)
    {
      XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
      XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
      XY_CTHL_ZhuangLiaoStep = 1;
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + 10;
    }
    else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Origin_ALARM,bRunning);
    }  
    break;
  }  
}

void XY_CTHL_TLiao_Step(void)
{
  switch(XY_CTHL_TLiaoStep)
  {
  case 1:
    if(bTuiLaTouOkFlg)
    {
      XY_CTHL_TLiaoStep = 0; 
    }
    else
    {
      XY_CTHL_TLiao_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
      XY_CTHL_TLiaoStep = 2;
    }
    break;
  case 2:    //横送料在原位
    if(XY_CTHL_HSLiao_Origin_IN && !XY_CTHL_HSLiao_Limit_IN && !XY_CTHL_HSLiao_VAVLE)
    {
      XY_CTHL_TLiao_VAVLE = 1;    //推料(推拉头)输出
      XY_CTHL_TLiao_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
      XY_CTHL_TLiaoStep = 3;
    }
    else if(dwTickCount >= XY_CTHL_TLiao_Delay) 
      XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Origin_ALARM,1);          
    break;
  case 3:  //推拉头到位
    if(XY_CTHL_TLiao_Limit_IN)
    { 
      XY_CTHL_TLiao_Delay = dwTickCount + XY_CTHL_PARAM_TLiao_BACKDELAY;
      XY_CTHL_TLiaoStep = 4;
    }
    else if(dwTickCount >= XY_CTHL_TLiao_Delay) 
      XY_CTHL_SetAlarmCode(XY_CTHL_TLiao_Limit_ALARM,1);        
    break;
  case 4:
    if(dwTickCount >= XY_CTHL_TLiao_Delay)
    {
      XY_CTHL_TLiao_VAVLE       = 0;
      XY_CTHL_TLiao_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME; 
      XY_CTHL_TLiaoStep = 5;
    }
    break;
  case  5:
    if(!XY_CTHL_TLiao_Limit_IN)
    {
      XY_CTHL_TLiaoStep = 0;
      XY_CTHL_TLiao_Delay = dwTickCount;
      bTuiLaTouOkFlg    = 1;
    }
    else if(dwTickCount >= XY_CTHL_TLiao_Delay) 
      XY_CTHL_SetAlarmCode(XY_CTHL_TLiao_Limit_ALARM,0);    
    break;
  } 
  
}
//振动盘控制
void XY_CTHL_ZhenDongAction(void)
{
  
#if 0  
  if((XY_CTHL_bDLP || bRunning) && XY_CTHL_ZhenDongPian_OUT && XY_CTHL_PARAM_DALIAOPIAN)
  {        
    if(CT_DLP_Time >= dwTickCount)
    {
      CT_ZDP_Delay = dwTickCount + CT_PARAM_DLP_TIME + 40;  
      CT_DaLaPian_VAVLE = ~CT_DaLaPian_VAVLE;
    }
  }
  else
    CT_DaLaPian_VAVLE = 0;   
#endif
  
#if 1  
  
  //    if(bRunning)
  //    {
  switch(XY_CTHL_PARAM_ZDP_AUTO)
  {
  case 0:
    if(XY_CTHL_ZhenDongPian_OUT == 0)
    {
      if(!XY_CTHL_ZDP_IN)
      {
        if(dwTickCount >= XY_CTHL_ZDP_Delay)
        {
          XY_CTHL_ZhenDongPian_OUT = 1;
          XY_CTHL_ZDP_Delay = dwTickCount + XY_CTHL_PARAM_ZDP_Stop_TIME;//XY_CTHL_PARAM_ZDP_Stop_TIME + 50;
        }
      }
      else
      {
        XY_CTHL_ZDP_Delay = dwTickCount + XY_CTHL_PARAM_ZDP_Start_TIME;//XY_CTHL_PARAM_ZDP_Start_TIME;
      }   
    }
    else
    {  
      if(XY_CTHL_ZDP_IN)
      {  
        if(dwTickCount >= XY_CTHL_ZDP_Delay)
        {
          XY_CTHL_ZhenDongPian_OUT = 0;  
          XY_CTHL_ZDP_Delay = dwTickCount + XY_CTHL_PARAM_ZDP_Start_TIME;//XY_CTHL_PARAM_ZDP_Start_TIME
        }
      }
      else
        XY_CTHL_ZDP_Delay = dwTickCount + XY_CTHL_PARAM_ZDP_Stop_TIME;//XY_CTHL_PARAM_ZDP_Stop_TIME+ 50;
    }
    break;
  case 1:
    XY_CTHL_ZhenDongPian_OUT=0;
    XY_CTHL_ZDP_Delay = dwTickCount;
    break;
  case 2:     
    XY_CTHL_ZhenDongPian_OUT=1;
    XY_CTHL_ZDP_Delay = dwTickCount;
    break;
  }    
  if(XY_CTHL_ZhenDongPian_OUT)
  {
    if(XY_CTHL_PARAM_LaPian_EN)
    {
      if(dwTickCount >= XY_CTHL_DLP_Delay)
      {
        
        XY_CTHL_DaLaPian_OUT = !XY_CTHL_DaLaPian_OUT;
        
        if(XY_CTHL_DaLaPian_OUT)
          XY_CTHL_DLP_Delay = dwTickCount + XY_CTHL_PARAM_DaLaPian;
        else
          XY_CTHL_DLP_Delay = dwTickCount + XY_CTHL_PARAM_DaLaPian+50;
      }  
    }
    else
      XY_CTHL_DaLaPian_OUT = 0;      
  }
  else
    XY_CTHL_DaLaPian_OUT = 0;
#endif    
}
void XY_CTHL_bFKCXTDDWStep(void)
{
  switch(XY_CTHL_bFKCXTDDW_Step)
  {
  case 1:
    XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
    XY_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
    XY_CTHL_FKGD_VAVLE = 0;     //方块固定关
    XY_CTHL_bFKCXTDDW_Step = 2;
    
    break;
  case 2: 
    if(!XY_CTHL_XKTD_Origin_IN)  //斜口推带原位离开
    {
      XY_CTHL_bFKCXTDDW_Step = 3;
      XY_CTHL_bFKCXTDDW_Delay = dwTickCount + 20;
    }  
    break;
  case 3://斜口定位
    if(dwTickCount >= XY_CTHL_bFKCXTDDW_Delay)
    {
      XY_CTHL_XKDW_VAVLE = 1;
      XY_CTHL_bFKCXTDDW_Step = 4;
      //         XY_CTHL_bFKCXTDDW_Delay = dwTickCount + XY_CTHL_PARAM_XKDW_TD_DELAY;
    }  
    break;
  case 4:
    if(dwTickCount >= XY_CTHL_bFKCXTDDW_Delay)
    {
      AxisContinueMoveAcc(X_AXIS,1200,DIR_P,800,600,10,10);//拖带电机                       
      XY_CTHL_bFKCXTDDW_Step = 5;
      XY_CTHL_XSavePosBuff = dwXRealPos;
      SetPos(X_AXIS, 0);  //启动位置设为0点
      dwXRealPos = 0;
    }
    break;
  case 5:
    if(XY_CTHL_XKSC_Limit_IN)   //方块到位
    {
      AxisEgmStop(X_AXIS);
      XY_CTHL_QDXK_VAVLE=1;
      XY_CTHL_bFKCXTDDW_Step = 6;
      XY_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭 
      XY_CTHL_bFKCXTDDW_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
      
    }
    else if(dwXRealPos >= (XY_CTHL_XSavePosBuff + 800))
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_FKCXDW_ALARM,bRunning);//方块插销定位异常警告
      
    }  
    break;
  case 6:  
    if(XY_CTHL_PARAM_TDFZ_LENTH && !X_DRV)  //拖带电机反转
      AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_DXKFZ_LENTH,800,600,6,6,0); 
    if(XY_CTHL_PARAM_CXXY_MODE)
      XY_CTHL_CXXY_VAVLE = 1;
    XY_CTHL_bFKCXTDDW_Step = 0;
    break;
    
  }  
}

//插销穿入动作
void XY_CTHL_bCXCRStep(void)
{
  switch(XY_CTHL_bCXCR_Step)
  {
  case 11:
    XY_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
    XY_CTHL_FKGD_VAVLE = 0;     //方块固定关
    XY_CTHL_CXSCDW_VAVLE=1;
    XY_CTHL_bCXCR_Step = 12;      
    
    break;
  case 12: 
    if(!XY_CTHL_XKTD_Origin_IN)  //斜口推带原位离开
    {
      XY_CTHL_bCXCR_Step = 13;
      //     XY_CTHL_CXQJD_VAVLE = 1;    //插销前夹带  
      XY_CTHL_bCXCR_Delay = dwTickCount + 20;
    }  
    break;
  case 13: 
    if((XY_CTHL_CL_MotorStep == 0) && (XY_CTHL_SF_Origin_IN) && (dwTickCount >= XY_CTHL_bCXCR_Delay))  //插销前夹带回到原位
    {
      XY_CTHL_bCXCR_Step = 14; 
      //  XY_CTHL_FKGD_VAVLE = 1;     //方块固定开
      XY_CTHL_CXQJD_VAVLE = 1;    //插销前夹带                    
      XY_CTHL_bCXCR_Delay = dwTickCount + XY_CTHL_PARAM_XCQJD_XCDW_DELAY+100;
    }
    break;
  case 14:
    if(dwTickCount >= XY_CTHL_bCXCR_Delay)
    {
      XY_CTHL_bCXCR_Step = 15; 
      XY_CTHL_FKGD_VAVLE = 1;     //方块固定
      //Y轴启动插销
      XY_CTHL_CL_MotorStep = 20;  //插销定位                   
    }
    break;
  case 15:   
    if(XY_CTHL_CL_MotorStep == 0)   //插销定位完成
    {
      XY_CTHL_bCXCR_Step = 16; 
      XY_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
      XY_CTHL_bCXCR_Delay = dwTickCount + 10;  //延时插销下移
    }  
    break;
  case 16: 
    if(dwTickCount >= XY_CTHL_bCXCR_Delay)
    {
      XY_CTHL_bCXCR_Step = 17;
      if(XY_CTHL_PARAM_CXXY_MODE)
        XY_CTHL_CXXY_VAVLE = 0;
      else
        XY_CTHL_CXXY_VAVLE = 1;     //Y06 插销下移电磁阀
      if(XY_CTHL_PARAM_NLSL_MODE == 0)
        XY_CTHL_bCXCR_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
      else
        XY_CTHL_bCXCR_Delay = dwTickCount + 80;  //插销下移异常时间
    }
    break;
  case 17:   
    if((XY_CTHL_CXXY_Limit_IN) || XY_CTHL_PARAM_NLSL_MODE)
    {
      
      if(XY_CTHL_CXXY_Limit_IN || (dwTickCount >= XY_CTHL_bCXCR_Delay))
      {
        XY_CTHL_bCXCR_Step = 18; 
        if( cXcxcrCnt==0 && !X_DRV)  //拖带电机反转
        {
          AxisMovePosAccDec(X_AXIS,10000,-XY_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);
        }
        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
        XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
        XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
        XY_CTHL_bCXCR_Delay = dwTickCount + XY_CTHL_PARAM_SCDWOff_CXDW_DELAY;
        
      }
    }  
    else if(dwTickCount >= XY_CTHL_bCXCR_Delay)  
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_CXXY_Limit_ALARM,bRunning);//插销下移异常
      
    }
    break;
  case 18:   
    //              if(START_IN_UP)
    {
      if(dwTickCount >= XY_CTHL_bCXCR_Delay) 
      {
        XY_CTHL_bCXCR_Step = 19; 
        
        XY_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
        XY_CTHL_bCXCR_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME +1000;  //插销穿入到位异常时间
        XY_CTHL_CL_MotorStep = 50;  //合链电机回原点
      }
    }
    break;
  case 19:  
    if( cXcxcrCnt > 1)  
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM,bRunning); //插销穿入到位异常  
    }
    
    if( XY_CTHL_CX_Limit_IN  &&  cXcxcrCnt<2 )
    {
      cXcxcrCnt=0;
      bZhuangLiaoOkFlg = 0;
      XY_CTHL_bCXCR_Step = 0;
      XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
      
    } 
    else if (dwTickCount >= XY_CTHL_bCXCR_Delay)
    {
      cXcxcrCnt++;
      
      XY_CTHL_CXHJD_VAVLE=0;
      XY_CTHL_CXHDW_VAVLE=0;
      XY_CTHL_CXDWZ_VAVLE = 0;
      if(XY_CTHL_PARAM_CXXY_MODE)
        XY_CTHL_CXXY_VAVLE = 0;
      else
        XY_CTHL_CXXY_VAVLE = 1;     //Y06 插销下移电磁阀
      XY_CTHL_bCXCR_Step = 11;
    }
    
    break;
  }
}

void XY_CTHL_bCLFirstStep(void)
{
  switch(XY_CTHL_bCLFirst_Step)
  {
  case 19:   
    XY_CTHL_JLTou_VAVLE = 0;        //接拉头
    bZhuangLiaoOkFlg = 0;
    XY_CTHL_bCLFirst_Step = 20;
    XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
    XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀关
    XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
    break;
  case 20:  
    if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      XY_CTHL_bCLFirst_Step = 21;
      XY_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
      XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
    }
    break;
  case 21:   
    if(!XY_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
    {
      XY_CTHL_bCLFirst_Step = 22;
      XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
    }
    else if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
    }
    break;
  case 22:
    if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      XY_CTHL_bCLFirst_Step = 23;                                     
      XY_CTHL_MGuo_VAVLE = 0;     //码勾退
      XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_MGOff_XiaMo_DELAY;
      XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
      XY_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
      XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀关
    } 
    break;
  case 23:  
    if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      XY_CTHL_bCLFirst_Step = 24;
      XY_CTHL_CTXM_VAVLE = 0; //穿头下模下降
      XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
      XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
    } 
    break;
  case 24: 
    if(!XY_CTHL_CTM_Limit_IN)
    {
      XY_CTHL_bCLFirst_Step= 25;
      XY_CTHL_bCLFirst_Delay = dwTickCount + 25;  //一次穿入延时返回
    }
    else if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning); //穿头下模下降异常
    }
    break;
  case 25:
    if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
    {
      
      XY_CTHL_bCLFirst_Step= 0;
      XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
      XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
      
      
      //退下出错警告
      XY_CTHL_AutoDelay1 = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
      XY_CTHL_AutoStep1 = 1;
      bTuiLaTouOkFlg = 1;
    }
    break;
  }
}
//手动动作
void XY_CTHL_ManualAction(void)
{ 
  if(bRunning) // 运行灯输出
  {
    XY_CTHL_Run_State=1;
    XY_CTHL_Stop_State=0;
  }
  else 
  {
    XY_CTHL_Stop_State=1;
    XY_CTHL_Run_State=0;
  }
  
  if((XY_CTHL_SF_ALR_IN && (XY_CTHL_PARAM_DB_MODE == 1))|| (((GetAlarm(Y_AXIS)==0) || (GetAlarm(X_AXIS)==0)) && (XY_CTHL_PARAM_DB_MODE == 0))) // 伺服报警
  {
    cCHULIANBAOJIN=1;
    XY_CTHL_SetAlarmCode(XY_CTHL_SF_ALR_ALARM,0);
  }
  if(dwTickCount >= XY_CTHL_bSFBBAOJIN_Delay)  
  {
    XY_CTHL_SF_ALR_CLR=0;
    SetClr(Y_AXIS,MOTOR_ALARM);
    SetClr(X_AXIS,MOTOR_ALARM);
  }
  
  if(bRunning == 0)  
  {   
    if(bClearTotal) //切断计数清零
    {
      bClearTotal       = 0;
      ClrcToTal(QDCT_TOTAL_ADDR);
    }
    if(XY_CTHL_bTLiao )                 //手动推料(推拉头)
    {
      XY_CTHL_bTLiao = 0;           
      if(XY_CTHL_TLiao_VAVLE)
        XY_CTHL_TLiao_VAVLE = 0;//XY_CTHL_TLiao_VAVLE; 
      else if(!XY_CTHL_HSLiao_VAVLE && XY_CTHL_HSLiao_Origin_IN)
      {
        XY_CTHL_TLiao_VAVLE = 1;
      } 
      else//条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_HENSONGLIAO_ALARM,0); // 横送料不能输出
      }
      
    } 
    
    if(XY_CTHL_bHSL)     //手动横送料   
    {
      XY_CTHL_bHSL= 0;
      if(!XY_CTHL_First_CT_VAVLE)
      {
        if(XY_CTHL_HSLiao_VAVLE)
        {
          XY_CTHL_HSLiao_VAVLE = 0;//~XY_CTHL_HSLiao_VAVLE;
        }
        else if(!XY_CTHL_TLiao_VAVLE && !XY_CTHL_TLiao_Limit_IN && XY_CTHL_CTM_Origin_IN && !XY_CTHL_JLiao_Limit_IN &&
                !XY_CTHL_JLTou_VAVLE && !XY_CTHL_CTXM_VAVLE && !XY_CTHL_CXDWZ_VAVLE && (!XY_CTHL_bMG || (XY_CTHL_bMG && XY_CTHL_LTou_Check)))
        {
          XY_CTHL_HSLiao_VAVLE = 1;
        }  
        else   //条件警告  最后一个括号条件为已经有拉头
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_YCCT_ALARM,0); 
        }  
      }
    }           
    if(XY_CTHL_bJLT)                  //接拉头
    {
      XY_CTHL_bJLT = 0;
      if(XY_CTHL_JLTou_VAVLE)
        XY_CTHL_JLTou_VAVLE = 0;
      else if(!XY_CTHL_First_CT_VAVLE && !XY_CTHL_CTXM_VAVLE && XY_CTHL_CTM_Origin_IN && XY_CTHL_First_CT_Origin_IN)
      {
        XY_CTHL_MGuo_VAVLE = 0;
        XY_CTHL_JLTou_VAVLE = 1;
      } 
      else//条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0); 
      }
    } 
    if(XY_CTHL_bMG)                   //码勾
    {
      XY_CTHL_bMG = 0;
      XY_CTHL_MGuo_VAVLE = !XY_CTHL_MGuo_VAVLE;
    } 
    if(XY_CTHL_bFKJD)                 //方块夹带
    {
      XY_CTHL_bFKJD = 0;
      XY_CTHL_FKJD_VAVLE = !XY_CTHL_FKJD_VAVLE;
    } 
    if(XY_CTHL_bXKTD)                  //斜口推带
    {
      XY_CTHL_bXKTD = 0;
      if(XY_CTHL_XKTD_VAVLE)
        XY_CTHL_XKTD_VAVLE = 0;
      else if(!XY_CTHL_DXK_VAVLE && (!XY_CTHL_XKSC_Limit_IN  || !XY_CTHL_CTXM_VAVLE|| XY_CTHL_PARAM_NLSL_MODE))
        XY_CTHL_XKTD_VAVLE = 1;
      else//条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_DXKCTXM_Origin_ALARM,0);          
      }
    } 
    if(XY_CTHL_bXKDW)                  //斜口定位
    {
      XY_CTHL_bXKDW = 0;
      XY_CTHL_XKDW_VAVLE = ~XY_CTHL_XKDW_VAVLE;
    } 
    if(XY_CTHL_bCTXM)                  //穿头下模
    {
      XY_CTHL_bCTXM = 0;
      if(XY_CTHL_CTXM_VAVLE )
      {
        if(!XY_CTHL_CXXY_VAVLE)
        {
          XY_CTHL_CTXM_VAVLE = 0;
          XY_CTHL_JLTou_VAVLE = 0;
        }
        else 
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_TXC_Limit_ALARM,0);   
        }
      }    
      else if(!XY_CTHL_HSLiao_VAVLE && XY_CTHL_HSLiao_Origin_IN && (!XY_CTHL_XKSC_Limit_IN || !XY_CTHL_XKTD_VAVLE))                
      {  
        if(XY_CTHL_PARAM_CXXY_MODE)
          XY_CTHL_CXXY_VAVLE = 1;
        XY_CTHL_MGuo_VAVLE = 1;
        XY_CTHL_CTXM_VAVLE = 1;
      }  
    } 
    if(XY_CTHL_bQianDXK)                  //前顶斜口
    {
      XY_CTHL_bQianDXK = 0;
      if(XY_CTHL_QDXK_VAVLE)
        XY_CTHL_QDXK_VAVLE = 0;
      else if(!XY_CTHL_XKTD_VAVLE)
        XY_CTHL_QDXK_VAVLE = 1;
      else  //条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_ALARM,0);   
      } 
    } 
    
    if(XY_CTHL_bDXK)                  //顶斜口
    {
      XY_CTHL_bDXK = 0;
      if(!XY_CTHL_PARAM_NLSL_MODE)
      {
        if(XY_CTHL_DXK_VAVLE)
          XY_CTHL_DXK_VAVLE = 0;
        else if(!XY_CTHL_XKTD_VAVLE)
        {
          if(!XY_CTHL_PARAM_NLSL_MODE)
            XY_CTHL_DXK_VAVLE = 1;
        }
        else  //条件警告
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_ALARM,0);   
        } 
      }
      else
      {
        if(XY_CTHL_XKTD_VAVLE)
          XY_CTHL_XKTD_VAVLE = 0;
        else if(!XY_CTHL_DXK_VAVLE )
        {
          if(!XY_CTHL_XKSC_Limit_IN  || !XY_CTHL_CTXM_VAVLE || XY_CTHL_PARAM_NLSL_MODE)
            XY_CTHL_XKTD_VAVLE = 1;
          else
          {
            XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0);   
          }
        }
        else//条件警告
        {
          XY_CTHL_SetAlarmCode(XY_CTHL_DXKCTXM_Origin_ALARM,0);          
        }
        
      }
    } 
    
    if(XY_CTHL_bQianDXK_DXK)
    {
      XY_CTHL_bQianDXK_DXK = 0;
      if(!XY_CTHL_XKTD_VAVLE && XY_CTHL_AutoStep==0)
      {
        cQDXK_DXK=1;
        XY_CTHL_AutoStep = 8;
        SetEn(X_AXIS, MOTOR_EN);
        XY_CTHL_AutoDelay = dwTickCount + 50;
        bRunning=1;
      }
      
    }
    //斜码插入
    if(XY_CTHL_bBanZiDong)
    {
      XY_CTHL_bBanZiDong=0;
      cBanAuTo=1;
      //          XY_CTHL_PARAM_BanAuto_MODE=1;
      XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
      XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
      XY_CTHL_ZhuangLiaoStep = 1; 
      bTuiLaTouOkFlg = 1;
      bZhuangLiaoOkFlg= 0;
      bCL_EN_FLG=0;
      XY_CTHL_AutoStep = 1;  
      bRunning=1;
    }
    //小插插入
    if(XY_CTHL_CXC)//穿小插
    {
      XY_CTHL_CXC=0;
      cCXCONE=1;
      cBanAuTo=0;
      //    XY_CTHL_PARAM_BanAuto_MODE=0;
      XY_CTHL_AutoStep = 11;  
      bRunning=1;
      if(GetEn(Y_AXIS) == MOTOR_DISEN) 
      {
        SetEn(Y_AXIS, MOTOR_EN);
        XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
        
      } 
    }
    
    if(XY_CTHL_bFKGD)                 //方块固定
    {
      XY_CTHL_bFKGD = 0;
      XY_CTHL_FKGD_VAVLE = ~XY_CTHL_FKGD_VAVLE;
    } 
    if(XY_CTHL_bCXQJD)                 //插销前夹带
    {
      XY_CTHL_bCXQJD = 0;
      XY_CTHL_CXQJD_VAVLE = ~XY_CTHL_CXQJD_VAVLE;
    } 
    if(XY_CTHL_bCXSY)                 //插销下移电磁阀
    {
      XY_CTHL_bCXSY = 0;
      XY_CTHL_CXXY_VAVLE = !XY_CTHL_CXXY_VAVLE;
    } 
    if(XY_CTHL_bCXDWZ)                 //Y14 插销定位针电磁阀
    {
      XY_CTHL_bCXDWZ = 0;
      if(XY_CTHL_CXDWZ_VAVLE)
        XY_CTHL_CXDWZ_VAVLE = 0;
      else if(XY_CTHL_HSLiao_Origin_IN)
      {
        XY_CTHL_CXDWZ_VAVLE = 1;
      }
      else //条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_HENSONGLIAO_ALARM,0);   
      }
      
    } 
    if(XY_CTHL_bCXHJD)                 //Y15 插销后夹带电磁阀
    {
      XY_CTHL_bCXHJD = 0;
      XY_CTHL_CXHJD_VAVLE =~XY_CTHL_CXHJD_VAVLE;
    } 
    if(XY_CTHL_bCXHDW)                 //Y16 插销后定位电磁阀
    {
      XY_CTHL_bCXHDW = 0;
      if(XY_CTHL_CXHDW_VAVLE)
        XY_CTHL_CXHDW_VAVLE = 0;
      else if(!XY_CTHL_CXQJD_VAVLE)
        XY_CTHL_CXHDW_VAVLE = 1;
      else//条件警告
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_CXQJD_ALARM,0);  
      }
    } 
    if(XY_CTHL_bFirst_CT)              //Y20 一次穿头电磁阀
    {
      XY_CTHL_bFirst_CT = 0;
      if( !XY_CTHL_First_CT_VAVLE )
      {
        if(!XY_CTHL_CXXY_VAVLE)
          XY_CTHL_First_CT_VAVLE=1;
        else 
          XY_CTHL_SetAlarmCode(XY_CTHL_TXC_Limit_ALARM,0);   
        
      }
      else if(XY_CTHL_First_CT_VAVLE)
      {
        XY_CTHL_First_CT_VAVLE=0;
      }
      
      
    } 
    if(XY_CTHL_bHLJJ)                  //Y21 合链夹具电磁阀
    {
      XY_CTHL_bHLJJ = 0;
      XY_CTHL_HLJJ_VAVLE = ~XY_CTHL_HLJJ_VAVLE;
    } 
    if(XY_CTHL_bCXSCDW)               //Y23 插销上止定位电磁阀 
    {
      XY_CTHL_bCXSCDW = 0;
      XY_CTHL_CXSCDW_VAVLE = ~XY_CTHL_CXSCDW_VAVLE;
    } 
    //自动装料
    if(XY_CTHL_bAutoZhuangLiao)
    {
      XY_CTHL_bAutoZhuangLiao = 0;
      if(XY_CTHL_ZhuangLiaoStep == 0)
      {
        bTuiLaTouOkFlg = 1;
        bZhuangLiaoOkFlg = 0;
        XY_CTHL_ZhuangLiaoStep = 1;
        XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
        XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
      }  
    }
    //测试电机
    if(XY_CTHL_bCLMotor_N)
    {           
      SetEn(Y_AXIS, MOTOR_EN);
      if(!XY_CTHL_SF_Origin_IN)
      {  
        if(!Y_DRV)
          //                Y轴       运行速度                    启动速度        加速度  减速度
          AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,1000,15,15);
      } 
      else
      {
        XY_CTHL_bCLMotor_N = 0;
      }
      
    }
    
    if(XY_CTHL_bCLMotor_P)  //后退限位已经取消
    {
      SetEn(Y_AXIS, MOTOR_EN);
      if(!Y_DRV)
        //                Y轴       运行速度                    启动速度        加速度  减速度
        AxisContinueMoveAcc(Y_AXIS,2000,DIR_P,1000,1000,15,15);
    }
    
    if(!XY_CTHL_bCLMotor_P && !XY_CTHL_bCLMotor_N && (XY_CTHL_CL_MotorStep == 0))
    {
      AxisEgmStop(Y_AXIS);//AxisDecStop(Y_AXIS); 
    }
    //合链电机返回原点
    if(XY_CTHL_bCLMotor_O)
    {
      XY_CTHL_bCLMotor_O = 0;
      if(XY_CTHL_CL_MotorStep == 0)
        XY_CTHL_CL_MotorStep = 40;
    } 
    //拖带方块定位 ,因这步为前拖带定位, 很多电磁阀要关掉       
    if(XY_CTHL_bFKTDDW)
    {
      XY_CTHL_bFKTDDW = 0;
      if(XY_CTHL_TD_MotorStep == 0)
      {
        XY_CTHL_XKDW_VAVLE = 0;     //斜口定位
        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
        if(!XY_CTHL_PARAM_CXXY_MODE)     
          XY_CTHL_CXXY_VAVLE = 0;     //插销下移
        
        XY_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
        XY_CTHL_CXHDW_VAVLE = 0;    //插销后定位
        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
        XY_CTHL_bHLJJ = 0;          //合链夹具
        XY_CTHL_FKJD_VAVLE = 0;     //方块夹带
        if((GetEn(X_AXIS) == MOTOR_DISEN))
        {
          SetEn(X_AXIS, MOTOR_EN);
          XY_CTHL_TD_MotorDelay = dwTickCount + 200;                    
        } 
        else
          XY_CTHL_TD_MotorDelay = dwTickCount + 50;
        XY_CTHL_TD_MotorStep = 1;
      } 
    } 
    //拖带方块插销定位(斜口推带，斜口定位，顶斜口)
    if(XY_CTHL_bFKCXTDDW)
    {
      XY_CTHL_bFKCXTDDW = 0;
      if((XY_CTHL_bFKCXTDDW_Step == 0) && (XY_CTHL_CL_MotorStep == 0) && 
         !XY_CTHL_CTXM_VAVLE)
      {
        XY_CTHL_bFKCXTDDW_Step = 1;
        SetEn(X_AXIS, MOTOR_EN);
        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
        XY_CTHL_CXXY_VAVLE = 0;     //插销下移
        XY_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
        XY_CTHL_CXHDW_VAVLE = 0;    //插销后定位
        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
        XY_CTHL_HLJJ_VAVLE = 0;          //合链夹具
      }  
    } 
    //插销穿入(包含电机前定位,插销下移,后夹,后定位)
    if(XY_CTHL_bCXCR) 
    {
      XY_CTHL_bCXCR = 0;
      //拉头模在上面到们并且码勾输出,判断有拉头
      if(XY_CTHL_CTXM_VAVLE && XY_CTHL_MGuo_VAVLE && !XY_CTHL_CXQJD_VAVLE &&
         XY_CTHL_CTM_Limit_IN && !XY_CTHL_LTou_Check)
      {                
        if(XY_CTHL_CL_MotorStep == 0)
        {
          XY_CTHL_bCXCR_Step = 11; 
          SetEn(Y_AXIS, MOTOR_EN);
          if(!XY_CTHL_SF_Origin_IN)
            XY_CTHL_CL_MotorStep = 40;
        }
      }
      else   //警告不能自动穿插销
      {
        XY_CTHL_SetAlarmCode(XY_CTHL_WFZIDONGCX_ALARM,0);  
      }
    }
    //电机合链动作
    if(XY_CTHL_bMotorHL)
    {
      XY_CTHL_bMotorHL = 0;
      if(XY_CTHL_SF_Origin_IN)
      {
        if((XY_CTHL_CL_MotorStep == 0) && !XY_CTHL_CTXM_VAVLE && (!XY_CTHL_CTM_Limit_IN))
        {
          bCL_OK_FLG = 0;   
          XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
          XY_CTHL_CL_MotorStep = 1;
          XY_CTHL_CL_MotorDelay = dwTickCount + XY_CTHL_PARAM_HLJJ_CL_DELAY + 130;
          if((GetEn(Y_AXIS) == MOTOR_DISEN))
          {
            SetEn(Y_AXIS, MOTOR_EN);
            XY_CTHL_CL_MotorDelay = dwTickCount + 250;                    
          } 
        }
      }
      else
      {
        XY_CTHL_bCLMotor_O =1;
        
      }
    } 
    //一次穿链动作
    if(XY_CTHL_bCL_First)
    {
      XY_CTHL_bCL_First = 0;
      //拉头模在上面到们并且码勾输出,判断有拉头
      if(XY_CTHL_CTXM_VAVLE && XY_CTHL_MGuo_VAVLE && !XY_CTHL_CXQJD_VAVLE &&
         XY_CTHL_CTM_Limit_IN && !XY_CTHL_LTou_Check && (XY_CTHL_CL_MotorStep == 0))
      {  
        XY_CTHL_bCLFirst_Step = 19;
        XY_CTHL_CXHJD_VAVLE = 1;    //插销后夹带 
        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
      }
    }        
  }        
}

#endif