GC19038/Machine/ChangShengGeiLiMachine/GLQueduan_newstr_CSNew.c

#include "global.h"

#if (CHANG_SHENG_GEI_LI_MACHINE==1)

void QueDuan_AlarmProtect(void);
void QueDuan_ManualAction(void);
void QueDuan_AutoAction(void);
void QueDuan_StepCheckStart(void);
void QueDuan_XiaQue(void);
void QueDuan_SecondXiaQue(void);
void QueDuan_Motor(void);
void QueDuan_YuanDianAction(void);
void QueDuan_TuiLianAction(void);
void QueDuan_ExtiActionX31(void);
void QueDuan_BingLian(void);
void QDN_TuiDaiAction(void);
static unsigned long cZipCnt = 0,cTableCnt = 0,cTuiFangKuaiCnt = 0;
static long save_limit_pos,cRealPos;
static long dwSaveLength;
        
unsigned char cCheckLianFlg = 0;
unsigned char cCheckLianFlgEN = 0;
unsigned char cGoLimitEn    = 0;
unsigned char NQDJGNUNMBER    = 0;
short *length_buffer;



void QueDuan_ExtiActionX31(void)
{
    cCheckLianFlg = 1;
}

void QDN_SetAlarmCode(unsigned alarm_code)
{
    SetAlarmCode(QDN_ALARM_ADDR,alarm_code);
    bAlarmStop = 1;
}
//电机松轴
void Motor_SZ(unsigned char En)
{
    if(En) //使能
    {  
        if(QDN_PARAM_MOTOR_SELECT)
            QDN_SZ_OUT   = 1;  //伺服电机
        else
            QDN_SZ_OUT   = 0;  //步进电机
    }
    else  //松轴
    {
        if(QDN_PARAM_MOTOR_SELECT)
            QDN_SZ_OUT   = 0;  //伺服电机
        else
            QDN_SZ_OUT   = 1;  //步进电机
    }  
}

void QueDuan_NewStr_InitAction(void)
{
    float length_buff,pulse_buff;

    length_buff = QDN_PARAM_CYCLE_LENGTH;
    pulse_buff  = QDN_PARAM_CYCLE_PULSE;
    XGearRatio  = pulse_buff/length_buff;  
    if(QDN_PARAM_KAIBEE_SELECT > 1)
        QDN_PARAM_KAIBEE_SELECT = 1;
    Motor_SZ(QDN_MOTOR_DIS); //电机松轴
   QDCT_SetAlarmCode(QDN_NO_ALARM);
        
}

void QueDuan_NewStr_Action(void)
{
    InputPinConfig(); 
    QueDuan_AlarmProtect();
    QueDuan_Motor();
    QueDuan_XiaQue();
    QueDuan_ManualAction();
    QueDuan_TuiLianAction();
    QueDuan_BingLian();
    QueDuan_SecondXiaQue();
    QueDuan_AutoAction();
    QueDuan_StepCheckStart();   // 调用脚踏开关检测程序 
    OutputPinConfig();
}

//手动动作
void QueDuan_ManualAction(void)
{  
    if(bRunning == 0)  
    {   
        cGoLimitEn = 0;
        if(QDN_bClearTotal) //切断计数清零
        {
            QDN_bClearTotal       = 0;
            ClrcToTal(QDN_TOTAL_ADDR);
        }
        
        if(QDN_bClearNowTotal)
        {
            QDN_bClearNowTotal = 0;
            QDN_PARAM_NOW_CNT = 0;
        }
        
        if(QDN_PARAM_KAIBEE_SELECT) 
         {
             if(!QDN_GOUZHEN_HOU_IN && !QDN_GOUZHEN_HOU_IN)
                    QDN_GZDW_OUT=1;
          }
          else
          {
            QDN_GZDW_OUT=0;
          }
        
        if(QDN_bXiaQie || QDN_MAN_QIEDUAN_IN_UP)
        {
            QDN_bXiaQie = 0;
            if((QDN_XiaQieStep == 0) && !QDN_TL_VAVLE)
            {
              if(!QDN_PARAM_KAIBEE_SELECT)
                QDN_XiaQieStep = 1;
              else
                QDN_XiaQieStep = 1;
            }  
        }
        //前点定位
        if(QDN_bQianDianDW)
        {
            QDN_bQianDianDW = 0;
            if(QDN_MotorStep == 0)
            {
                QDN_MotorStep = 61;
                cZipCnt      = 0;
                Motor_SZ(QDN_MOTOR_EN); //电机锁轴
                QDN_MotorDelay  =    dwTickCount + 150;
            }
        }
        
        if(QDN_bTL)
        {  
            QDN_bTL = 0;
            if(QDN_TL_VAVLE)
            {
                QDN_TL_VAVLE = 0;
            } 
            else if(!QDN_GZ_VAVLE && !QDN_SM_VAVLE)
            {
                QDN_TL_VAVLE = ~QDN_TL_VAVLE;
            }
        }
        

        
        if(QDN_bYD)
        {
            QDN_bYD = 0;
            QDN_YD_VAVLE = ~QDN_YD_VAVLE;
        }
        
        if(QDN_bGZ || QDN_MAN_GOUZHEN_IN_UP)
        {
            QDN_bGZ = 0;
            QDN_GZ_VAVLE = ~QDN_GZ_VAVLE;
        }
        
        if(QDN_bJD)
        {
           QDN_bJD = 0;
           QDN_JD_VAVLE = ~QDN_JD_VAVLE;
        }
        
        if(QDN_bXM)
        {
           QDN_bXM = 0;
           if(QDN_XM_KAIKOU_VAVLE || QDN_XM_VAVLE)
           {
                QDN_XM_VAVLE = 0;
                QDN_XM_KAIKOU_VAVLE = 0;
           }
           else
           {
                if(QDN_PARAM_KAIBEE_SELECT)      //闭口
                {  
                    
                    QDN_XM_VAVLE = 1;
                }
                else
                {
                    QDN_XM_KAIKOU_VAVLE = 1;
                  
                }
           }  
        }
        
        if(QDN_bSM)
        {
           QDN_bSM = 0;
           if(QDN_SM_VAVLE)
                QDN_SM_VAVLE = 0;
           else if(!QDN_TL_VAVLE)
                QDN_SM_VAVLE = 1;
        }
        //推方块
        if(QDN_bTFK || QDN_MAN_TUIDAI_IN_UP)
        {
            QDN_bTFK = 0;
            QDN_TFK_VAVLE = ~QDN_TFK_VAVLE;
        }
        //台面电机
        if(QDN_bTB)
        {
            QDN_bTB = 0;           
            QDN_TABLE_VAVLE = ~QDN_TABLE_VAVLE;
        }
        
//        if(QDN_bYBD)
//  /      {
//            QDN_bYBD = 0;
//            QDN_YBD_VAVLE = ~QDN_YBD_VAVLE;
//        }
        
        if(QDN_bTestCS)
        {
           QDN_bTestCS = 0;
           QDN_CS_OUT  = 1;
           QDN_CSDelay = dwTickCount + QDN_PARAM_CS_TIME;
        }
        
        if(QDN_bBL)//合链
        {
            QDN_bBL = 0;
            QDN_BL_VAVLE = ~QDN_BL_VAVLE;
        }
        
        if(QDN_bHL)  //护链,双开用
        {
            QDN_bHL = 0;
//            QDN_HL_VAVLE = ~QDN_HL_VAVLE;
        }
        
        if(QDN_bYX)
        {
            QDN_bYX = 0;
//            QDN_YX_VAVLE = ~QDN_YX_VAVLE;
        }
        if(QDN_XiaQieStep == 0)
        {
            if(dwTickCount >= QDN_CSDelay) QDN_CS_OUT  = 0;
        }

        
//电机控制        
        if(QDN_bGoMotor && !QDN_QIAN_LIMIT_IN)
        {           
            Motor_SZ(QDN_MOTOR_EN); //电机锁轴

            if(!X_DRV)
            {
              
              //                  X轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED,10,12);
            }
        }
        
        if(QDN_bBackMotor)  //后退限位已经取消
        {
            Motor_SZ(QDN_MOTOR_EN); //电机锁轴
            if(!X_DRV)
                //                  X轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_P,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED,10,12);
        }
        
        if(!QDN_bGoMotor && !QDN_bBackMotor && (QDN_MotorStep == 0))
        {
            if(X_DRV)AxisEgmStop(X_AXIS); 
        }
        
        if(QDN_QIAN_LIMIT_IN && (QDN_MotorStep == 0) && !QDN_bBackMotor &&(QDN_AutoStep == 0))
        {
            if(X_DRV)AxisEgmStop(X_AXIS);
        }       
    }
}




void QueDuan_AlarmProtect(void)
{ 
    cRealPos = GetPos(X_AXIS);
    
    if(!bRunning)
    {  
        if(QDN_BACK_LIMIT_IN)
        {
            if((QDN_MotorStep != 0) ||  X_DRV && QDN_bBackMotor)        //到后限不能再后退但可以点前进
            {
                QDN_bBackMotor = 0;
                
                AxisDecStop(X_AXIS);   
                QDN_JD_VAVLE   = 0;
                QDN_SetAlarmCode(QDN_BACK_ALARM);
                
            }
        }     
    }
    else
    {
        //软件限位
        if(QDN_PARAM_RUN_LENGTH < 5000)
            QDN_PARAM_RUN_LENGTH= 5000;
        if((cRealPos > QDN_PARAM_RUN_LENGTH) && (cGoLimitEn != 0))  //第一条手动时不保护
        {
            AxisEgmStop(X_AXIS);   
            QDN_JD_VAVLE = 0;
            QDN_SetAlarmCode(QDN_BACK_ALARM);
        }
        //硬件限位
        if(QDN_BACK_LIMIT_IN && GetDir(X_AXIS)==QDN_DIR_P)
        {
                if(X_DRV)
                {
                    AxisEgmStop(X_AXIS); 
                    QDCT_JD_OUT = 0;
                    QDCT_SetAlarmCode(QDN_BACK_ALARM);
                }
        }
    }
}


void QueDuan_AutoAction(void)
{     
    if(bRunning)
    {//台面电机定时关掉
        if(dwTickCount >= QDN_TBDelay)
            QDN_TABLE_VAVLE = 0;
        switch(QDN_AutoStep)
        {
            case 1:
                  if(dwTickCount >= QDN_AutoDelay)
                  {
                      if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_bTiaoShiStep)
                      {                       
                        QDN_AutoStep = 2;	    
                        if(QDN_MotorStep == 0)
                        {
                            QDN_MotorStep = 61;   //前点定位
                        }
                        cGoLimitEn = 0;
                      }
                  }	
                  break;	
            case 2:	 
                  if(QDN_MotorStep == 0)
                  {   
                      if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_bTiaoShiStep)
                      {
                        QDN_MotorStep = 30;  
                        QDN_AutoStep = 3;	
                        cGoLimitEn = 1;
                      }
                  }
                  break;	
            case 3:	//后面两步为延时反转步
                  if((QDN_MotorStep == 0) || (QDN_MotorStep == 390) || (QDN_MotorStep == 391))
                  {  
                      if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_bTiaoShiStep)
                      {
                        if(QDN_SAFE_IN)
                        {
                            bStop = 1;
                        }
                        else 
                        {
                             
                            if(QDN_XiaQieStep == 0)
                               QDN_XiaQieStep = 1;                 
                            QDN_AutoStep = 4;
                        }
                      }
                  }              
                  break;
            case 4:
                      //                                  闭口
                      if((QDN_XiaQieStep == 0) || ((QDN_XiaQieStep == 6) && (QDN_PARAM_KAIBEE_SELECT == 1))|| ((QDN_XiaQieStep == 13) && (QDN_PARAM_KAIBEE_SELECT == 0)))// && !QDN_SHANG_MU_LIMIT_IN)
                      {
                        if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_bTiaoShiStep)
                        {
                          if(QDN_MotorStep == 0) 
                          {
                              QDN_MotorStep = 40;     //切完后退   
                              QDN_AutoStep = 5;
                          }
                        }
                      }

                 break;
          case 5:
             if(QDN_MotorStep == 0)
               {
                if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_bTiaoShiStep)
                {
                  if(QDN_PARAM_SecondDAO_LENGTH && QDN_PARAM_KAIBEE_SELECT && QDN_PARAM_BKGZ_NUMBER )
                  {
                            QDN_SecondXiaQueStep = 1;
                            QDN_AutoStep=0;
                  }
                  else
                  {
                    if(NQDJGNUNMBER==0)
                           QDN_AutoStep = 6;
                    else if(NQDJGNUNMBER==1)
                        QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                    else if(NQDJGNUNMBER==2)
                      QDN_SetAlarmCode(QDN_LENGTH_SHORT_ALARM);
                    
                   }
                }
               }
             break;
            case 6:	 
                
                  if(QDN_MotorStep == 0)
                  {
                      cZipCnt++;
                      QDN_PARAM_NOW_CNT++;
                      cTableCnt++;
                      AddToTal(QDN_TOTAL_ADDR);
                      AddToTal(CT_WORKTOTAL_ADDR);
                      CalProSP(QDN_PROSPEED_ADDR);
                      
                      if(cTableCnt >= QDN_PARAM_TABLE_NUM)
                      {
                          cTableCnt = 0;
                          QDN_TABLE_VAVLE = 1;
                          QDN_TBDelay = dwTickCount + QDN_PARAM_TB_TIME;
                      }
                      
                      if(/*(GetTotal(QDN_TOTAL_ADDR) >= QDN_PARAM_SET_TOTAL) ||*/ SingOneFlg)
                      {
                        /*
                          if((QDN_PARAM_SET_TOTAL == 0) && !SingOneFlg)
                          {
                                QDN_AutoDelay = dwTickCount + QDN_PARAM_CYCLE_DELAY;
                                QDN_AutoStep = 1; 
                          }
                          else
                        */
                          {
                              bRunning = 0;
                              QDN_AutoStep = 0; 
                              SingOneFlg = 0;
                               
                          }
                          
 //                         if(GetTotal(QDN_TOTAL_ADDR) >= QDN_PARAM_SET_TOTAL) QDN_SetAlarmCode(QDN_TOTAL_ALARM);
                      }
                      else
                      {
                          QDN_AutoStep = 1; 
                          
                          if((QDN_PARAM_NOW_CNT >= QDN_PARAM_ZHA_SHU) && (QDN_PARAM_ZHA_SHU > 0))   
                          {
                              QDN_AutoDelay = dwTickCount + QDN_PARAM_ZS_STOP_TIME;
                              QDN_PARAM_NOW_CNT = 0;
                              if(QDN_PARAM_ZS_STOP_TIME == 0)
                              {
                                  bRunning = 0;
                                  QDN_AutoStep = 0; 
                                  SingOneFlg = 0;
                                  QDN_SetAlarmCode(QDN_TOTAL_ALARM);
                              }
                          }
                          else
                              QDN_AutoDelay = dwTickCount + QDN_PARAM_CYCLE_DELAY;
                      }
                  }
                  break;
        }	
    }
}

void QueDuan_StepCheckStart(void)
{
//		启动      			
    if((QDN_START_IN_UP) || bStart || QDN_bSingle) 
    {
        bStart = 0;
        
        if(!bRunning && (QDN_AutoStep == 0))
        {
            if((QDN_XIA_MU_LIMIT_IN | QDN_KAIKUO_XIAMO_LIMIT_IN) && !QDN_PARAM_XM_ENABLE)QDN_SetAlarmCode(QDN_XM_DAOWEI);
//            else if(GetAlarmCode(QDN_ALARM_ADDR) != 0);
            //else if(GetTotal(QDN_TOTAL_ADDR) >= QDN_PARAM_SET_TOTAL) QDN_SetAlarmCode(QDN_TOTAL_ALARM);
           else if(QDN_ANQUANMEN_LIMIT_IN)QDN_SetAlarmCode(QDN_PARAM_ANQUANMEN_ALARM);
            else if(QDN_SM_VAVLE)QDN_SetAlarmCode(QDN_SM_ALARM);
            else if(QDN_GOUZHEN_QIAN_IN || QDN_GOUZHEN_HOU_IN)QDN_SetAlarmCode(QDN_GZ_ALARM);
            else
            {
                bRunning    = 1;
                QDN_AutoStep = 1;
                if(QDN_bSingle) 
                    SingOneFlg= 1;
                cZipCnt      = 0;
                cTuiFangKuaiCnt = 0;
                NQDJGNUNMBER = 0;
                QDN_BL_VAVLE = 0;    //并链关
                QDN_DGLG_VAVLE = 0;  //顶过链杆关
                SetAlarmCode(QDN_ALARM_ADDR,0); 
                Motor_SZ(QDN_MOTOR_EN); //电机锁轴
                QDN_AutoDelay = dwTickCount + 150; 
                if(QDN_PARAM_KAIBEE_SELECT) 
                  QDN_GZDW_OUT=1;
                else
                  QDN_GZDW_OUT=0;
            }
        }
        QDN_bSingle = 0;
    }
    //停止
   if(QDN_STOP_IN_UP || bStop)
   {
        bStop = 0;       
        if(bRunning)
        {
            QDN_AutoDelay   = dwTickCount;
            QDN_MotorDelay = dwTickCount;
            QDN_XiaQieDelay  = dwTickCount;
            QDN_KaDaiDelay   = dwTickCount;
            QDN_CSDelay = dwTickCount;
            QDN_TBDelay  = dwTickCount;
            QDN_TFKDelay  = dwTickCount;
            QDN_TLDelay     = dwTickCount;
            dwTickCount = QDN_TBDelay;
             NQDJGNUNMBER = 0;
            SingOneFlg  = 0; 
            QDN_JD_VAVLE = 0;
            QDN_SM_VAVLE = 0;
            QDN_XM_VAVLE = 0;
            QDN_XM_KAIKOU_VAVLE=0;
            QDN_YD_VAVLE = 0;
            QDN_TFK_VAVLE= 0;
            QDN_TL_VAVLE      = 0;
 //           QDN_HL_VAVLE  = 0;
            QDN_CS_OUT   = 0;
            QDN_XiaQieStep = 0;
            QDN_MotorStep  = 0;
            QDN_TuiLianStep = 0;
            QDN_GZ_VAVLE    = 0;
            QDN_TABLE_VAVLE   = 0;
            QDN_DGLG_VAVLE = 0;  //顶过链杆关
            AxisDecStop(X_AXIS);  
            QDN_BinLianStep  = 0;
            QDN_BL_VAVLE    = 0;
            user_datas[121] = 0;
            user_datas[122] = 0;

            SetAlarmCode(QDN_ALARM_ADDR,0);        
        }
        else
        {
            QDN_AutoDelay   = dwTickCount;
            QDN_MotorDelay = dwTickCount;
            QDN_XiaQieDelay  = dwTickCount;
            QDN_KaDaiDelay   = dwTickCount;
            QDN_CSDelay = dwTickCount;
            QDN_TBDelay  = dwTickCount;
            QDN_TFKDelay = dwTickCount;
            QDN_TLDelay  = dwTickCount;
            dwTickCount = QDN_TBDelay;
             NQDJGNUNMBER = 0;
            SingOneFlg  = 0; 
            QDN_JD_VAVLE = 0;
            QDN_SM_VAVLE = 0;
            QDN_XM_VAVLE = 0;
            QDN_XM_KAIKOU_VAVLE = 0;
            QDN_YD_VAVLE = 0;
            QDN_TFK_VAVLE= 0;
 //           QDN_YX_VAVLE = 0;
//            QDN_HL_VAVLE  = 0;
            QDN_TL_VAVLE      = 0;
            QDN_DGLG_VAVLE = 0;  //顶过链杆关
            QDN_GZ_VAVLE = 0;
            QDN_CS_OUT   = 0;
            QDN_XiaQieStep = 0;
            QDN_MotorStep  = 0;
            QDN_TuiLianStep = 0;
            QDN_TABLE_VAVLE   = 0;
            AxisEgmStop(X_AXIS);   
            Motor_SZ(QDN_MOTOR_DIS); //电机松轴
            QDN_BinLianStep  = 0;
            QDN_BL_VAVLE    = 0;
            SetAlarmCode(QDN_ALARM_ADDR,0);
        }
        bRunning   = 0;
        QDN_XiaQieStep = 0;
        QDN_AutoStep   = 0;
        QDN_MotorStep  = 0;
        QDN_TuiLianStep = 0;
        cTuiFangKuaiCnt=0;
    }    
    if(bAlarmStop)
    {
        bAlarmStop = 0;
        QDN_XiaQieStep = 0;
        QDN_AutoStep   = 0;
        QDN_MotorStep  = 0;
        QDN_TuiLianStep = 0;
         NQDJGNUNMBER = 0;
        QDN_XiaQieStep = 0;
        QDN_MotorStep  = 0;
        QDN_TuiLianStep = 0;
        QDN_AutoDelay   = dwTickCount;
        QDN_MotorDelay = dwTickCount;
        QDN_XiaQieDelay  = dwTickCount;
        QDN_KaDaiDelay   = dwTickCount;
        QDN_CSDelay = dwTickCount;
        QDN_TBDelay  = dwTickCount;
        QDN_TFKDelay  = dwTickCount;
        QDN_TLDelay     = dwTickCount;
        SingOneFlg  = 0; 
        bRunning   = 0;
        AxisDecStop(X_AXIS); 
        dwTickCount = QDN_TBDelay;
        QDN_TABLE_VAVLE = 0;
        QDN_JD_VAVLE=0;
        QDN_GZ_VAVLE=0;
        cTuiFangKuaiCnt=0;
    }
    
}   
//记忆长度模式误差检测
void QueDuan_CheckLength(long zip_length)
{
    static long start_dist;
    switch(QDN_CheckLengthStep)
    {
        case 0:break;
        case 1:
               start_dist = cRealPos;
               dwSaveLength = 0;
               QDN_CheckLengthStep = 2;
               break;
        case 2:
          if(QDN_GUO_LIAN_IN_DW){  
            dwSaveLength = cRealPos - start_dist;   
 //           user_datas[127] = cRealPos;

          }
               break;         
    }          
}

#if 1//!QDN_KB_MODE  //开口
//开口切专用
//30步开始后拉开始，分解4种工作模式
//40步开始用切断后拉动作
//60步开始为前方向，开闭口一样

void QueDuan_Motor_KK(void)
{
        static long save_buff,length_buff,gou_zhen_buff,checkdelay_buff,dandao_buff,back_buff,gouzhen_buff,go_buff,go_length_buff,jz_buff;
       unsigned  short ch;
        user_datas[121]  = QDN_AutoStep;
        user_datas[122]  = QDN_MotorStep;
        user_datas[123]  = cRealPos;
        user_datas[124]  = length_buff;
        user_datas[125] = GetCurSpeed(X_AXIS);
        user_datas[126] = QDN_XiaQieStep;
        user_datas[127] = QDN_XiaQieStep;
        QueDuan_CheckLength(length_buff);
        
	switch(QDN_MotorStep)
	{
                case 30:
                    switch(QDN_PARAM_BACK_MODE)  //开口分四种模式 
                    {
                        case 0: //单数控模式
                              QDN_MotorStep   = 310;  //每种模式留20步
                              QDN_DGLG_VAVLE = 1;  //顶过链杆关
                              break;
                        case 1://单感应模式
                            QDN_MotorStep   = 330;  //每种模式留20步
                            
                            break;
                        case 2: //先感应后数控模式+检测
                            QDN_MotorStep   = 350;  //每种模式留20步
                            break;
                        default:  //数控模式+过链检测长度
                            QDN_MotorStep   = 370;  //每种模式留20步
                            break;
                    }  
                    QDN_MotorDelay  =    dwTickCount + QDN_PARAM_DELAY_BACK;    
                    break;
         //310步到315步为数控模式                    
                case 310:
                    QDN_MotorStep   = 311;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    if(QDN_PARAM_BL_ENABLE)
                        QDN_BinLianStep = 1;  //并链起动
                    length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                    break;
                case 311:   
                   if(dwTickCount >= QDN_MotorDelay)
                    {   
                      
                      //李永庆代码                                                   
                      //SetDir(X_AXIS, QDN_DIR_N);
                      //两段速度移动距离  拉链长度+慢速长度停止
                     //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
                      AxisMoveTwoPos(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH -(*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                    QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_DIR_P,
                                    QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
                      
                      back_buff = cRealPos;
                      gou_zhen_buff = cRealPos;
                      save_buff = cRealPos;     
                            
    
                            QDN_MotorDelay  =    dwTickCount + MOTOR_ALARM_TIME;
                            QDN_MotorStep   = 312;
                   }
                    break;   
		case 312:
                        //勾针提前输出 ，争取时间推方块
                       if (!QDN_GZ_VAVLE && (cRealPos >= (QDN_PARAM_ZIPPER_LENGTH - (*length_buffer)- QDN_PARAM_GOUZHEN_LENGTH)))
                       {
                            QDN_GZ_VAVLE = 1;
                            //QDN_XM_KAIKOU_VAVLE=1;
                       }
                       if((cRealPos) > (QDN_PARAM_ZIPPER_LENGTH - (*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH)) //- (*length_buffer) - (QDN_PARAM_BACK_LOW_SPEED_LENGTH + PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC)))))
                       {                            
                           QDN_MotorStep   = 313;
                           
                       }
                       else if(cRealPos >= (QDN_PARAM_ZIPPER_LENGTH - (*length_buffer) + QDN_PARAM_ERROR_LENGTH))
                       {
                          AxisEgmStop(X_AXIS);
                          QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                       }
			break;
                case 313:
                       if(!QDN_GZ_VAVLE && ((cRealPos) > (QDN_PARAM_ZIPPER_LENGTH - (*length_buffer) - QDN_PARAM_GOUZHEN_LENGTH)))
                       {
                            QDN_GZ_VAVLE = 1;
                            //QDN_XM_KAIKOU_VAVLE=1;
                       }
                       if(!X_DRV)
                       {                         
                           //AxisEgmStop(X_AXIS);
                           QDN_MotorDelay = dwTickCount + QDN_PARAM_TFK_DELAY;
                           QDN_MotorStep   = 314;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                           
                           if((QDN_PARAM_BACK_MODE == 2) && !QDN_DGLG_VAVLE) //模式2,先检测长度后数控
                           {//对比长度 ,发须要有过链信号,模式2,3.  模式0,1不用在这里对比长度           
                               if(cZipCnt > 1)  //长度检测
                                {
                                   if(QDN_PARAM_ERROR_LENGTH != 0)  //长度误差值不能为0
                                    {     
                                        if(((dwSaveLength + QDN_PARAM_MOTOR_DELAY_LENGTH) > (length_buff + QDN_PARAM_ERROR_LENGTH)) || (dwSaveLength == 0))
                                        {
                                           QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);//拉链变长,对比警告                                   
                                        }
                                        else if((dwSaveLength + QDN_PARAM_MOTOR_DELAY_LENGTH+ QDN_PARAM_ERROR_LENGTH) < length_buff) 
                                        {
                                           QDN_SetAlarmCode(QDN_LENGTH_SHORT_ALARM);  ////拉链变短     
                                       }                                      
                                        QDN_CheckLengthStep = 0;
                                    }    
                                }
                            }
                       } 
                       if(cRealPos >= (QDN_PARAM_ZIPPER_LENGTH - (*length_buffer) + QDN_PARAM_ERROR_LENGTH))
                       {
                          AxisEgmStop(X_AXIS);
                           QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                       }
                        break;
                case 314:
                       if(!X_DRV && (dwTickCount >= QDN_MotorDelay))  //数控到停止
                       {      
                            QDN_MotorStep   = 315;
                            QDN_MotorDelay  =    dwTickCount + VAVLE_ALARM_TIME;
                            QDN_TFK_VAVLE   = 1;    //推方块输出                       
                       }
                       break;
                case 315: 
                      if(QDN_GOUZHEN_QIAN_IN)
                      {
                        QDN_MotorStep   = 0;
                      }
                      else if(dwTickCount >= QDN_MotorDelay)
                      {
                        QDN_SetAlarmCode(QDN_GZ_ALARM);
                      }    
                      break;
              //330步到349步单感应模式   
                case  330:  
                    back_buff = cRealPos;
                     gou_zhen_buff = cRealPos;
                    QDN_MotorStep   = 331;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    save_buff = cRealPos;  
                    length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                    //user_datas[127] = 0;
                    break;
                case 331:  
                    if(dwTickCount >= QDN_MotorDelay)
                    {   
                        if(cZipCnt < 2)
                        {
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 10;  //并链起动
                           //第一条都是过链感应，后拉速度减半//原来QDN_PARAM_CHECK_BACK_HSPEED/2
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                          AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,10,13);
                          
                             //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
                          // AxisMoveTwoPos(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH + (*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_DIR_P); 
                          QDN_MotorStep   = 332; 
                        }   
                        else
                        {  
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 1;  //并链起动
                          //因为每条都是过链感应，所以直接运行检测模式后拉速度
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                            //AxisContinueMoveAcc(X_AXIS,QDN_PARAM_CHECK_BACK_HSPEED,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
                            if(length_buff>QDN_PARAM_BACK_LOW_SPEED_LENGTH)
                              AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_BACK_SPEED,length_buff-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                               QDN_PARAM_START_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);
                            else
                              AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,8,13);
                           QDN_MotorStep   = 334; 
                         }
                    }
                    break;
                case 332:
                    //第一二条工作
                    {  
                        if(QDN_GUO_LIAN_IN_UP)
                        {                                 
                            checkdelay_buff = cRealPos;
                             AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);  
                             QDN_MotorDelay  = dwTickCount + 0;//QDN_PARAM_DELAY_XM;
                              QDN_MotorStep   = 333;
                         }  
//                         else if((cRealPos >= QDN_PARAM_RUN_LENGTH) && (QDN_PARAM_RUN_LENGTH >= 5000))  //模组最长限制
//                        {
//                           QDN_SetAlarmCode(QDN_PARAM_RUN_LENGTH_ALARM);  //超出轨道运行长度
//                        }
                    }
                    break;
                 case 333:
                       if(dwTickCount >= QDN_MotorDelay)
                       {
                           QDN_MotorStep   = 334;
                       }                        
                        break;   
                case 334:
                   if(QDN_GUO_LIAN_IN_DW && ((cRealPos-save_buff)> (length_buff-QDN_PARAM_BACK_LOW_SPEED_LENGTH) || (cZipCnt < 2)))  //下降沿,定位长度
                   {      
                     //滤波有待调试
//                        if((((cRealPos - checkdelay_buff) >= QDN_PARAM_DELAY_CHECK) && (QDN_PARAM_LT_ENABLE)) || (((cRealPos - checkdelay_buff) >= QDN_PARAM_NO_LT_DELAY_CHECK) && (QDN_PARAM_LT_ENABLE == 0)))
//                        {
                            if(QDN_GUO_LIAN_IN_DW)
                            {                  
                                 gou_zhen_buff = cRealPos;
                                 QDN_MotorStep   = 335;
                            }
//                        }                       
                   }
                   break;
                case 335:	                        
                    if(QDN_GUO_LIAN_IN_DW)
                    {
                        gou_zhen_buff = cRealPos; 
                         
                    }
                    //在空们都把延时清零    
                    if(QDN_GUO_LIAN_IN)
                    {
                        gou_zhen_buff = cRealPos; 
                    }    
                    if(((cRealPos - gou_zhen_buff) >= QDN_PARAM_MOTOR_DELAY_LENGTH/4) && !QDN_GUO_LIAN_IN)
                    {                         
                        QDN_GZ_VAVLE = 1;
                        //QDN_XM_KAIKOU_VAVLE=1;
                        //QDN_MotorStep   = 336;
                        
                    }                       
                    //定位停止
                    if(((cRealPos - gou_zhen_buff) >= QDN_PARAM_MOTOR_DELAY_LENGTH) && !QDN_GUO_LIAN_IN)
                    {                         
                        AxisEgmStop(X_AXIS);   
                        QDN_MotorDelay =    dwTickCount +  VAVLE_ALARM_TIME;
                        QDN_MotorStep   = 336;
                        QDN_GZ_VAVLE = 1;
                        QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                    }   
                    break;
                case 336: 
                    if(!X_DRV)
                    {      
                       QDN_GZ_VAVLE = 1;
           
                        QDN_MotorDelay =    dwTickCount +  QDN_PARAM_TFK_DELAY;
                           // QDN_XM_VAVLE    = 1;
                        QDN_MotorStep   = 337;
                        QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                    }
                    break;
                case 337:
                    if(dwTickCount >= QDN_MotorDelay)
                    {
                      QDN_TFK_VAVLE   = 1;    //推方块输出                       
                      QDN_MotorStep   = 338;
                      QDN_MotorDelay =    dwTickCount +  VAVLE_ALARM_TIME;
                    } 
                    break;
                case 338:  
                    if(QDN_GOUZHEN_QIAN_IN)
                    {                      
                      QDN_MotorStep   = 339;
                      QDN_MotorDelay =    dwTickCount +  VAVLE_ALARM_TIME;
                    }
                    else if(dwTickCount >= QDN_MotorDelay)
                    {
                      QDN_SetAlarmCode(QDN_GZ_ALARM);
                    }  
                    break;                    
                case 339:
                    if(cZipCnt == 1)
                    {   
                         length_buff = cRealPos - save_buff;
                         //需要补偿推方块增加的距离
                         SetData32bits(QDN_PARAM_ZIPPER_LENGTH_ADDR,length_buff + (*length_buffer));
                    }     
                    else if(cZipCnt > 1)  //长度检测
                    {
                        if(QDN_PARAM_ERROR_LENGTH != 0)  //长度误差值不能为0
                        {       
                            if(cRealPos >= length_buff)  //拉链变长,对比警告
                            {
                                if((cRealPos - save_buff) > (length_buff+QDN_PARAM_ERROR_LENGTH))                  
                                   NQDJGNUNMBER=1;
                            }
                            else   //拉链变短
                            {
                                if((cRealPos - save_buff + QDN_PARAM_ERROR_LENGTH) < (length_buff))
                                   NQDJGNUNMBER=2; 
                             } 
                         }
                    }
                    QDN_MotorStep   = 0;
                    break;
              //350步到369步单感应模式   
                case  350:  
                    back_buff = cRealPos;
                     gou_zhen_buff = cRealPos;
                     save_buff = cRealPos; 
                    QDN_MotorStep   = 351;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                    
                    break;
                case 351:  
                    if(dwTickCount >= QDN_MotorDelay)
                    {   
                        QDN_MotorStep   = 352; 
                        //第一,二条都是过链感应，测量长度
                        if(cZipCnt < 2)
                        {
                            if(QDN_PARAM_BL_ENABLE)  //因为长度未知,只能通过过链退合链
                                QDN_BinLianStep = 10;  //并链起动
                            QDN_DGLG_VAVLE = 0;  //顶过链杆关
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                            AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_GO_LOW_SPEED,8,12);
                          
                        }   
                        else
                        {  
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 1;  //并链起动
                            QDN_DGLG_VAVLE = 1;  //顶过链杆关
                            QDN_CheckLengthStep = 1;    //长度检测,第3条才有对比
                            //走数控方式,因第二条中已经测量出来拉链长度，可以直接按长度数控方式走
                            QDN_MotorStep   = 311; 
                        }  
                    }
                    break;
                case 352:
                  //前两条都按最低速度工作
                    if(QDN_GUO_LIAN_IN_UP)
                    {                                 
                         checkdelay_buff = cRealPos;
                         AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);  
                         
                         
                         QDN_MotorDelay  = dwTickCount + 2;//因慢速，加8MS滤波
                         QDN_MotorStep   = 353;
                     }  
                     else if((cRealPos >= QDN_PARAM_RUN_LENGTH) && (QDN_PARAM_RUN_LENGTH >= 5000))  //模组最长限制
                     {
 //                       QDN_SetAlarmCode(QDN_PARAM_RUN_LENGTH_ALARM);  //超出轨道运行长度
                     }

                    break;
                 case 353:
                     if(dwTickCount >= QDN_MotorDelay)
                     {
                         QDN_MotorStep   = 354;
                     }                        
                     break;   
                case 354:
                   if(QDN_GUO_LIAN_IN_DW)  //下降沿,定位长度
                   {      
                     //滤波有待调试
//                        if((((cRealPos - checkdelay_buff) >= QDN_PARAM_DELAY_CHECK) && (QDN_PARAM_LT_ENABLE)) || (((cRealPos - checkdelay_buff) >= QDN_PARAM_NO_LT_DELAY_CHECK) && (QDN_PARAM_LT_ENABLE == 0)))
//                        {
                            if(QDN_GUO_LIAN_IN_DW)
                            {                  
                                 gou_zhen_buff = cRealPos;
                                 QDN_MotorStep   = 355;
                            }
//                        }                       
                   }
                   break;
                case 355:	                        
                    if(QDN_GUO_LIAN_IN_DW)
                    {
                        gou_zhen_buff = cRealPos; 
                         
                    }
                    //在空们都把延时清零    
                    if(QDN_GUO_LIAN_IN)
                    {
                        gou_zhen_buff = cRealPos; 
                    }             
                     if(((cRealPos - gou_zhen_buff) >= QDN_PARAM_MOTOR_DELAY_LENGTH/4) && !QDN_GUO_LIAN_IN)
                    {                         
                        QDN_GZ_VAVLE = 1;
                        //QDN_XM_KAIKOU_VAVLE=1;
                        
                    }   
                    //定位停止
                    if(((cRealPos - gou_zhen_buff) >= QDN_PARAM_MOTOR_DELAY_LENGTH) && !QDN_GUO_LIAN_IN)
                    {                         
                        AxisEgmStop(X_AXIS);   
                        QDN_MotorStep   = 356;
                        QDN_GZ_VAVLE = 1;
                    }   
                    break;
                case 356:    
                    if(!X_DRV)
                    {      
                       QDN_GZ_VAVLE = 1;
           
                        QDN_MotorDelay =    dwTickCount +  QDN_PARAM_TFK_DELAY;
                           // QDN_XM_VAVLE    = 1;
                        QDN_MotorStep   = 357;
                    }
                    break;
                case 357:
                    if(dwTickCount >= QDN_MotorDelay)
                    {
                      QDN_TFK_VAVLE   = 1;    //推方块输出                       
                      QDN_MotorStep   = 358;
                      QDN_MotorDelay =    dwTickCount +  VAVLE_ALARM_TIME;
                    } 
                    break;
                case 358:  
                    if(QDN_GOUZHEN_QIAN_IN)
                    {                       
                      QDN_MotorStep   = 359;
                      QDN_MotorDelay =    dwTickCount +  VAVLE_ALARM_TIME;
                    }
                    else if(dwTickCount >= QDN_MotorDelay)
                    {
                      QDN_SetAlarmCode(QDN_GZ_ALARM);
                    }
                    break;                    
                case 359:
                    if(cZipCnt == 1)
                    {
                         length_buff = cRealPos - save_buff;
                         //测量出来长度，补偿推方块的距离
                         SetData32bits(QDN_PARAM_ZIPPER_LENGTH_ADDR,length_buff  + (*length_buffer));
                    }     
                    QDN_MotorStep   = 0;
                    break;                    
        //370步到389步为数控模式                    
                case 370:
                    QDN_MotorStep   = 371;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    if(QDN_PARAM_BL_ENABLE)
                        QDN_BinLianStep = 1;  //并链起动
                    
                    QDN_CheckLengthStep = 1;  //长度检测开始
                    length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                    break;
                case 371:   
                   if(dwTickCount >= QDN_MotorDelay)
                   {   
                     back_buff = cRealPos;
                     gou_zhen_buff = cRealPos;
                     save_buff = cRealPos;

                            //李永庆代码                                                   
                      //SetDir(X_AXIS, QDN_DIR_N);
                      //两段速度移动距离  拉链长度+慢速长度停止
                     //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
                     AxisMoveTwoPos(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH -(*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                    QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_DIR_P,
                                    QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
     
         
                     QDN_MotorDelay  =    dwTickCount + MOTOR_ALARM_TIME;
                     QDN_MotorStep   = 372;
                   }
                    break;   
		case 372:
                        //勾针提前输出 ，争取时间推方块
                       if (!QDN_GZ_VAVLE && (cRealPos >= (QDN_PARAM_ZIPPER_LENGTH- (*length_buffer) - QDN_PARAM_GOUZHEN_LENGTH)))
                             {
                            QDN_GZ_VAVLE = 1;
                            //QDN_XM_KAIKOU_VAVLE=1;
                       }
                       if((cRealPos) > (QDN_PARAM_ZIPPER_LENGTH- (*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH)) //- (*length_buffer) - (QDN_PARAM_BACK_LOW_SPEED_LENGTH + PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC)))))
                       {                            
                           QDN_MotorStep   = 373;
                           
                       }
			break;
                case 373:
                       if(!QDN_GZ_VAVLE && ((cRealPos) > (QDN_PARAM_ZIPPER_LENGTH- (*length_buffer) - QDN_PARAM_GOUZHEN_LENGTH)))
                             {
                            QDN_GZ_VAVLE = 1;
                            //QDN_XM_KAIKOU_VAVLE=1;
                       }
                       if(!X_DRV)
                       {                         
                           AxisEgmStop(X_AXIS);
                           QDN_MotorDelay = dwTickCount + QDN_PARAM_TFK_DELAY;
                           QDN_MotorStep   = 374;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                            //对比长度 ,发须要有过链信号,模式2,3.  模式0,1不用在这里经           
                           if(cZipCnt > 1)  //长度检测
                           {
                             if((QDN_PARAM_ERROR_LENGTH != 0) && length_buff)  //长度误差值不能为0
                             {     
                                if((dwSaveLength > (length_buff + QDN_PARAM_ERROR_LENGTH)) || (dwSaveLength == 0))
                                {
                                    QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);//拉链变长,对比警告                                   
                                }
                                //上升沿的长度
                                  else if((dwSaveLength + QDN_PARAM_ERROR_LENGTH) < length_buff)
                                  {
                                    QDN_SetAlarmCode(QDN_LENGTH_SHORT_ALARM); ////拉链变短     
                                  }
                                 
                                   QDN_CheckLengthStep = 0;
                              }        
                            }
                           else if(cZipCnt == 1)  //长度检测
                           {
                                if(dwSaveLength)
                                    length_buff = dwSaveLength;
                           }
                       }             
                        break;
                case 374:
                      if(!X_DRV && (dwTickCount >= QDN_MotorDelay))  //数控到停止
                       {      
                            QDN_MotorStep   = 315;
                            QDN_MotorDelay  =    dwTickCount + VAVLE_ALARM_TIME;
                            QDN_TFK_VAVLE   = 1;    //推方块输出                       
                       }
                       break;
                case 375: 
                      if(QDN_GOUZHEN_QIAN_IN)
                      {
                        QDN_MotorStep   = 0;
                      }
                      else if(dwTickCount >= QDN_MotorDelay)
                      {
                        QDN_SetAlarmCode(QDN_GZ_ALARM);
                      }    
                      break;
                        //切完延时后拉带松夹子
		case 40:    
                        if(QDN_PARAM_SJZ_LENGTH == 0)
                        {
                            QDN_JD_VAVLE = 0; 
                        }
                        QDN_MotorDelay     = dwTickCount + QDN_PARAM_CUT_BACK_DELAY;
                        SetDir(X_AXIS, QDN_DIR_P);
         //               QDN_JZ_DIR   = QDN_YDIR_P;
                        SetDir(X_AXIS, QDN_DIR_N);

                        QDN_MotorStep   = 41;
                        break; 
                case 41:   
                        
                        if((dwTickCount >= QDN_MotorDelay))
                        { 
                          jz_buff = cRealPos;
                          if(QDN_JD_VAVLE)
                            //两段速度移动距离
                                    //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
                                 AxisMoveTwoPos(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,QDN_PARAM_SJZ_LENGTH,5000,
                                                QDN_PARAM_BACK_LENGTH,QDN_DIR_P,QDN_PARAM_START_SPEED,
                                                QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);  
                          else                           
                             //夹子已经张开
                             AxisMovePosAccDec(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_SJZ_LENGTH+QDN_PARAM_BACK_LENGTH),
                                               QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,10,10,0);
                            //  AxisMovePos(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_SJZ_LENGTH+QDN_PARAM_BACK_LENGTH));
                          QDN_MotorStep   = 42;   
                        }
                           break;
		case 42:	 
                  
                          if(((QDN_PARAM_SJZ_LENGTH) <= (cRealPos - jz_buff)))
                          {
                              QDN_JD_VAVLE = 0;
                              QDN_MotorStep   = 43;
                          }
                          if(!X_DRV)
                          {
                             QDN_JD_VAVLE = 0;
                              QDN_MotorStep   = 43;
                          }
                        break;
                case 43:	                           // 切断完成后拉电机动作
                        if(!X_DRV)
                        {
                            QDN_MotorStep   = 0;
                            QDN_MotorDelay  =    dwTickCount;
                        }
                        break;   
                case 61: // 前点定位数控模式
                        QDN_BL_VAVLE = 0;//并链也要打开
                        if(dwTickCount >= QDN_MotorDelay)
                        {  
                        
                            
             //               QDN_JZ_DIR   = QDN_YDIR_N; 
                            if(!QDN_TL_VAVLE && cZipCnt)  //没送链情况下主动送链
                            {
                                if(!QDN_SHANG_MU_LIMIT_IN && (QDN_TuiLianStep == 0))
                                {
                                     QDN_TuiLianStep = 1;
                                     QDN_MotorStep = 62;
                                }                          
                            }
                            else
                                QDN_MotorStep = 62;
                        }
                        break;
                case 62:
                        if(dwTickCount >= QDN_MotorDelay)
                        {                            
                            if(QDN_QIAN_LIMIT_IN)
                            {
                                SetPos(X_AXIS, 0);//在前点，直接置零点
         //                       QDN_JZ_DIR   = QDN_YDIR_P;
                                //前点亮的情况下先退出
                                AxisMovePos(X_AXIS,QDN_PARAM_GO_LOW_SPEED,1000);                           
                                QDN_MotorDelay = dwTickCount + 300;
                            }
                            QDN_MotorStep = 63;            
                            QDN_JD_VAVLE = 0;  
                        }
			break;
		case 63:
                        if(!X_DRV && !QDN_QIAN_LIMIT_IN && (dwTickCount >= QDN_MotorDelay))// && !QDN_SHANG_MU_LIMIT_IN)
                        {
                            SetDir(X_AXIS, QDN_DIR_N);
         //                   QDN_JZ_DIR   = QDN_YDIR_N;
                            //SetDir(X_AXIS, QDN_DIR_P);
                            go_buff  = cRealPos;
                             //QDN_YD_VAVLE = 1; //开口不用压带
         //                   QDN_HL_VAVLE = 1;      
         //                   QDN_YX_VAVLE = 1;
                            //李永庆代码,当位置在慢速之外,走数控到慢速点
                            if(cZipCnt > 0)
                            {
                             
                                if(cRealPos>(QDN_PARAM_GO_LOW_SPEED_LENGTH))   
                                {   
                                  
                //                        AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos-QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
               //                SetStartSpeed(X_AXIS,QDN_PARAM_START_SPEED);
                //              SetAccTime(X_AXIS,QDN_PARAM_ACC); 
                //              SetDecTime(X_AXIS,QDN_PARAM_DCC);
                              //两段速度移动距离
                                    //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
               //                  AxisMoveTwoPos(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos-QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED_LENGTH+ 100,QDN_DIR_N);  
                                  //跑三段速度   
//                                 AxisMoveThreePosNoStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos -QDN_PARAM_GO_LOW_SPEED_LENGTH-300-150,
//                                                QDN_PARAM_GO_HIGH_SPEED*2/3,350,
//                                                QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED_LENGTH+150,QDN_DIR_N) ; 
                                 AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,-(cRealPos -QDN_PARAM_GO_LOW_SPEED_LENGTH),
                                               QDN_PARAM_START_SPEED,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);
                                } 
                                else
                                 {
                                    //                  X轴       运行速度                    启动速度        加速度  减速度
                                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED/3,QDN_PARAM_GO_LOW_SPEED/3,15,15);
       
                                   //   MoveAction_Const_AccDec(X_AXIS, QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
                                  }
                              
                            }
                            else
                            {
                               //                  X轴       运行速度                    启动速度        加速度  减速度
                                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED/3,QDN_PARAM_GO_LOW_SPEED/3,15,15);
                              // MoveAction_Const_AccDec(X_AXIS, QDN_DIR_N,QDN_PARAM_FIRST_GO_HIGHSPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);//
                            }
                            
                            QDN_MotorDelay =    dwTickCount + MOTOR_ALARM_TIME;
                            QDN_MotorStep   =64;
                        }  
                       
			break;
                case 64:
                        if(cZipCnt > 1)
                        {                         
                              //李永庆代码
                              if(((cRealPos) < (QDN_PARAM_GO_LOW_SPEED_LENGTH+1200)))// || (QDN_QIAN_DEC_IN))
                              {
                                   //user_datas[126]= GetCurSpeed(X_AXIS);
                               //     MoveChangSpeedDec(X_AXIS,QDN_PARAM_GO_HIGH_SPEED*2/3,6,8);
                             //    AxisChangeSpeed(X_AXIS,40);
                                   QDN_MotorStep   =65;
                              }
                           
                             if(QDN_QIAN_LIMIT_IN)
                              {      
                                
                                   back_buff=cRealPos;
                                     QDN_MotorStep   = 301;
                               
                              }
                               
                           
                             
                        }
                        else
                        {        if(QDN_QIAN_LIMIT_IN)
                              {      
                                
                                   back_buff=cRealPos;
                                     QDN_MotorStep   = 301;
                               
                              }
                              
                            
                              
                              
                              
                             
                        }

                        break;
                        
                                  
                 case 301:
                                    
                                if(QDN_QIAN_LIMIT_IN && back_buff-cRealPos >= QDN_PARAM_KKQIANDIAN_LENGTH )  //前点限位
                                {
                                    AxisEgmStop(X_AXIS);
                                    QDN_MotorStep   = 66;                            
                                }
                                 
                                break;
		case 65:
                           if(QDN_QIAN_LIMIT_IN)
                              {      
                                
                                   back_buff=cRealPos;
                                     QDN_MotorStep   = 301;
                               
                              }
                              
                        else if(dwTickCount >= QDN_MotorDelay)
                            QDN_SetAlarmCode(QDN_NO_ZIPPER_ALARM);
                        
                        break;
		case 66:
                        if(!X_DRV)
                        {   
                            SetPos(X_AXIS, 0);
                            QDN_MotorDelay =    dwTickCount;
                            QDN_MotorStep   = 67;
                        }
			break;   
		case 67:  //等推链完成后,
                        if((dwTickCount >= QDN_MotorDelay) && (QDN_TuiLianStep == 0) && ((QDN_PARAM_TIAOSHI_MODE && QDN_bTS) || (QDN_PARAM_TIAOSHI_MODE == 0)) )
                        {
                            if(bRunning)
                            {
                                QDN_JD_VAVLE = 1;
                                QDN_MotorDelay =    dwTickCount + QDN_PARAM_DELAY_BACK;
                            }
                            QDN_MotorStep   = 68;
                        }
			break;
                case 68:
                        if(dwTickCount >= QDN_MotorDelay)
                        {
                            QDN_YD_VAVLE = 0;
                            QDN_TFK_VAVLE  = 0;
         //                   QDN_HL_VAVLE = 0;      
         //                   QDN_YX_VAVLE = 0;
                            QDN_TL_VAVLE    = 0;
                            QDN_MotorStep   = 0;
                            QDN_MotorDelay  = dwTickCount;
                        }
                        break;
               
	}
}
#endif

void QueDuan_BingLian(void)
{
    static long bl_pos_buff,HL_delay;
    
    switch(QDN_BinLianStep)
    {
        case 0:break;
        case 1:
              bl_pos_buff = cRealPos;
              QDN_BinLianStep = 2;
        break;       
        case 2:
              if((cRealPos - bl_pos_buff) >= QDN_PARAM_DELAY_HL_LENGTH)
              {
                   QDN_BL_VAVLE = 1;   
                   QDN_BinLianStep = 3;
              }            
        break;
        case 3://有过链检测
              if((cRealPos - bl_pos_buff) >= (QDN_PARAM_ZIPPER_LENGTH - QDN_PARAM_HL_DELAY_BACK))
              {
                   QDN_BL_VAVLE = 0;
                   QDN_BinLianStep = 0;   
              }                
        break;
        case 10:
           bl_pos_buff = cRealPos;
              QDN_BinLianStep = 11;
        break;       
        case 11:
              if((cRealPos - bl_pos_buff) >= QDN_PARAM_DELAY_HL_LENGTH)
              {
                   QDN_BL_VAVLE = 1;   
                   QDN_BinLianStep = 12;
              }            
        break;
        case 12://有过链检测
              if(QDN_GUO_LIAN_IN_DW)
              {
                QDN_BinLianStep = 13;
                QDN_BingLianDelay = dwTickCount + 50;
              }
        break;
        case 13:
              if(QDN_GUO_LIAN_IN) 
                QDN_BinLianStep = 12;
              if(dwTickCount>=QDN_BingLianDelay)
              {
                if(!QDN_GUO_LIAN_IN)
                {
                   QDN_BL_VAVLE = 0;
                   QDN_BinLianStep = 0;   
                }
                else
                {
                  QDN_BinLianStep = 12;
                }
              }
              break;
        default:;    
    }
    
}
#if 1  //闭口

//作闭口专用程序,也有四种模式
//不带过链感应长度输入电机长度  闭口有勾针到位
void QueDuan_Motor_NoGL(void)
{ 
        static long save_buff,length_buff,gou_zhen_buff,checkdelay_buff,dandao_buff,back_buff,gouzhen_buff,go_buff,go_length_buff,jz_buff;
        long pulse_buff;
        unsigned  short ch,kk;
        user_datas[121]  = QDN_AutoStep;
        user_datas[122]  = QDN_MotorStep;
        user_datas[123]  = cRealPos;
        user_datas[124]  = length_buff;
        user_datas[125] = GetCurSpeed(X_AXIS);
        user_datas[126] = QDN_XiaQieStep;
        user_datas[127] = QDN_XiaQieStep;

	switch(QDN_MotorStep)
	{
               case 30:
                    switch(QDN_PARAM_BACK_MODE)  //开口分四种模式 
                    {
                        case 0: //单数控模式
                              QDN_MotorStep   = 310;  //每种模式留20步
                              QDN_DGLG_VAVLE = 1;  //顶过链杆关
                              break;
                        case 1://单感应模式
                            QDN_MotorStep = 330;  //每种模式留20步
                            
                            break;
                        case 2: //先感应后数控模式+检测
                            QDN_MotorStep   = 350;  //每种模式留20步
                            break;
                        default:  //数控模式+过链检测长度
                            QDN_MotorStep   = 370;  //每种模式留20步
                            break;
                    }  
                    QDN_MotorDelay  =    dwTickCount + QDN_PARAM_DELAY_BACK;    
                    break;
         //310步到315步为数控模式                    
                case 310:
                    QDN_MotorStep   = 311;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    if(QDN_PARAM_BL_ENABLE)
                        QDN_BinLianStep = 1;  //并链起动
                    break;
                case 311:   
                   if(dwTickCount >= QDN_MotorDelay)
                    {   
                      length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                      
                      AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                               QDN_PARAM_START_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);

                      back_buff = cRealPos;
                      gou_zhen_buff = cRealPos;
                      save_buff = cRealPos;                                 

                      QDN_MotorDelay  =    dwTickCount + MOTOR_ALARM_TIME;
                      QDN_MotorStep   = 312;
                   }
                    break;   
		case 312:
                       //勾针提前输出
                       if (!QDN_GZ_VAVLE && ((cRealPos + QDN_PARAM_GOUZHEN_LENGTH) >= (QDN_PARAM_ZIPPER_LENGTH )))
                       {  
                            QDN_GZ_VAVLE = 1;
                       }
                       if((cRealPos) >= (QDN_PARAM_ZIPPER_LENGTH - QDN_PARAM_BACK_LOW_SPEED_LENGTH)) //- (*length_buffer) - (QDN_PARAM_BACK_LOW_SPEED_LENGTH + PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC)))))
                       {           
                            QDN_MotorDelay  = dwTickCount + 2000; //钩针未到位延时警告
                            QDN_MotorStep   = 313;                                 
                       }//下面条件为无效代码
                       else if((cRealPos >= (QDN_PARAM_ZIPPER_LENGTH + QDN_PARAM_ERROR_LENGTH)) && QDN_PARAM_ERROR_LENGTH)
                       {
                            QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                       }                  
		      break;
                case 313:
                       if(!QDN_GZ_VAVLE && (cRealPos + QDN_PARAM_GOUZHEN_LENGTH) > (QDN_PARAM_ZIPPER_LENGTH ))
                       {
                            QDN_GZ_VAVLE = 1;
                       }   
                       //提前12MM取消数控模式,进入连续运动
//                       if((cRealPos + 100) > (QDN_PARAM_ZIPPER_LENGTH ))
//                       {
//                            //CancelPmoveState(X_AXIS);
//                            SetStartSpeed(X_AXIS,1500);
//                            AxisChangeSpeed(X_AXIS,1500);
//                       }
                       if(QDN_GOUZHEN_HOU_IN)
                       {                      
                           AxisEgmStop(X_AXIS);
                           QDN_MotorDelay  =    dwTickCount + 0;
                           QDN_YD_VAVLE = 1;

                           QDN_MotorStep   = 314;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                       }
                       else if((cRealPos >= (QDN_PARAM_ZIPPER_LENGTH + QDN_PARAM_ERROR_LENGTH)) && QDN_PARAM_ERROR_LENGTH)
                       {
                           AxisEgmStop(X_AXIS);
                            if(dwTickCount >= QDN_MotorDelay)                            
                                QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                       }   
                       
//                       else if((cRealPos >= QDN_PARAM_ZIPPER_LENGTH  + (*length_buffer)))// && dwTickCount >= QDN_MotorDelay)
//                       {
                            
//                       }
                        break;
                      
                case 314:
                       if(!X_DRV && (dwTickCount >= QDN_MotorDelay))
                       {    
                            QDN_MotorDelay  =    dwTickCount + VAVLE_ALARM_TIME;
                            QDN_YD_VAVLE = 1;//压带

                            QDN_MotorStep   = 315;
                       }   
                       break;
                case 315:    
                        if(cZipCnt == 0)  //第一条把误差到正负9MM
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH -90; 
                           kk = QDN_PARAM_ZIPPER_LENGTH +90;
                       }   
                       else
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH -70;                            
                           kk = QDN_PARAM_ZIPPER_LENGTH +70;                           
                       }
                      
                       if(((cRealPos) < (ch))) 
                       { 
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }          
                       else if((cRealPos > kk))//(QDN_PARAM_ERROR_LENGTH - 200 + (*length_buffer)+50)))
                       {
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }     
                       else
                       {                                                              
                            QDN_MotorStep   = 390;  //延时反转步
                       }                       
                       break;
              //330步到349步单感应模式   
                case  330:  
                    back_buff = cRealPos;
                    gou_zhen_buff = cRealPos;
                    save_buff=cRealPos;
                    QDN_MotorStep   = 331;   
                    break;
                case 331:  
                    if(dwTickCount >= QDN_MotorDelay)
                    {   
                        
                        if(cZipCnt < 2)
                        {
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 10;  //并链起动
                           //第一条都是过链感应，后拉速度减半//原来QDN_PARAM_CHECK_BACK_HSPEED/2
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                          AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,8,13);
                          
                             //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
                          // AxisMoveTwoPos(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH + (*length_buffer)-QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_DIR_P); 
                           QDN_MotorDelay  = dwTickCount + 20;
                          QDN_MotorStep   = 332;      
                        }   
                        else
                        {  
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 1;  //并链起动
                          //因为每条都是过链感应，所以直接运行检测模式后拉速度
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                            //AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);   
                            if(length_buff>QDN_PARAM_BACK_LOW_SPEED_LENGTH)
                              AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_BACK_SPEED,length_buff-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                               QDN_PARAM_START_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);
                            else
                              AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,8,13);
                           QDN_MotorStep   = 334; 
                         }
                    }
                    break;
                case 332:
                        if(QDN_GUO_LIAN_IN_UP)
                        {                                 
                            checkdelay_buff = cRealPos;
                            AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);    
                            QDN_MotorDelay  = dwTickCount + 20;
                         }  
                        if(QDN_GUO_LIAN_IN && dwTickCount >= QDN_MotorDelay)
                        {
                              QDN_MotorDelay  = dwTickCount + QDN_PARAM_FEEL_GZ_DELAY;//QDN_PARAM_DELAY_XM;
                              QDN_MotorStep   = 333;
                        }
                        else if(!QDN_GUO_LIAN_IN)
                        {
                           QDN_MotorDelay  = dwTickCount + 20;
                        }

                  break;
                 case 333:  //此步为前两条运行
                   if(!QDN_PARAM_BKGZ_NUMBER) //有钩针模式
                   {
                     
                       if(dwTickCount >= QDN_MotorDelay)
                       {
                           QDN_MotorStep   = 334;
                           
                             QDN_GZ_VAVLE = 1;
                             
                       }   
                       if(QDN_GUO_LIAN_IN_DW)
                       {                  
                            gou_zhen_buff = cRealPos;
                            QDN_MotorStep   = 335;
                             QDN_GZ_VAVLE = 1;
                             
                        }     
                   }
                   else  // 无钩针模式
                   {
                     if(QDN_GUO_LIAN_IN_DW)
                       {                  
                            gou_zhen_buff = cRealPos;
                            QDN_MotorStep   = 335;
                             
                        }   
                   
                   }
                        break;   
                case 334:     
                 if(!QDN_PARAM_BKGZ_NUMBER)  // 有钩针模式
                 {
                   if(QDN_GUO_LIAN_IN_DW)  //下降沿,定位长度
                   {      
                       gou_zhen_buff = cRealPos;
                       QDN_MotorStep   = 335; 
                       QDN_GZ_VAVLE = 1;     
                   }                   
                   if(cZipCnt > 1)  //第三条开始要长度误差
                   {  
                        if(cRealPos >= (length_buff + QDN_PARAM_ERROR_LENGTH))
                        {                    
                            QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                            //user_datas[128] = 1;
                        }  
                   }  
                 }
                 else  // 无钩针模式
                 {
                 if(QDN_GUO_LIAN_IN_DW)  //下降沿,定位长度
                   {      
                     gou_zhen_buff = cRealPos;
                      QDN_MotorStep   = 335;   
                   }                   
                   if(cZipCnt > 1)  //第三条开始要长度误差
                   {  
                        if(cRealPos >= (length_buff + QDN_PARAM_ERROR_LENGTH))
                        {                    
                              QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                              //user_datas[128] = 1;
                        }  
                   }  
                 }
                   break;
                case 335:
                   if(!QDN_PARAM_BKGZ_NUMBER) //有钩针模式
                   {
                        if(QDN_GUO_LIAN_IN_DW)
                        {
                            gou_zhen_buff = cRealPos; 
                             
                        }
                        //在空们都把延时清零    
                        if(QDN_GUO_LIAN_IN)
                        {
                            gou_zhen_buff = cRealPos; 
                        }
                        //距离到停
//                        if(cRealPos -gou_zhen_buff > QDN_PARAM_BKGY_LENGTH )
//                        {                                    
//                               AxisEgmStop(X_AXIS);
//                               QDN_MotorDelay  =    dwTickCount + 10;
//                               QDN_YD_VAVLE = 1;
//                               QDN_MotorStep   = 336;
//                               QDN_BL_VAVLE = 0;  //停止时并链一定要打开
//                        }
                        //感应到停
                        if(QDN_GOUZHEN_HOU_IN)
                        {                                    
                               AxisEgmStop(X_AXIS);
                               QDN_MotorDelay  =    dwTickCount + 10;
                               QDN_YD_VAVLE = 1;
                               QDN_MotorStep   = 336;
                               QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                        }
                        else
                        {
                            if(cZipCnt > 1)  //2 条后才有长度误差
                            {
                                if(cRealPos >= (length_buff + QDN_PARAM_ERROR_LENGTH))
                                {
                                    AxisEgmStop(X_AXIS);
                                    //user_datas[128] = 2;
                                    if(dwTickCount >= QDN_MotorDelay)                            
                                        QDN_SetAlarmCode(QDN_GZ_ALARM);
                                }
                            }  
                        }
                   }
                   else
                   {
                        if(QDN_GUO_LIAN_IN_DW)
                        {
                            gou_zhen_buff = cRealPos; 
                             
                        }
                        //在空们都把延时清零    
                        if(QDN_GUO_LIAN_IN)
                        {
                            gou_zhen_buff = cRealPos; 
                        }

                        if(cRealPos -gou_zhen_buff > QDN_PARAM_BKGY_LENGTH )
                        {                                    
                               AxisEgmStop(X_AXIS);
                               QDN_MotorDelay  =    dwTickCount + 10;
                               QDN_YD_VAVLE = 1;
                               QDN_MotorStep   = 336;
                               QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                        }
                        else
                        {
                            if(cZipCnt > 1)  //2 条后才有长度误差
                            {
                                if(cRealPos >= (length_buff + QDN_PARAM_ERROR_LENGTH))
                                {
                                    AxisEgmStop(X_AXIS);
                                    //user_datas[128] = 2;
                                    if(dwTickCount >= QDN_MotorDelay)                            
                                        QDN_SetAlarmCode(QDN_GZ_ALARM);
                                }
                            }  
                        }

                   
                   
                   }
                    break;
                case 336:                                              
                    if(cZipCnt > 1)  //长度检测
                    {
                        ch = QDN_PARAM_ZIPPER_LENGTH;                                                                         
                        //user_datas[127] = ch;
                        if(((cRealPos + QDN_PARAM_ERROR_LENGTH) < (ch)) && QDN_PARAM_ERROR_LENGTH) 
                        { 
                           NQDJGNUNMBER =1;
                            //user_datas[128] = 3;
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                        }          
                        else if((cRealPos > (ch + QDN_PARAM_ERROR_LENGTH)) && QDN_PARAM_ERROR_LENGTH)//(QDN_PARAM_ERROR_LENGTH - 200 + (*length_buffer)+50)))
                        {
                            //user_datas[128] = 4;
                            NQDJGNUNMBER = 2;
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                        }  
                        else
                        {
                            QDN_MotorStep   = 337;
                        }
                    }
                    else 
                    {  
                        if(cZipCnt == 1)
                        {
                            length_buff = cRealPos - save_buff;
                            SetData32bits(QDN_PARAM_ZIPPER_LENGTH_ADDR,length_buff);  //测量记录长度
                        }     
                        QDN_MotorStep   = 337;
                    } 
                    break;                    
                case 337:   
                    QDN_MotorStep   = 390;
                    
//                    SetDir(X_AXIS, QDN_DIR_N);
//                    if(dwTickCount >= QDN_MotorDelay) 
//                    {
//                        AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,-QDN_PARAM_FZ_LENGTH,3000,QDN_PARAM_ACC,QDN_PARAM_DCC);                                   
//                        QDN_MotorStep   = 0;
//                    }
                    break;
              //350步到369步单感应模式   
                case  350:  
                    back_buff = cRealPos;
                     gou_zhen_buff = cRealPos;
                     save_buff=cRealPos;
                    QDN_MotorStep   = 351;   
                    break;
                case 351:  
                    if(dwTickCount >= QDN_MotorDelay)
                    {   
                        QDN_MotorStep   = 352; 
                        //第一,二条都是过链感应，测量长度
                        if(cZipCnt < 2)
                        {
                            if(QDN_PARAM_BL_ENABLE)  //因为长度未知,只能通过过链退合链
                                QDN_BinLianStep = 10;  //并链起动
                            QDN_DGLG_VAVLE = 0;  //顶过链杆关
                            //                  X轴       运行速度                    启动速度        加速度  减速度
                            AxisContinueMoveAcc(X_AXIS,QDN_PARAM_BACK_LOW_SPEED*2,QDN_DIR_P,QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,8,12);
                            QDN_MotorDelay  = dwTickCount + 20;
                        }   
                        else
                        {  
                            if(QDN_PARAM_BL_ENABLE)
                                QDN_BinLianStep = 1;  //并链起动
                            QDN_DGLG_VAVLE = 1;  //顶过链杆关
                            QDN_CheckLengthStep = 1;    //长度检测,第3条才有对比
                            //走数控方式,因第二条中已经测量出来拉链长度，可以直接按长度数控方式走
                            QDN_MotorStep   = 311; 
                        }  
                    }
                    break;
                case 352:
                  //前两条都按最低速度工作
                        if(QDN_GUO_LIAN_IN_UP)
                        {                                 
                            checkdelay_buff = cRealPos;
                            AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);    
                            QDN_MotorDelay  = dwTickCount + 20;
                         }  
                        if(QDN_GUO_LIAN_IN && dwTickCount >= QDN_MotorDelay)
                        {
                              QDN_MotorDelay  = dwTickCount + QDN_PARAM_FEEL_GZ_DELAY;//QDN_PARAM_DELAY_XM;
                              QDN_MotorStep   = 353;
                        }
                        else if(!QDN_GUO_LIAN_IN)
                        {
                           QDN_MotorDelay  = dwTickCount + 20;
                        }
                    break;
                 case 353:
                    //此步为前两条运行
                    if(dwTickCount >= QDN_MotorDelay)
                    {
                        QDN_MotorStep   = 354;
                        QDN_GZ_VAVLE = 1;
                    }   
                    if(QDN_GUO_LIAN_IN_DW)
                    {                  
                        gou_zhen_buff = cRealPos;
                        QDN_MotorStep   = 355;
                        QDN_GZ_VAVLE = 1;
                    }                                                       
                    break;   
                case 354:
                   if(QDN_GUO_LIAN_IN_DW)  //下降沿,定位长度
                   {      
                        if(QDN_GUO_LIAN_IN_DW)
                        {                  
                            gou_zhen_buff = cRealPos;
                            QDN_MotorStep   = 355;
                            QDN_GZ_VAVLE = 1;
                        }                     
                   }
                   break;
                case 355:	                                           
                    //在空们都把延时清零    
                    if(QDN_GOUZHEN_HOU_IN)
                    {                      
                           AxisEgmStop(X_AXIS);
                           QDN_MotorDelay  =    dwTickCount + 10;
                           QDN_YD_VAVLE = 1;
                           QDN_MotorStep   = 356;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                    }                   
                    break;
                case 356:                                              
                    if(cZipCnt == 1)
                    {
                        length_buff = cRealPos - save_buff;
                        SetData32bits(QDN_PARAM_ZIPPER_LENGTH_ADDR,length_buff);  //测量记录长度
                     }     
                     QDN_MotorStep   = 357;
                    
                    break;                    
                case 357:
                    QDN_MotorStep   = 390;   //延时反转步
 //                   SetDir(X_AXIS, QDN_DIR_N);
 //                   AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,-QDN_PARAM_FZ_LENGTH,3000,QDN_PARAM_ACC,QDN_PARAM_DCC);                                   
 //                   QDN_MotorStep   = 0;
                    break;
                               
        //370步到389步为数控模式                    
                case 370:
                    QDN_MotorStep   = 371;   
         //           QDN_JZ_DIR   = QDN_YDIR_P; 
                    if(QDN_PARAM_BL_ENABLE)
                        QDN_BinLianStep = 1;  //并链起动
                    
                    QDN_CheckLengthStep = 1;  //长度检测开始
                    
                    break;
                case 371:   
                   if(dwTickCount >= QDN_MotorDelay)
                   {   
                     back_buff = cRealPos;
                     gou_zhen_buff = cRealPos;
                     save_buff = cRealPos;

                            //李永庆代码                                                   
                      SetDir(X_AXIS, QDN_DIR_P);
\
                     AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH-QDN_PARAM_BACK_LOW_SPEED_LENGTH,
                                               QDN_PARAM_START_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);
                           
                     QDN_MotorDelay  =    dwTickCount + MOTOR_ALARM_TIME;
                     QDN_MotorStep   = 372;
                   }
                    break;   
		case 372:
                      //勾针提前输出
                       if (!QDN_GZ_VAVLE && ((cRealPos + QDN_PARAM_GOUZHEN_LENGTH) >= (QDN_PARAM_ZIPPER_LENGTH )))
                            QDN_GZ_VAVLE = 1;

                       if((cRealPos + QDN_PARAM_BACK_LOW_SPEED_LENGTH + 20) > (QDN_PARAM_ZIPPER_LENGTH + (*length_buffer))) //- (*length_buffer) - (QDN_PARAM_BACK_LOW_SPEED_LENGTH + PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC)))))
                       {           
                            QDN_MotorDelay  = dwTickCount + 2000; //钩针未到位延时警告
                            QDN_MotorStep   = 373;                                 
                       }
                       else if(cRealPos >= (QDN_PARAM_ZIPPER_LENGTH + (*length_buffer)))//QDN_PARAM_ERROR_LENGTH))
                       {
                           QDN_SetAlarmCode(QDN_GZ_ALARM);
                       }                  
		      break;
                case 373:
                      //勾针提前输出
                       if (!QDN_GZ_VAVLE && ((cRealPos + QDN_PARAM_GOUZHEN_LENGTH) >= (QDN_PARAM_ZIPPER_LENGTH )))
                            QDN_GZ_VAVLE = 1;
                       
  //提前12MM取消数控模式,进入连续运动
//                       if((cRealPos + 100) > (QDN_PARAM_ZIPPER_LENGTH ))
//                       {
//                            //CancelPmoveState(X_AXIS);
//                            SetStartSpeed(X_AXIS,1500);
//                            AxisChangeSpeed(X_AXIS,1500);
//                       }
                       if(QDN_GOUZHEN_HOU_IN)
                       {                      
                           AxisEgmStop(X_AXIS);
                           QDN_MotorDelay  =    dwTickCount + 0;
                           QDN_YD_VAVLE = 1;

                           QDN_MotorStep   = 374;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                       }
                       else if((cRealPos >= (QDN_PARAM_ZIPPER_LENGTH  + QDN_PARAM_ERROR_LENGTH)) && QDN_PARAM_ERROR_LENGTH)
                       {
                           AxisEgmStop(X_AXIS);
                            if(dwTickCount >= QDN_MotorDelay)                            
                                QDN_SetAlarmCode(QDN_GZ_ALARM);
                       }   
                        break;
                case 374:
                       if(!X_DRV)
                       {    
                            QDN_MotorDelay  =    dwTickCount + VAVLE_ALARM_TIME;
                            QDN_YD_VAVLE = 1;
                            QDN_MotorStep   = 375;
                       }   
                       break;
                case 375:    
                        if(cZipCnt == 0)  //第一条把误差到正负9MM
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH - 90; 
                           kk = QDN_PARAM_ZIPPER_LENGTH + 90;
                       }   
                       else
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH;                            
                           kk = QDN_PARAM_ZIPPER_LENGTH;                           
                       }
 
                       if(((cRealPos + QDN_PARAM_ERROR_LENGTH) < (ch))) 
                       { 
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }          
                       else if((cRealPos > (kk + QDN_PARAM_ERROR_LENGTH)))//(QDN_PARAM_ERROR_LENGTH - 200 + (*length_buffer)+50)))
                       {
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }     
                       else
                       {
//                            SetDir(X_AXIS, QDN_DIR_N);
//                            AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,-QDN_PARAM_FZ_LENGTH,3000,QDN_PARAM_ACC,QDN_PARAM_DCC);                                   
                            QDN_MotorStep   = 390;  //延时反转步
                       }                       
                       break;
                    //此两步为到位后反转步
                case 390:
                    //SetDir(X_AXIS, QDN_DIR_N);
                    QDN_YD_VAVLE=1;//先压带后延时反转
                    QDN_MotorDelay  =    dwTickCount + QDN_PARAM_YD_FZ_DELAY;
                    QDN_MotorStep   = 391; 
                    break;
                case 391:    
                    if(dwTickCount >= QDN_MotorDelay) 
                    {
                        //SetDir(X_AXIS, QDN_DIR_N);
                        AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,-QDN_PARAM_FZ_LENGTH,3000,3000,QDN_PARAM_ACC,QDN_PARAM_DCC,0); 
                        QDN_MotorStep   = 392;
                    }
                    break;
                case 392:
                    if(!X_DRV)
                    {
                      QDN_MotorStep   = 0;
                    }
                    break;
#if 0     //下面为老的数控模式     
                case 30:
                        QDN_MotorDelay  =    dwTickCount + QDN_PARAM_DELAY_BACK;                        
                        length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                        if(QDN_PARAM_BL_ENABLE)   //
                            QDN_BinLianStep = 1;

                        if(QDN_MACHINE_TYPE == QDN_CS_TUIFANGKUAI)   //双开带过链感应
                        {
                             if(QDN_PARAM_DEC_MODE == QDN_BACK_NOMAL_DEC_MODE)//测长数控
                                 QDN_MotorStep   = 101;
                             else 
                                 QDN_MotorStep   = 31;
                        }
                        else  //闭口走长度
                             QDN_MotorStep   = 31;
                        break;
                case 31:	                                       
                        if(dwTickCount >= QDN_MotorDelay)
                        {   
                            back_buff = cRealPos;
                            gou_zhen_buff = cRealPos;
                            save_buff = cRealPos;
                            length_buffer = &QDN_PARAM_OFFSET_LENGTH;
                            //李永庆代码                                                   
                            SetDir(X_AXIS, QDN_DIR_N);
                            //两段速度移动距离
                            //               轴     第一段速度  第一段长度要减去送链长度  第二段速度 第二段长度  方向
                            AxisMoveTwoPos(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH-QDN_PARAM_BACK_LOW_SPEED_LENGTH-200,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_BACK_LOW_SPEED_LENGTH + (*length_buffer),QDN_DIR_P);
                           
                            //AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_BACK_SPEED,QDN_PARAM_ZIPPER_LENGTH-QDN_PARAM_BACK_LOW_SPEED_LENGTH,QDN_PARAM_START_SPEED,QDN_PARAM_BACK_LOW_SPEED,4,QDN_PARAM_DCC+8);
                            
                            SetDir(X_AXIS,QDN_DIR_P);
                            QDN_MotorDelay  =    dwTickCount + MOTOR_ALARM_TIME;
                            QDN_MotorStep   = 32;
                        }
			break; 
		case 32:
                   //勾针提前输出
                       if (!QDN_GZ_VAVLE && ((cRealPos + QDN_PARAM_GOUZHEN_LENGTH + 200) >= (QDN_PARAM_ZIPPER_LENGTH )))
                            QDN_GZ_VAVLE = 1;

                       if((cRealPos) > (QDN_PARAM_ZIPPER_LENGTH-QDN_PARAM_BACK_LOW_SPEED_LENGTH)) //- (*length_buffer) - (QDN_PARAM_BACK_LOW_SPEED_LENGTH + PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC)))))
                       {           
                            QDN_MotorDelay  = dwTickCount + 2000; //钩针未到位延时警告
                            QDN_MotorStep   = 33;                                 
                       }
                       else if(cRealPos >= (QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)))//QDN_PARAM_ERROR_LENGTH))
                       {
                           QDN_SetAlarmCode(QDN_GZ_ALARM);
                       }                  
			break;
                case 33:
                       if(!QDN_GZ_VAVLE && (cRealPos + QDN_PARAM_GOUZHEN_LENGTH + 200) > (QDN_PARAM_ZIPPER_LENGTH ))
                       {
                         QDN_GZ_VAVLE = 1;
                         QDN_MotorDelay  = dwTickCount + 2000; //钩针未到位延时警告
                       }   
                       //提前12MM取消数控模式,进入连续运动
//                       if((cRealPos + 180 + 200) > (QDN_PARAM_ZIPPER_LENGTH ))
//                       {
//                            CancelPmoveState(X_AXIS);
//                            SetStartSpeed(X_AXIS,1500);
//                            AxisChangeSpeed(X_AXIS,1500);
//                       }
                       if(QDN_GOUZHEN_HOU_IN)
                       {                      
                           AxisEgmStop(X_AXIS);
                           QDN_MotorDelay  =    dwTickCount + 10;
                           QDN_YD_VAVLE = 1;
                           QDN_MotorStep   = 34;
                           QDN_BL_VAVLE = 0;  //停止时并链一定要打开
                       }
                       else if((cRealPos >= QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)))// && dwTickCount >= QDN_MotorDelay)
                       {
                          AxisEgmStop(X_AXIS);
                          if(dwTickCount >= QDN_MotorDelay)                            
                              QDN_SetAlarmCode(QDN_GZ_ALARM);
                       }
                        break;
                case 34:
                       if(!X_DRV && (dwTickCount >= QDN_MotorDelay))
                       {    
                            QDN_MotorDelay  =    dwTickCount + VAVLE_ALARM_TIME;
                            QDN_YD_VAVLE = 1;
                            QDN_MotorStep   = 35;
                       }   
                       break;
                case 35:
                       if(cZipCnt == 0)
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)-90; 
                           kk = QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)+90;
                       }   
                       else
                       {
                           ch = QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)-70;                            
                           kk = QDN_PARAM_ZIPPER_LENGTH - 200 + (*length_buffer)+70;                           
                       }user_datas[128] = ch; 
                       user_datas[127] = kk;   
                       if(((cRealPos) < (ch))) 
                       { 
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }          
                       else if((cRealPos > kk))//(QDN_PARAM_ERROR_LENGTH - 200 + (*length_buffer)+50)))
                       {
                            SetAlarmCode(QDN_ALARM_ADDR,QDN_LENGTH_LONG_ALARM);   
                            if(dwTickCount >= QDN_MotorDelay)
                                bAlarmStop = 1;
                       }     
                       else
                            {
                               SetDir(X_AXIS, QDN_DIR_N);

                                SetDir(X_AXIS, QDN_DIR_P);
                                 AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,-QDN_PARAM_FZ_LENGTH,3000,QDN_PARAM_ACC,QDN_PARAM_DCC);                                   
                               SetDir(X_AXIS, QDN_DIR_P); 
                                 QDN_MotorStep   = 0;
                            }
                       
                        break;                       
                case 101:	                                       
                        if(dwTickCount >= QDN_MotorDelay)
                        {   
                            back_buff = cRealPos;
                            gou_zhen_buff = cRealPos;
                            save_buff = cRealPos;
                            
                            if(cZipCnt <= 2)
                            {
                                QDN_MotorDelay  = dwTickCount + MOTOR_ALARM_TIME;
                                MoveAction_Const_AccDec(X_AXIS,QDN_DIR_P,QDN_PARAM_FIRST_SPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);                                                                    
                                QDN_MotorStep   = 102;
                            }
                            else
                            {
                                MoveAction_Const_AccDec(X_AXIS,QDN_DIR_P,QDN_PARAM_BACK_SPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);   
                                QDN_MotorStep   = 102;                           
                            }
                        }
			break;
                case 102:                     
                            if(cZipCnt <= 2)
                            {
                                //拉链上升沿,就是到空位
                                if(QDN_GUO_LIAN_IN_UP)     
                                {
                                    QDN_MotorDelay  = dwTickCount + QDN_PARAM_GZ_DELAY;
                                    if(X_DRV)
                                      AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);  //降速
                                    QDN_MotorStep   = 103;
                                }
                            }
                            else
                            {   
                              //1为双开
                               if((QDN_SK_MODE) && (((cRealPos + QDN_PARAM_YALIAN_LENGTH- gou_zhen_buff) > (length_buff - QDN_PARAM_GOUZHEN_LENGTH))))
                               {
                                 
 //                                   QDN_HL_VAVLE = 1;
                               }   
                                if(((cRealPos - gou_zhen_buff) > (length_buff - QDN_PARAM_GOUZHEN_LENGTH)) && !QDN_GZ_VAVLE)
                               {
                                    QDN_GZ_VAVLE = 1;
                                    
                               }
                               if((cRealPos - back_buff) > (length_buff - QDN_PARAM_BACK_LOW_SPEED_LENGTH-PulseToPos(X_AXIS,MV_Cal_Dec_pulse(QDN_PARAM_BACK_SPEED,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_DCC))))
                               {                 
                                   if(X_DRV)
                                   {
                                       AxisChangeSpeed(X_AXIS,QDN_PARAM_BACK_LOW_SPEED);   
                                   }                        
                                   QDN_MotorStep   = 103;
                               }                           
                            }
                        break;
		case 103:
                            if(cZipCnt <= 2)
                            {//双开暂不用,先保留
                            #if QDN_SK_MODE
                                if((QDN_SK_MODE) && ((dwTickCount + QDN_PARAM_GZ_DELAY/2)  >= QDN_MotorDelay))
                                {
                                    QDN_YX_VAVLE = 1;
                                    QDN_HL_VAVLE = 1;
                                } 
                            #endif
                                if(dwTickCount >= QDN_MotorDelay)
                                {
                                    QDN_GZ_VAVLE = 1;
//                                    QDN_YX_VAVLE = 1;
                                  #if QDN_SK_MODE   //双开暂不用,先保留
                                    if(QDN_SK_MODE)
                                        QDN_MotorStep   = 154;
                                    else
                                #endif     
                                        QDN_MotorStep   = 160;
                                }  
                            }
                            else
                            {
                            #if QDN_SK_MODE   //双开暂不用,先保留
                               if((QDN_SK_MODE) && (((cRealPos + QDN_PARAM_YALIAN_LENGTH- gou_zhen_buff) > (length_buff - QDN_PARAM_GOUZHEN_LENGTH))))
                               {
                                    QDN_YX_VAVLE = 1;
                                    QDN_HL_VAVLE = 1;
                               }   
                            #endif  
                               if(((cRealPos - gou_zhen_buff) > (length_buff - QDN_PARAM_GOUZHEN_LENGTH)))
                               {
                                   QDN_GZ_VAVLE = 1; 
 
                                #if QDN_SK_MODE   //双开暂不用,先保留
                                    if(QDN_SK_MODE)
                                        QDN_MotorStep   = 154;
                                    else
                                #endif       
                                        QDN_MotorStep   = 160;   
                               }
                                      
                               
                                 if(((cRealPos - save_buff) >= (QDN_PARAM_ERROR_LENGTH + length_buff)) && QDN_GZ_VAVLE)
                               {
                                   QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                               }
                            }
			break;
                case 154:
                    #if QDN_SK_MODE   //双开暂不用,先保留
                        if(QDN_GZ_UP_IN)
                        {
                           QDN_MotorDelay  = dwTickCount + QDN_PARAM_DELAY_CHECK_GZ;
                           QDN_MotorStep   = 104;
                        }
                    #endif
                        break;
                case 160:                  
                         if(QDN_GOUZHEN_HOU_IN)
                         {
                             AxisEgmStop(X_AXIS);
                             QDN_YD_VAVLE = 1;
                             QDN_MotorStep   = 105;
                         }
                         else if(((cRealPos - save_buff) >= (QDN_PARAM_ERROR_LENGTH + length_buff)) && QDN_GZ_VAVLE && (cZipCnt > 2))
                         {
                             QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                         }
                        break;     
                case 104:
                      #if QDN_SK_MODE   //双开暂不用,先保留
                        if(dwTickCount >= QDN_MotorDelay)
                        {
                          //勾针离开就是到位
                              if(!QDN_GOUZHEN_HOU_IN && QDN_GZ_UP_IN)
                             {
                                 AxisEgmStop(X_AXIS);                             
                                 QDN_MotorStep   = 105;
                             }
                        }
                     #endif
                        break;
                case 105:
                       if(!X_DRV)
                      {
                             QDN_MotorStep   = 0;
//                             QDN_HL_VAVLE = 1;
                             QDN_YD_VAVLE = 1;
                       
                            if(cZipCnt == 1)
                            {
                                go_length_buff = cRealPos - back_buff;
                            }
                            else if(cZipCnt == 2)
                            {
                                length_buff = cRealPos - back_buff;
                            }
                            else if(cZipCnt > 2)
                            {
                                if(((cRealPos - save_buff) < (length_buff - QDN_PARAM_ERROR_LENGTH- (*length_buffer))))QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                                else if(((cRealPos - save_buff) > (QDN_PARAM_ERROR_LENGTH + length_buff - (*length_buffer))))QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
                                else
                                {

                                }
                            }
                            AxisMovePosAccDec(X_AXIS,QDN_PARAM_BACK_LOW_SPEED,QDN_PARAM_FZ_LENGTH,1,QDN_PARAM_ACC,QDN_PARAM_DCC);                                   
                            
                       }
                       break;
                case 106:
                           if(!X_DRV)
                           {
                               QDN_SetAlarmCode(QDN_GZ_ALARM);
                           }
                           else
                           {
                               if(QDN_GOUZHEN_HOU_IN)
                               {
                                   AxisEgmStop(X_AXIS);
                                   QDN_YD_VAVLE = 1;
                                   QDN_MotorStep   = 0;
                               }
                           }
                              
                        break; 
#endif                        
		case 40:     
                    if(!QDN_SecondXiaQueStep)
                    {
                        if(QDN_PARAM_SJZ_LENGTH == 0)
                        {
                          QDN_MotorDelay  = dwTickCount + QDN_PARAM_CUT_BACK_DELAY;
                            QDN_JD_VAVLE = 0; 
                        }
                        else
                            QDN_MotorDelay     = dwTickCount + 3;
                    }
                    else
                    {
                      if(QDN_PARAM_Secondleave_LENGTH == 0)
                          {
                            QDN_MotorDelay  = dwTickCount + 20;
                              QDN_JD_VAVLE = 0; 
                          }
                          else
                              QDN_MotorDelay    = dwTickCount + 3;
                    
                    }
                      
                        SetDir(X_AXIS, QDN_DIR_N);  
                        QDN_MotorStep   = 41;
                        jz_buff = cRealPos;
                        break; 
                case 41:   
                  if(!QDN_SecondXiaQueStep)
                  {
                    if((dwTickCount >= QDN_MotorDelay))
                    { 
                         //夹子已经张开
                         AxisMovePosAccDec(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_SJZ_LENGTH+QDN_PARAM_BACK_LENGTH),
                                           QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,10,10,0);
                        //  AxisMovePos(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_SJZ_LENGTH+QDN_PARAM_BACK_LENGTH));
                           QDN_MotorStep   = 42;   
                    }
                  }
                  else
                  { 
                    if((dwTickCount >= QDN_MotorDelay))
                    { 
                     AxisMovePosAccDec(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_Secondleave_LENGTH+QDN_PARAM_BACK_LENGTH),
                                       QDN_PARAM_START_SPEED,QDN_PARAM_START_SPEED,10,10,0);
                          //  AxisMovePos(X_AXIS,QDN_PARAM_CUT_BACK_SPEED,(QDN_PARAM_SJZ_LENGTH+QDN_PARAM_BACK_LENGTH));
                             QDN_MotorStep   = 42;   
                    }
                  }
                        break;
		case 42:	 
                        if(!QDN_SecondXiaQueStep)
                            {
                                    if(((QDN_PARAM_SJZ_LENGTH) <= (cRealPos - jz_buff)))
                                    {
                                        QDN_JD_VAVLE = 0;
                                    }
                            }
                        else
                        {
                          if(((QDN_PARAM_Secondleave_LENGTH) <= (cRealPos - jz_buff)))
                                {
                                    QDN_JD_VAVLE = 0;
                                }
                        }
                  
                            if(!X_DRV)
                          {
                              QDN_JD_VAVLE = 0;
                              QDN_MotorStep   = 43;
                          }
                        break;
                case 43:	                           // 切断完成后拉电机动作
                        if(!X_DRV)
                        {
                            QDN_MotorStep   = 0;
                            QDN_MotorDelay  =    dwTickCount;
                        }
                        break;   
                case 61: // 前点定位数控模式
                        QDN_BL_VAVLE = 0;//并链也要打开
                        if(dwTickCount >= QDN_MotorDelay)
                        {  
                        
                            
             //               QDN_JZ_DIR   = QDN_YDIR_N; 
                            if(!QDN_TL_VAVLE && cZipCnt)  //没送链情况下主动送链
                            {
                                if(!QDN_SHANG_MU_LIMIT_IN && (QDN_TuiLianStep == 0))
                                {
                                     QDN_TuiLianStep = 1;
                                     QDN_MotorStep = 62;
                                }                          
                            }
                            else
                                QDN_MotorStep = 62;
                        }
                        break;
                case 62:
                        if(dwTickCount >= QDN_MotorDelay)
                        {                            
                            if(QDN_QIAN_LIMIT_IN)
                            {
                                SetPos(X_AXIS, 0);//在前点，直接置零点

                                //前点亮的情况下先退出
                                AxisMovePos(X_AXIS,QDN_PARAM_GO_LOW_SPEED,1000);                           
                                QDN_MotorDelay = dwTickCount + 300;
                            }
                            QDN_MotorStep = 63;            
                            QDN_JD_VAVLE = 0;  
                        }
			break;
		case 63:
                        if(!X_DRV && !QDN_QIAN_LIMIT_IN && (dwTickCount >= QDN_MotorDelay))// && !QDN_SHANG_MU_LIMIT_IN)
                        {

                            //SetDir(X_AXIS, QDN_DIR_N);
                            go_buff  = cRealPos;
                            QDN_YD_VAVLE = 1;
 //                           QDN_HL_VAVLE = 1;      
 //                           QDN_YX_VAVLE = 1;
                            //李永庆代码,当位置在慢速之外,走数控到慢速点
                            if(cZipCnt > 0)
                            {
                             
                                if(cRealPos>(QDN_PARAM_GO_LOW_SPEED_LENGTH))   
                                {   
                                  
                //                        AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos-QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
               //                SetStartSpeed(X_AXIS,QDN_PARAM_START_SPEED);
                //              SetAccTime(X_AXIS,QDN_PARAM_ACC); 
                //              SetDecTime(X_AXIS,QDN_PARAM_DCC);
                              //两段速度移动距离
                                    //               轴     第一段速度  第一段长度  第二段速度 第二段长度  方向
               //                  AxisMoveTwoPos(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos-QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED_LENGTH+ 100,QDN_DIR_N);  
                                  //跑三段速度   
//                                 AxisMoveThreePosNoStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,cRealPos -QDN_PARAM_GO_LOW_SPEED_LENGTH-300,
//                                                QDN_PARAM_GO_HIGH_SPEED*2/3,350,
//                                                QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_DIR_N) ; 
                                 
                                 AxisMovePosAccDecNotStop(X_AXIS,QDN_PARAM_GO_HIGH_SPEED,-(cRealPos -QDN_PARAM_GO_LOW_SPEED_LENGTH),
                                               QDN_PARAM_START_SPEED,QDN_PARAM_GO_LOW_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC,0);
                                } 
                                else
                                 {
                                    //                  X轴       运行速度                    启动速度        加速度  减速度
                                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED/3,QDN_PARAM_GO_LOW_SPEED/3,15,15);
       
                                   //   MoveAction_Const_AccDec(X_AXIS, QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED_LENGTH,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);
                                  }
                              
                            }
                            else
                            {
                               //                  X轴       运行速度                    启动速度        加速度  减速度
                                    AxisContinueMoveAcc(X_AXIS,QDN_PARAM_GO_LOW_SPEED,QDN_DIR_N,QDN_PARAM_GO_LOW_SPEED/3,QDN_PARAM_GO_LOW_SPEED/3,15,15);
                              // MoveAction_Const_AccDec(X_AXIS, QDN_DIR_N,QDN_PARAM_FIRST_GO_HIGHSPEED,QDN_PARAM_START_SPEED,QDN_PARAM_ACC,QDN_PARAM_DCC);//
                            }
                            
                            QDN_MotorDelay =    dwTickCount + MOTOR_ALARM_TIME;
                            QDN_MotorStep   =64;
                        }  
                       
			break;
                case 64:
                        if(cZipCnt > 1)
                        {                         
                              //李永庆代码
                              if(((cRealPos) < (QDN_PARAM_GO_LOW_SPEED_LENGTH+1200)))// || (QDN_QIAN_DEC_IN))
                              {
                                   //user_datas[126]= GetCurSpeed(X_AXIS);
                               //     MoveChangSpeedDec(X_AXIS,QDN_PARAM_GO_HIGH_SPEED*2/3,6,8);
                             //    AxisChangeSpeed(X_AXIS,40);
                                   QDN_MotorStep   =65;
                              }
                                if(QDN_QIAN_LIMIT_IN)  //前点限位
                                {
                                    SetPos(X_AXIS, QDN_PARAM_BKQIANDIAN_LENGTH);
                                    //AxisEgmStop(X_AXIS);
                                    QDN_MotorStep   = 66;                            
                                }
                        }
                        else
                        {                            
                            if(QDN_QIAN_LIMIT_IN)  //前点限位
                            {
                                //AxisEgmStop(X_AXIS);
                                SetPos(X_AXIS, QDN_PARAM_BKQIANDIAN_LENGTH);
                                QDN_MotorStep   = 66;                            
                            }
                        }

                        break;
		case 65:
                        if(QDN_QIAN_LIMIT_IN)
                        {
                            
                            //AxisEgmStop(X_AXIS);
                            SetPos(X_AXIS, QDN_PARAM_BKQIANDIAN_LENGTH);
                            QDN_MotorStep   = 66;      
                            
                        }
                        else if(dwTickCount >= QDN_MotorDelay)
                            QDN_SetAlarmCode(QDN_NO_ZIPPER_ALARM);
                        
                        break;
		case 66:
                        if(!X_DRV || cRealPos<=0)
                        {   
                            AxisEgmStop(X_AXIS);
                            SetPos(X_AXIS, 0);
                            QDN_MotorDelay =    dwTickCount + 15;
                            QDN_MotorStep   = 67;
                        }
			break;   
		case 67:  //等推链完成后,
                        if((dwTickCount >= QDN_MotorDelay) && (QDN_TuiLianStep == 0) && ((QDN_PARAM_TIAOSHI_MODE && QDN_bTS) || (QDN_PARAM_TIAOSHI_MODE == 0)) )
                        {
                            if(bRunning)
                            {
                                QDN_JD_VAVLE = 1;
                                QDN_MotorDelay =    dwTickCount + QDN_PARAM_DELAY_BACK;
                            }
                            QDN_MotorStep   = 68;
                        }
			break;
                case 68:
                        if(dwTickCount >= QDN_MotorDelay)
                        {
                            QDN_YD_VAVLE = 0;
                            
//                            QDN_HL_VAVLE = 0;      
//                           QDN_YX_VAVLE = 0;
                            QDN_TL_VAVLE    = 0;
                            QDN_MotorStep   = 0;
                            QDN_MotorDelay  = dwTickCount;
                        }
                        break;
               
	}
}
#endif
//电机动作
void QueDuan_Motor(void)	 
{
    if(QDN_PARAM_KAIBEE_SELECT) //闭口
    {
  
        QueDuan_Motor_NoGL(); 
       
    }
    else  //开口
    {
//开口
        QueDuan_Motor_KK();  //

    }  
//     switch(QDN_MACHINE_TYPE)  
//     {
 //        case QDN_NO_CS_TUIFANGKUAI: QueDuan_Motor_CS();break;
 //        case QDN_NO_GL_TUIFANGKUAI: QueDuan_Motor_NoGL();break;
 //        case QDN_CS_TUIFANGKUAI:break;
 //        default:;
//     }
}

//超声方式下切,开口专用
void QueDuan_XiaQue_KK(void)	
{
   switch(QDN_XiaQieStep) 
    {
        case 0:
                break;
        case 1:
/*          
             if(bRunning)
             {
                 QDN_XiaQieStep = 6;                  
                 QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;
                 if(QDN_SAFE_IN)
                 {
                    bStop = 1;
                     QDN_XM_VAVLE   = 0;
                 }
               }
               else
*/          
                 QDN_XiaQieStep = 2;                     
                break;
        case 2:             
                QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;
                QDN_XiaQieStep = 3;   
               break;
        case 3:
                if(1)
                {
                    QDN_XiaQieDelay = dwTickCount + 0;//QDN_PARAM_GZ_DELAY;
                    QDN_XiaQieStep = 4; 
                }
                else if(dwTickCount >= QDN_XiaQieDelay)
                {
                    QDN_SetAlarmCode(QDN_XM_DAOWEI);
                }
                break;
        case 4:   
                if(QDN_GZ_VAVLE)  //勾针已经有输出就不需要延时
                {
                    QDN_XiaQieDelay = dwTickCount + 0;
                }
                else
                   QDN_XiaQieDelay = dwTickCount + QDN_PARAM_TFK_DELAY;
                QDN_GZ_VAVLE  = 1;
                cTuiFangKuaiCnt=0;
                QDN_XiaQieStep = 5;  
                
                break;
        case 5:  
                if(dwTickCount >= QDN_XiaQieDelay)
                {
                    QDN_TFK_VAVLE = 1;
                    QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;
                    QDN_XiaQieStep = 6;  
                }
                break;
        case 6: 
                if(1)
                {                         
                    QDN_XiaQieStep = 7;  
                    QDN_XiaQieDelay = dwTickCount + 1000;
                }
                else if(dwTickCount >= QDN_XiaQieDelay)
                {
                    QDN_SetAlarmCode(QDN_GZ_ALARM);
                    QDN_TFK_VAVLE=0;
                    QDN_GZ_VAVLE=0;
                }
                break;
        case 7:
               if(QDN_GOUZHEN_QIAN_IN /*| !bRunning*/ )
               {                
                   cTuiFangKuaiCnt = 0;
                   //QDN_YD_VAVLE    = 1;
                   if(!bRunning)
                     QDN_XiaQieDelay = dwTickCount + 200;
                   else
                     QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CUT_DELAY;
                   
                   if(!QDN_QIAN_LIMIT_IN)
                   {
                       QDN_XiaQieStep = 8;  
                   }
                   else
                   {
                       QDN_SetAlarmCode(QDN_QIAN_LIMIT_ALARM);
                        QDN_TFK_VAVLE=0;
                        QDN_GZ_VAVLE=0;
                   }
               }
               else if((dwTickCount >= QDN_XiaQieDelay))
               {  
                   if(cTuiFangKuaiCnt < QDN_PARAM_TFK_NUMBER)
                   {
                       QDN_TFK_VAVLE = 0;
                       cTuiFangKuaiCnt++;
                       QDN_XiaQieDelay = dwTickCount + 500;
                       QDN_XiaQieStep = 100;   
                   }
                   else   
                   {
                       QDN_SetAlarmCode(QDN_GZ_ALARM);                         
                      QDN_TFK_VAVLE=0;
                      QDN_GZ_VAVLE=0;
                   }
               }
               break;
        case 100:
               if((dwTickCount >= QDN_XiaQieDelay))
               {
                   QDN_XiaQieStep = 5;   
               }
               break;
        case 8://上下模同时输出
               if(dwTickCount >= QDN_XiaQieDelay)
               {
                  QDN_SM_VAVLE = 1;
                  if(QDN_PARAM_XM_ENABLE == 0)   //配置下模动
                     QDN_XM_KAIKOU_VAVLE=1;
                  QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;
                  QDN_XiaQieStep = 9;   
               }
               break;
    case 9://上下模到位，调试模下的话，等按下一步按键     下模不动
                if(QDN_SHANG_MU_LIMIT_IN && (QDN_KAIKUO_XIAMO_LIMIT_IN || QDN_PARAM_XM_ENABLE) && ((QDN_bTiaoShiMode && QDN_bTiaoShiStep) || (QDN_bTiaoShiMode == 0)) )
                {
                    if(!QDN_PARAM_CS_MODE)   //无超声配置
                    {
                        QDN_XiaQieDelay = dwTickCount + QDN_PARAM_DELAYBACK_SM;       // 
                        QDN_XiaQieStep = 12;        
                    }
                    else
                    {
                        QDN_XiaQieDelay = dwTickCount + QDN_PARAM_DELAY_CS;       // 
                        QDN_XiaQieStep = 10;                      
                    }
                }
                else if(dwTickCount >= QDN_XiaQieDelay)
                {
                    if(!QDN_SHANG_MU_LIMIT_IN)QDN_SetAlarmCode(QDN_SM_DAOWEI);
                    else QDN_SetAlarmCode(QDN_XM_DAOWEI);
                }
                break;
        case 10:
                if(dwTickCount >= QDN_XiaQieDelay)	
                {
 
                        QDN_CS_OUT = 1;
                 //
                    QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CS_TIME;       // 
                    QDN_XiaQieStep = 11;      
                }
                break;
        case 11:
                if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    QDN_CS_OUT = 0;
                    QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CS_COLD_TIME;       // 
                    QDN_XiaQieStep = 12;	
                }
                break;
        case 12:  
               if(dwTickCount >= QDN_XiaQieDelay)
               {
                   
                    QDN_SM_VAVLE   = 0;
                    if(QDN_PARAM_XM_ENABLE == 0)   //配置下模动
                       QDN_XM_KAIKOU_VAVLE=0;
                    if(!QDN_PARAM_TFK_SELECT) //切断后推方块退
                        QDN_TFK_VAVLE  = 0;
                    QDN_GZ_VAVLE = 0;
                    QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;   
                    QDN_XiaQieStep = 13;	
               }// 
                break;
        case 13:
                if(!QDN_SHANG_MU_LIMIT_IN)
                {
                    //启动推链(送链)
                    if((QDN_TuiLianStep == 0) && !QDN_TL_VAVLE)
                       QDN_TuiLianStep = 1;
                }
                if(!QDN_SHANG_MU_LIMIT_IN && (!QDN_KAIKUO_XIAMO_LIMIT_IN || QDN_PARAM_XM_ENABLE))	
                {   
                    QDN_XiaQieStep = 0;                      
                }
                else if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    QDN_SetAlarmCode(QDN_SM_YUANWEI);
                }
                break;
    }	
}


void QueDuan_TuiLianAction(void)
{
    if(QDN_PARAM_XM_ENABLE == 0)
    {
        QDN_TuiLianStep = 0;
    }
    else
    {  
        switch(QDN_TuiLianStep) 
        {
            case 1:
                QDN_TuiLianStep = 2;
            break;
            case 2:
                  QDN_TLDelay     = dwTickCount + QDN_PARAM_YD_DELAY;
                  QDN_TuiLianStep = 3;
            break;
            case 3:
                if(!QDN_SM_VAVLE && !QDN_SHANG_MU_LIMIT_IN)//dwTickCount >= QDN_TLDelay)
                {   
                    QDN_TL_VAVLE    = 1;
                    if(!bRunning)QDN_TFK_VAVLE = 0;
                    QDN_TLDelay     = dwTickCount + QDN_PARAM_TL_DELAY;
                    QDN_TuiLianStep = 4;
                }
            break;
            case 4:
                if(dwTickCount >= QDN_TLDelay)
                {
                    QDN_TuiLianStep = 0;
                }
            break;
            case 10:
             
                QDN_TuiLianStep = 11;
            break;
            case 11:
                if(!Y_DRV)
                {
                   {
                      QDN_TuiLianStep = 0;
                   }
                }
            break;
        }
    }
}

//闭口专用
void QueDuan_XiaQue_NO_GL(void)
{
    switch(QDN_XiaQieStep) 
    {
        case 0:
                break;
        case 1:
                    if(!bRunning)
                    {
                        if(/*(QD_MACHINE_TYPE == QD_CS_TUIFANGKUAI) && */QDN_SK_MODE)
                        {
                            //跳到双开
                           // QDN_YD_VAVLE = 1;

                            QDN_GZ_VAVLE = 1;  //勾针
                            QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CUT_DELAY;
                            QDN_XiaQieStep = 100; 
                        }
                        else
                        {
                       //     QDN_GZ_VAVLE = 1;  //勾针
                            
                       //     QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CUT_DELAY;
                       //     QDN_XiaQieStep = 100;   
                            QDN_YD_VAVLE = 1;
                            QDN_XiaQieStep = 2;                             
                           QDN_XiaQieDelay = dwTickCount + 30;
                        }
                    }
                    else
                    {
                        QDN_YD_VAVLE = 1;
                        QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CUT_DELAY;
                        QDN_XiaQieStep = 2;  
                    }
                break;
        case 2:
               if(dwTickCount >= QDN_XiaQieDelay)
               {
                    QDN_XiaQieStep = 3;  
                    QDN_XiaQieDelay = dwTickCount;
               }
               break;
        case 3:
                if(dwTickCount >= QDN_XiaQieDelay)
                {      
                    if((QDN_PARAM_TIAOSHI_MODE && QDN_bTS) || (QDN_PARAM_TIAOSHI_MODE == 0))
                    {
                        QDN_SM_VAVLE   = 1;
                        if(QDN_PARAM_XM_ENABLE == 0)   //配置下模动
                          QDN_XM_VAVLE   = 1;
                        QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;       // 
                        QDN_XiaQieStep = 4;   
                    }
                }
            break;
        case 4:   
                if(QDN_SHANG_MU_LIMIT_IN && (QDN_XIA_MU_LIMIT_IN || QDN_PARAM_XM_ENABLE))
                {          
                    QDN_GZ_VAVLE   = 0;
                    if(!QDN_PARAM_CS_MODE)  //气切
                    {
                        QDN_XiaQieDelay = dwTickCount + QDN_PARAM_DELAYBACK_SM;       // 
                        QDN_XiaQieStep = 5;      
                    }
                    else
                    {
                        QDN_XiaQieDelay = dwTickCount + QDN_PARAM_DELAY_CS;       // 
                        QDN_XiaQieStep = 10;                      
                    }      // 
                }
                else if(dwTickCount >= QDN_XiaQieDelay)
                {
                    if(!QDN_SHANG_MU_LIMIT_IN)
                        QDN_SetAlarmCode(QDN_SM_DAOWEI);
                    else
                        QDN_SetAlarmCode(QDN_XM_DAOWEI);
                }  
        break;
        case 5:
                if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    
                    QDN_SM_VAVLE   = 0; 
                    if(QDN_PARAM_XM_ENABLE == 0)   //配置下模动
                      QDN_XM_VAVLE   = 0;
                    QDN_XiaQieDelay = dwTickCount + VAVLE_ALARM_TIME;       // 
                    QDN_XiaQieStep = 6;	
                }
        break;
        case 6:
          if(!QDN_SHANG_MU_LIMIT_IN && (!QDN_XIA_MU_LIMIT_IN || QDN_PARAM_XM_ENABLE))  //下模不动就不用判断	
                {   
                    if(QDN_TuiLianStep == 0)
                        QDN_TuiLianStep = 1;
                    if(!bRunning)
                        QDN_JD_VAVLE = 0;
                    QDN_XiaQieStep = 0;                                          
                }
                else if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    QDN_SetAlarmCode(QDN_SM_YUANWEI);
                }
                                
        break;
        //10~11步为超声
        case 10:
                if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    if(QDN_PARAM_CS_ENABLE)QDN_CS_OUT = 1;
                    QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CS_TIME;       // 
                    QDN_XiaQieStep = 11;      
                }
                break;
        case 11:
                if(dwTickCount >= QDN_XiaQieDelay)	
                {
                    QDN_CS_OUT = 0;
                    QDN_XiaQieDelay = dwTickCount + QDN_PARAM_CS_COLD_TIME;       // 
                    QDN_XiaQieStep = 5;	
                }
                break;
        case 100:
               if(dwTickCount >= QDN_XiaQieDelay)
               {
                 
                 //这是双开程序，暂时不考虑
#if 1
                    if(QDN_GOUZHEN_HOU_IN)
                    {
                        QDN_YD_VAVLE = 1;
                        QDN_XiaQieStep = 3;  
                    }
#endif                     
               }
               break;
    }	
}

//第二刀下切步骤
void QueDuan_SecondXiaQue(void)
{
 
  switch(QDN_SecondXiaQueStep) 
  {
      case 1:
          if(dwTickCount >= QDN_SecondXQDelay)
          {	
              QDN_SecondXiaQueStep = 2;	    
              if(QDN_MotorStep == 0)
              {
                  QDN_MotorStep = 61;   //前点定位
              }
          }	
          break;	
    case 2:	 
          if(QDN_MotorStep == 0)
          {   
              QDN_SecondXiaQueStep = 3;	
              QDN_SecondXQDelay = dwTickCount + 20;
         
          }
          break;
    case 3:	
         if(dwTickCount >= QDN_SecondXQDelay)
         {
             AxisMovePosAccDec(X_AXIS,1000,QDN_PARAM_SecondDAO_LENGTH,1000,1000,QDN_PARAM_ACC,QDN_PARAM_DCC,0); 
            QDN_SecondXiaQueStep = 4;
         }
            break;
   case 4:
         if(!X_DRV)
         {
         
         QDN_XiaQieStep=1;
          QDN_SecondXiaQueStep = 5;
         
         }
         break;
  case 5:
     if((QDN_XiaQieStep == 0) || ((QDN_XiaQieStep == 6) && (QDN_PARAM_KAIBEE_SELECT == 1)))
        {
            if(QDN_MotorStep == 0) 
            {
                QDN_MotorStep = 40;     //切完后退
                
            }
            QDN_SecondXiaQueStep = 6;
        }
    break;
  case 6:
    if(QDN_MotorStep == 0)
    {
      QDN_SecondXiaQueStep = 0;
       if(NQDJGNUNMBER==0)
             QDN_AutoStep = 6;
      else if(NQDJGNUNMBER==1)
          QDN_SetAlarmCode(QDN_LENGTH_LONG_ALARM);
      else if(NQDJGNUNMBER==2)
        QDN_SetAlarmCode(QDN_LENGTH_SHORT_ALARM);
    }
    break;
  
  
  }

}

//切断动作
void QueDuan_XiaQue(void)	 
{
  
  if(QDN_PARAM_KAIBEE_SELECT)//QDN_KB_MODE) //闭口
    {
        QueDuan_XiaQue_NO_GL();  //
    }
    else  //开口
    {
        QueDuan_XiaQue_KK(); 
    }  
#if 0  
    switch(QDN_MACHINE_TYPE)
    {	
        case QDN_NO_CS_TUIFANGKUAI:QueDuan_XiaQue_CS();break;	
        case QDN_NO_GL_TUIFANGKUAI:QueDuan_XiaQue_NO_GL();break;
        case QDN_CS_TUIFANGKUAI:QueDuan_XiaQue_NO_GL();break;
        default:;
    }
#endif  
}


#endif