GC23005/Machine/ChangShengGeiLiMachine/GLChuantou_HeLian.c

#include "global.h"
#if CHANG_SHENG_GEI_LI_MACHINE  ==  1

void GL_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag);
void GL_CTHL_ManualAction(void);
void GL_CTHL_AutoStepAction(void);
void GL_CTHL_TableAction(void);
void GL_CTHL_TD_Motor(void);
void GL_CTHL_CL_Motor(void);
void GL_CTHL_CheckStart(void);
void GL_CTHL_TLiao_Step(void);  //推料(推拉头)
void GL_CTHL_AlarmProtect(void);
void GL_CTHL_ZLT_Step(void);
void GL_CTHL_ZhenDongAction(void);
void GL_CTHL_bFKCXTDDWStep(void);
void GL_CTHL_bCXCRStep(void);
void GL_CTHL_bCLFirstStep(void);
void GL_CTHL_HeMo(void);

extern unsigned char LifeSignal;
extern nodelink_master_t master;
extern int nl_send_step; 

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

//故障报警
void GL_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag)
{
    SetAlarmCode(GL_CTHL_ALARM_ADDR,alarm_code);
   //  bAlarmStop = 0;
   // if(cStopFlag)
    if(!cWULATOUCnt)
    {
      bAlarmStop = 1;
    }
    else
    {
      cWULATOUCnt=0;
    }      
}

//初始化动作
void GL_CTHL_InitAction(void)
{
    float buff_pulse,buff_dist;
    
    buff_pulse  = GL_CTHL_PARAM_CYCLE_PULSE;
    buff_dist   = GL_CTHL_PARAM_CYCLE_LENGTH; 
    
    XGearRatio  =  buff_pulse/buff_dist; 
    
    buff_pulse  = GL_CTHL_PARAM_YCYCLE_PULSE;
    buff_dist   = GL_CTHL_PARAM_YCYCLE_LENGTH;
    YGearRatio  =  buff_pulse/buff_dist;
    
    GL_CTHL_bZDP= 1;
    
    bYFirstDingWeiFlg = 1;
    user_datas[121] = 0;
    user_datas[122] = 0;
    user_datas[123] = 0;
    
    SetEnReverse(X_AXIS, 1);
    SetEnReverse(Y_AXIS, 1);
    SetEnReverse(Z_AXIS, 1);
    
    SetDirReverse(X_AXIS, 1);
    SetDirReverse(Y_AXIS, 1);
    SetDirReverse(Z_AXIS, 0);
    
    SetEn(X_AXIS, MOTOR_DISEN);
    SetEn(Y_AXIS, MOTOR_DISEN);
    SetEn(Z_AXIS, MOTOR_DISEN);
    GL_CTHL_AlarmDisEnFlg=0;
    SetAlarmCode(GL_CTHL_ALARM_ADDR,0);   //警告要清除
    GL_CTHL_bSFBBAOJIN_Delay = dwTickCount + 2000;
    
    GL_CTHL_X_EN_FLG=0;
    GL_CTHL_Y_EN_FLG=0;         
    

//    QDCT_SZ_OUT   = QDCT_MOTOR_DISEN;
}

void GL_CTHL_Action(void)
{ 
   // user_datas[121] = LifeSignal;
    //user_datas[122] = master.bus_status;
    //user_datas[123] = master.dev_count;
    //user_datas[124] = master.data_in[0];
   // user_datas[125] = master.data_in[1];
  //  user_datas[126] = master.data_in[2];
    //user_datas[127] = nl_send_step;
    //user_datas[128] = master.data_out[1];
  
//    user_datas[121] = GL_CTHL_ZhuangLiaoStep;
//    user_datas[122] =GL_CTHL_bXCBackOK;
//    user_datas[123] = GL_CTHL_X_CXPosBuff;
    dwXRealPos = GetPos(X_AXIS);
    dwYRealPos = GetPos(Y_AXIS);
    dwZRealPos = GetPos(Z_AXIS);  
    user_datas[124] = dwXRealPos;
    user_datas[125] = GL_CTHL_CXDW_Stop;//GL_CTHL_RunStepSave;//dwYRealPos;
//   
   user_datas[126] = dwYRealPos;//GL_CTHL_CL_MotorStep;
   user_datas[127] = GL_CTHL_LianLengthAutoCheck;//GL_CTHL_TDMotorStepSave;
    user_datas[128] = GL_CTHL_AutoStep;  
    
    GL_CTHL_ZhenDongAction();
    GL_CTHL_AlarmProtect();
    GL_CTHL_CheckStart();    
    GL_CTHL_ZLT_Step();
    GL_CTHL_TLiao_Step();

    GL_CTHL_TD_Motor();
    GL_CTHL_CL_Motor();
    GL_CTHL_bFKCXTDDWStep();
    GL_CTHL_bCXCRStep();
    GL_CTHL_bCLFirstStep();
    GL_CTHL_HeMo();
    GL_CTHL_ManualAction();

    GL_CTHL_AutoStepAction(); 
     
}

void GL_CTHL_AlarmProtect(void)
{ 
    

 
}


//自动动作
void GL_CTHL_AutoStepAction(void)
{  

    if(bRunning && !bAlarmStop)
    {
        switch(GL_CTHL_AutoStep)
        {
            case 1:              
                if(dwTickCount >= GL_CTHL_AutoDelay )
                {  
                    if(!GL_CTHL_XKSC_Limit_IN)
                        GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出 
                    GL_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                           
                    GL_CTHL_FKGD_VAVLE = 0;     //方块固定关

    //                GL_CTHL_XKDW_VAVLE = 1;
                    GL_CTHL_AutoStep = 2;
                     GL_CTHL_AutoDelay=dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                    if(GL_CTHL_HLJJ_VAVLE)
                        bCL_EN_FLG = 1;
                    if(GL_CTHL_ZhuangLiaoStep == 0)
                    { 
                        GL_CTHL_ZhuangLiaoStep = 1;
                        GL_CTHL_TryCnt = 0;
                    }   
                }
                break;
            case 2: 
                if((!GL_CTHL_XKTD_Origin_IN && GL_CTHL_XKTD_VAVLE) || 
                  (!GL_CTHL_XKTD_VAVLE&& GL_CTHL_XKTD_Origin_IN))  //斜口推带原位离开
                {
                    GL_CTHL_AutoStep = 3;
                    if(GL_CTHL_cZipCnt== 0)
                    {
                        GL_CTHL_AutoDelay = dwTickCount + 180;
                    }
                    else
                        GL_CTHL_AutoDelay = dwTickCount;
                    
                } 
                else if(dwTickCount >= GL_CTHL_AutoDelay)  
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_XKTD_Origin_ALARM,bRunning); //斜口推带异常
                    
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 3://斜口定位
                if(dwTickCount >= GL_CTHL_AutoDelay)
                {       
                  //调试模式
                    if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
                        
                        GL_CTHL_AutoStep = 4;
                        GL_CTHL_XKDW_VAVLE = 1;
                        if(GL_CTHL_cZipCnt== 0)
                            GL_CTHL_AutoDelay = dwTickCount + 80;
                        else
                            GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_XKDW_TD_DELAY;
                    }
                }  

                break;
            case 4:
                if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                     
                     if(!cBanAuTo)
              {
                        if(!GL_CTHL_XKSC_Limit_IN)
                        {
          //          AxisContinueMoveAcc(X_AXIS,1000,DIR_P,800,600,10,10);//拖带电机   
                        SetPos(X_AXIS, 0);  //启动位置设为0点
                        dwXRealPos = 0;
                        
                        AxisMovePosAccDecNotStop(X_AXIS,600,200,600,600,10,30,0); 
                        GL_CTHL_bDinweiOK = 0;
                        }
                    
                    GL_CTHL_AutoStep = 5;
                   GL_CTHL_XSavePosBuff = dwXRealPos;
              }
              else
              {
                GL_CTHL_bDinweiOK = 0;
                 GL_CTHL_AutoStep = 5;
                   GL_CTHL_XSavePosBuff = dwXRealPos;
              
              }
                  }
                   
                    
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 5:

                if((dwXRealPos >= GL_CTHL_PARAM_WLCDSHEZHI_LENTH) && GL_CTHL_PARAM_WLCDSHEZHI_LENTH)
                {
 //                  GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning);  
                   //无拉链自动停机
                }
                if((dwXRealPos > (GL_CTHL_LianLengthAutoCheck+2000)) && GL_CTHL_LianLengthAutoCheck && GL_CTHL_cZipCnt>1)
                {
 //                   GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning);  
                   //无拉链自动停机
                }
                if(dwXRealPos>= 190)
                    GL_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸关
//                if((dwXRealPos >= 400) && bCL_EN_FLG)
 //                   GL_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                if(GL_CTHL_XKSC_Limit_IN)   //方块上止到位
                {
//                  if(bCL_EN_FLG)
//                    GL_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                    //AxisEgmStop(X_AXIS);
                    GL_CTHL_GDXM_VAVLE = 1; //固定斜码
                    GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
                    GL_CTHL_bDinweiOK = 1;
                    if(GL_CTHL_PARAM_QianMaSelect==1)  // 尼龙
                    { 
                       AxisEgmStop(X_AXIS);
                        //AxisMovePosAccDec(X_AXIS,850,-25,850,850,6,2,0); //尼龙不用多走
                    }
                    else  //其他
                    {
                        if(((GL_CTHL_bTiaoShiMode) && (!GL_CTHL_START_IN_UP)))
                            AxisEgmStop(X_AXIS);
                        else 
                            AxisMovePosAccDec(X_AXIS,700,GL_CTHL_PARAM_SCDW_LENTH,700,700,6,2,0);  
                    }   
                    //调试模式
//                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                  
                    
                    GL_CTHL_AutoStep = 6;
//                    GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭 
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                    GL_CTHL_bLTCHECK_Delay = dwTickCount + 20;
                    //电机穿入可以启动
                    bCL_OK_FLG = 1;   //不用穿合链的话认为已经完成
                    if(bCL_EN_FLG && !GL_CTHL_PARAM_HL_EN)
                    {
                        bCL_OK_FLG = 0;
                        GL_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                        
                        GL_CTHL_CL_MotorStep = 1;
                        GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_HLJJ_CL_DELAY;
                    } 
                  }
                }
                else if(dwXRealPos >= (GL_CTHL_XSavePosBuff + 850))  //750
                {
                    AxisEgmStop(X_AXIS);
                    GL_CTHL_SetAlarmCode(GL_CTHL_FKCXDW_ALARM,bRunning);  //方块插销定位异常警告
                    
                } 
                
                break;
            case 6:
//                if(GL_CTHL_XKTD_Origin_IN)      //斜口推带回到原位
                {
                    
                    if(bZhuangLiaoOkFlg && (GL_CTHL_ZhuangLiaoStep == 0))
                    {
                         if(dwTickCount >= GL_CTHL_bLTCHECK_Delay)
                         {
                            //单一标志
                            if(bSingOneFlg)
                            {
                                //次数到停止
                                if(bSingOneCnt==0)
                                {
                                  GL_CTHL_AutoStep = 0;
                                  bRunning = 0;
                                }
                            } 
                            if(!bSingOneFlg || (bSingOneFlg && bSingOneCnt))
                            {   
                              //调试模式
                              if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                              {
                                
                                          if(!GL_CTHL_LTou_Check)
                                          {
                                            if(GL_CTHL_HSLiao_Origin_IN)
                                            {
                                               GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭
                                          //  GL_CTHL_CTXMSS_VAVLE = 1; //穿头下模上升
                                            if(!GL_CTHL_CTXMSS_VAVLE)
                                                GL_CTHL_HeMoStep = 1;   //下模的上升和下降电磁阀要配合
                                            GL_CTHL_CXHJD_VAVLE=1;//后夹带
                                            GL_CTHL_AutoStep = 7;
                                            GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                                            //插销上下类型或直码类型需要动作
                                           if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0 || (GL_CTHL_PARAM_QianMaSelect==1 && GL_CTHL_PARAM_ZhiMaDingchu))
                                                GL_CTHL_CXSX_VAVLE = 1;    //插销上下
                                            else//插销前后+三角码类型不用顶出
                                                GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
                                            
                                            //单一标准有效，次数减去1
                                            if(bSingOneFlg)
                                            {
                                              if(bSingOneCnt>0)
                                              bSingOneCnt--;
                                            }
                                            }
                                            else if(dwTickCount >= (GL_CTHL_AutoDelay+3000))
                                            {
                                            
                                                GL_CTHL_SetAlarmCode(GL_CTHL_HSLiao_Origin_ALARM,bRunning);  // 没有拉头
                                            }
                                          }
                                          else
                                          {
                                             cWULATOUCnt=1;
                                            GL_CTHL_SetAlarmCode(GL_CTHL_ZLT_ALARM,bRunning);  // 没有拉头                               
                                          }
                              }
                            }
                         }
                    }  
                }
 //               else if(dwTickCount >= GL_CTHL_AutoDelay)
 //               {
 //                   GL_CTHL_SetAlarmCode(GL_CTHL_XKTD_Origin_ALARM,bRunning); //斜口推带回到异常
 //               }
                break;
            case 7: 
                if(!GL_CTHL_CTM_Origin_IN)
                {
                    GL_CTHL_JLTou_VAVLE = 0;    //接拉头
                }
                if(GL_CTHL_CTM_Limit_IN) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_JLTou_VAVLE = 0;
                    GL_CTHL_AutoStep = 8;
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_DXK_DELAY;
   
                    GL_CTHL_CXHJD_VAVLE=0;//后夹带
                    
                    if(GL_CTHL_PARAM_QianMaSelect == 1) //尼龙的顶斜口不能输出
                        GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出     
                  }
                }  
                else if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                  GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Limit_ALARM,bRunning);  //穿头下模上升异常
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 8:  
                if(dwTickCount >= GL_CTHL_AutoDelay)  //延时顶斜口
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    if(GL_CTHL_PARAM_QianMaSelect == 0)
                        GL_CTHL_DXK_VAVLE = 1;          //延时顶斜口
                    
                    GL_CTHL_AutoStep = 9;
                    if(!cBanAuTo)
                    {
                    if(GL_CTHL_cZipCnt==0)
                      GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_DXK_XKDW_Off_DELAY+50;
                    else
                       GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_DXK_XKDW_Off_DELAY;
                    }
                    else
                    {
                    GL_CTHL_AutoDelay = dwTickCount + 500;
                    
                    }
                  }
                      
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
          
            case 9: 
                if((dwTickCount >= GL_CTHL_AutoDelay))  //顶斜口延时退斜口上止定位
                {
                  //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                      
                    
                    GL_CTHL_XKDW_VAVLE = 0;    //方块钩针
                    GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
                    GL_CTHL_AutoStep = 10;    
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_XK_CR_DELAY;
                    
                    if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 1 && GL_CTHL_PARAM_QianMaSelect==1)
                        GL_CTHL_CXSX_VAVLE = 0;    //插销顶出退
                  }
                }    
                break;
            case 10:                   
                if((dwTickCount >= GL_CTHL_AutoDelay) && !X_DRV && (bCL_OK_FLG))
                {
                  //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                      if(!cBanAuTo)
              {
                       
                    GL_CTHL_TD_MotorStep = 10;   //启动拖带穿入            
                    GL_CTHL_AutoStep = 11;  
                    GL_CTHL_bXCBackOK = 0;
                    GL_CTHL_AutoDelay = dwTickCount + 0;
              }
              else
              {
                 GL_CTHL_AutoStep = 801; 
                  GL_CTHL_AutoDelay = dwTickCount + 2000;
              
              }
                  }
                }

                break;
               
                
        case 801:
               if(dwTickCount >= GL_CTHL_AutoDelay)
              {
                 
                  bRunning=0;
                  cBanAuTo=0;
                   cCHULIANBAOJIN=1;
                GL_CTHL_GDXM_VAVLE=0;
                  GL_CTHL_XKTD_VAVLE = 0;
                  GL_CTHL_DXK_VAVLE=0;
                  GL_CTHL_AutoStep = 0; 
              
              }
              break;
            case 11:
               
                if((GL_CTHL_TD_MotorStep == 0) && bCL_OK_FLG)  //穿入定位完成
                {      
                   if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0)
                        GL_CTHL_CXSX_VAVLE = 1;    //插销上下
                    else
                      GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
             /*   //测试拖带定位  
                    GL_CTHL_AutoStep = 1;       
                    GL_CTHL_AutoDelay = dwTickCount + 1000;
                     if(GL_CTHL_cZipCnt<3)
                        GL_CTHL_cZipCnt++;
                    break;  */
                  
          //        if(START_IN_UP)
           //       {
                  //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                      
                     //   GL_CTHL_XKDW_VAVLE = 0;    //方块钩针
                        GL_CTHL_XKTD_VAVLE = 1;     //斜口推带气缸输出 
                        
//                        if(GL_CTHL_PARAM_CR_MODE==0)
                            GL_CTHL_CXSCDW_VAVLE = 1;   //Y21 插销上止定位电磁阀
                        
                        if((GL_CTHL_CL_MotorStep == 0) && (GL_CTHL_SF_Origin_IN || (GL_CTHL_PARAM_CR_MODE == 0)))
                        {                          
                           GL_CTHL_CXQJD_VAVLE = 1;//插销前夹带
                           //GL_CTHL_SongDai_VAVLE = 1;    //松带
                           
                             //Y轴启动插销
                            GL_CTHL_CL_MotorStep = 20;  //插销定位  
                           
                        }     
                         else if(!GL_CTHL_SF_Origin_IN)
                        {
                        GL_CTHL_CL_MotorStep = 40;  //插销定位 
                        }
                        GL_CTHL_AutoStep = 12;  
                  }
                }  
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 12: 
              
                if(!GL_CTHL_bXCBackOK && (GL_CTHL_CL_MotorStep == 0) && 
                   (GL_CTHL_SF_Origin_IN || (GL_CTHL_PARAM_CR_MODE == 0)))
                {                          
                    GL_CTHL_CXQJD_VAVLE = 1;     //插销前夹带 
                    //GL_CTHL_SongDai_VAVLE = 1;    //松带
                    GL_CTHL_CL_MotorStep = 20;  //插销定位 
                }    
               
                if(!GL_CTHL_XKTD_Origin_IN)//)  //插销前夹带回到原位
                {
                    GL_CTHL_AutoStep = 14; 
                 
                    GL_CTHL_AutoDelay = dwTickCount + 0;
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 14:
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_AutoStep = 15; 
                    GL_CTHL_FKGD_VAVLE = 1;     //方块固定    
                    if(GL_CTHL_PARAM_CR_MODE==0)
                       GL_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                    if(GL_CTHL_PARAM_GouZhen_mode==0)
                       GL_CTHL_XKDW_VAVLE = 1; //方块勾针输出
                  }
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 15:   
                if(!GL_CTHL_bXCBackOK && (GL_CTHL_CL_MotorStep == 0) && 
                   (GL_CTHL_SF_Origin_IN || (GL_CTHL_PARAM_CR_MODE == 0)))  
                {  
                    GL_CTHL_CXQJD_VAVLE = 1;   
                    //GL_CTHL_SongDai_VAVLE = 1;    //松带
                    GL_CTHL_CL_MotorStep = 20;  //插销定位 
                }  
                if((GL_CTHL_CL_MotorStep == 0) && GL_CTHL_bXCBackOK)   //插销定位完成
                {
                  //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                    GL_CTHL_AutoStep = 16; 
                  
                    GL_CTHL_AutoDelay = dwTickCount + 2;  //延时插销下移
                                        
                    GL_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                 
                    //GL_CTHL_SongDai_VAVLE = 0;    //松带
                //    GL_CTHL_FKJD_VAVLE = 0;
                  }
                } 
                break;
            case 16: 
                if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_AutoStep = 17; 
                  
                     if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0)
                        GL_CTHL_CXSX_VAVLE = 0;    //插销上下
                    else
                      GL_CTHL_CXSX_VAVLE = 1;    //插销顶出
//                    GL_CTHL_CXSX_VAVLE = 0;     //Y06 插销下移电磁阀
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
                  }
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 17:
                if(GL_CTHL_CXXY_Limit_IN)
                {
                  //调试模式
                  if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                       
                       GL_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                      GL_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    //GL_CTHL_XKDW_VAVLE = 1; //方块勾针输出
                    GL_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关
                    GL_CTHL_AutoStep = 18; 
                    //
                    if(GL_CTHL_LENTH>0 || GL_CTHL_PARAM_CR_MODE==0)
                    {
                      if(!GL_CTHL_bReStart)
                        GL_CTHL_LENCountBuff = GL_CTHL_PARAM_TDFZ_LENTH;
                       //   AxisMovePosAccDec(X_AXIS,6000,-GL_CTHL_PARAM_TDFZ_LENTH,800,600,6,8,0); 
                      else
                            GL_CTHL_LENCountBuff = GL_CTHL_PARAM_TDFZ_LENTH/3;
                        //  AxisMovePosAccDec(X_AXIS,6000,-GL_CTHL_PARAM_TDFZ_LENTH/3,800,600,6,8,0);
                    }
                    else
                    {
                      if(!GL_CTHL_bReStart)
                            GL_CTHL_LENCountBuff = GL_CTHL_PARAM_TDFZ_LENTH + 300;
                        //  AxisMovePosAccDec(X_AXIS,6000,-GL_CTHL_PARAM_TDFZ_LENTH-300,800,600,6,8,0); 
                      else
                            GL_CTHL_LENCountBuff = GL_CTHL_PARAM_TDFZ_LENTH/3+ 300;
                        //  AxisMovePosAccDec(X_AXIS,6000,-GL_CTHL_PARAM_TDFZ_LENTH/3-300,800,600,6,8,0);
                    }
                    //user_datas[123] = GL_CTHL_LENCountBuff;//
                   if(!X_DRV && !cCXCONE)  //拖带电机反转
                      {
                    AxisMovePosAccDec(X_AXIS,6000,-GL_CTHL_LENCountBuff,800,600,6,8,0);  
                    }
                    GL_CTHL_bReStart = 0;
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_CXCR_DELAY;
                    cXcxcrCnt = 0;
                      
                    
                  }
                }  
                else if(dwTickCount >= GL_CTHL_AutoDelay)  
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_CXGL_Limit_ALARM,bRunning); //插销下移异常
                    
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 18:   
  //              if(START_IN_UP)
                {
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_AutoStep = 19; 
                    
                    GL_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
            //        GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                    GL_CTHL_AutoDelay = dwTickCount + 500;  //插销穿入到位异常时间
                    
                    GL_CTHL_CL_MotorStep = 50;  //合链电机回原点
                  }
                }
                }
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 19:   
                if(GL_CTHL_CX_Limit_IN || (!GL_CTHL_CXDWZ_VAVLE && GL_CTHL_bTiaoShiMode))
                {
                  //调试模式
                    if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
                     
                        bZhuangLiaoOkFlg = 0;
                        GL_CTHL_AutoStep = 901;
                        GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_TFKGD_DELAY;//延时退方块固定
                    }
                    GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                    
                     if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 1)
                     {
                        GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
                     }
                }  
                else if((dwTickCount >= GL_CTHL_AutoDelay) && GL_CTHL_CXDWZ_VAVLE) 
                {
                    cXcxcrCnt++;
                    if(cXcxcrCnt >= 3)
                        GL_CTHL_SetAlarmCode(GL_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常 
                    else
                    {
                          GL_CTHL_CXHJD_VAVLE=0;
                          if(cXcxcrCnt== 1)
                            GL_CTHL_AutoStep = 190;
                          else 
                              GL_CTHL_AutoStep = 195;
                          GL_CTHL_AutoDelay = dwTickCount + 80;
                    }
                    
                }           
              break;
        case 901:
          if(dwTickCount >= GL_CTHL_AutoDelay)  
          {
            
            if(!GL_CTHL_PARAM_CXJD_MODE)
            {
            GL_CTHL_AutoStep = 20;
             GL_CTHL_FKGD_VAVLE = 0;
                        //GL_CTHL_CXHDW_VAVLE=0;
               GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_First_CL_DELAY/2;//延时一次穿入
            }
            else
            {
              GL_CTHL_AutoStep = 902;
            }
          }
          break;
        case 902:
          if(dwTickCount >= GL_CTHL_AutoDelay)  
          {
              if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
            GL_CTHL_CXHJD_VAVLE=0;
               GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
            GL_CTHL_AutoStep = 903;
             GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_SongJiaDai_Time;//
                    }
            
          }
          break;
        case 903:
          
         if(dwTickCount >= GL_CTHL_AutoDelay)  
          {
              if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
            GL_CTHL_CXHJD_VAVLE=1;
               GL_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸关
            GL_CTHL_AutoStep = 20;
              GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_First_CL_DELAY/2;//延时一次穿入
                    }
          }
         
           break;
   
     
              //第二次
            case 190:
                if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   GL_CTHL_AutoStep = 191;
                   GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)
                   GL_CTHL_AutoDelay = dwTickCount + 80;
                }
            break;
            
          case 191:
            if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   GL_CTHL_AutoStep = 18;
                    GL_CTHL_CXHJD_VAVLE=1;
                   GL_CTHL_AutoDelay = dwTickCount + 80;
                }
            break;
            //第三次
        case  195:
              GL_CTHL_CXQJD_VAVLE = 1;     //插销前夹带 
              //GL_CTHL_SongDai_VAVLE = 1;    //松带
             if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   GL_CTHL_AutoStep = 196;
                   GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)
                   GL_CTHL_AutoDelay = dwTickCount + 500;
                   GL_CTHL_FKGD_VAVLE = 0;
                   AxisMovePosAccDec(Y_AXIS,1200,40,1200,500,6,6,20); 
                }
            break;           
          case 196:
            if(!Y_DRV)
            {
                GL_CTHL_CXQJD_VAVLE = 0;     //插销前夹带 
                //GL_CTHL_SongDai_VAVLE = 0;    //松带
            }
            if(dwTickCount >= GL_CTHL_AutoDelay)
                {
                   GL_CTHL_FKGD_VAVLE = 1;
                    GL_CTHL_CXHJD_VAVLE=1;
                    if(!Y_DRV)
                    {
                      GL_CTHL_CXQJD_VAVLE = 0;     //插销前夹带 
                      //GL_CTHL_SongDai_VAVLE = 0;    //松带
                      GL_CTHL_AutoStep = 18;
                      GL_CTHL_AutoDelay = dwTickCount + 120;
                      
                    }
                }
            break;
            
            case 20:  

                {   
                    if(dwTickCount >= GL_CTHL_AutoDelay) 
                    {
                       if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                        GL_CTHL_AutoStep = 210;
                        GL_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
                 
                         GL_CTHL_CXHJD_VAVLE = 1;    //Y14 插销后夹带打开 
                         //GL_CTHL_CXHDW_VAVLE=1;
                        GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_HDW_DELAY;
                  }
                    }
                }
                break;
            case 210:
                if(dwTickCount>=GL_CTHL_AutoDelay)
                {
                  GL_CTHL_CXHDW_VAVLE=0;
                  GL_CTHL_AutoStep = 211;
                  GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_HDW_TIME;
                }
                break;
            case 211:
                if(dwTickCount>=GL_CTHL_AutoDelay)
                {
                  GL_CTHL_CXHDW_VAVLE=1;
              //    GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                  GL_CTHL_AutoStep = 21;
                  GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                }
                break;
            case 21:
                if(!GL_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    
                  
                   GL_CTHL_CXHDW_VAVLE=1;
                     GL_CTHL_XKDW_VAVLE = 1;
                       GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                    GL_CTHL_AutoStep = 22;
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_First_CL_Timer/2;  //一次穿入时间
                    GL_CTHL_FKGD_VAVLE = 0;
                  }
                }
                else if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
                }
                break;
            case 22:
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                       
                    GL_CTHL_AutoStep = 23; 
                    if(GL_CTHL_PARAM_TuoLian_Mode && GL_CTHL_SF_Origin_IN)
                        {
                        GL_CTHL_CXQJD_VAVLE=1;
                        }
                    GL_CTHL_LENCountBuff = GL_CTHL_LENCountBuff * 2/5;
//                    if(GL_CTHL_LENCountBuff > 150)
                    //    AxisMovePosAccDec(X_AXIS,3500,GL_CTHL_LENCountBuff,800,800,6,6,0);
                    if(!GL_CTHL_PARAM_TuoLian_Mode)
                        GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_First_CL_Timer/2;  //一次穿入时间
                  }
                }
                break;
            case 23:    
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                      
                  //调试模式
                    if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
                      if(GL_CTHL_PARAM_TuoLian_Mode && GL_CTHL_SF_Origin_IN)
                        {
                        GL_CTHL_CXQJD_VAVLE=1;
    
                        }
                       
                        if(GL_CTHL_PARAM_TuoLian_Mode && !Y_DRV)
                        {
                      //  GL_CTHL_CXQJD_VAVLE=1;
                        if(GL_CTHL_PARAM_LaZhi_length)
                           AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CXDW_SPEED,GL_CTHL_PARAM_LaZhi_length,300,300,10,10,20);
                          
                       
                        GL_CTHL_AutoStep = 24;
                        GL_CTHL_MGuo_VAVLE = 0;     //码勾退
                          GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸输出
                      if(!GL_CTHL_PARAM_TuoLian_Mode)
                        GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                        GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_MGOff_XiaMo_DELAY;       
                        }
                      else
                      {
                        GL_CTHL_AutoStep = 24;
                        GL_CTHL_MGuo_VAVLE = 0;     //码勾退
                          GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸输出
                      if(!GL_CTHL_PARAM_TuoLian_Mode)
                        GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                        GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_PARAM_MGOff_XiaMo_DELAY;     
                      
                      }
                    }
                } 

                break;
            case 24:  
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                   
                    GL_CTHL_AutoStep = 25;
                    GL_CTHL_HeMoStep = 10;   //下模的上升和下降电磁阀要配合
                    GL_CTHL_CTXMSS_VAVLE = 0; //穿头下模退
                    GL_CTHL_AutoDelay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                  if(!GL_CTHL_PARAM_TuoLian_Mode)
                        GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                    GL_CTHL_FKGD_VAVLE = 0;     //方块固定关
                    //GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开
                  }
                } 
                GL_CTHL_RunStepSave = GL_CTHL_AutoStep;
                break;
            case 25: 
                if(!GL_CTHL_CTM_Limit_IN)
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    if(GL_CTHL_PARAM_TuoLian_Mode)
                        {
                        GL_CTHL_CXQJD_VAVLE=0;
                        }  
                     if(!GL_CTHL_PARAM_TuoLian_Mode)
                        GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                    GL_CTHL_AutoStep = 26;
                     if(!GL_CTHL_PARAM_TuoLian_Mode)
                      GL_CTHL_AutoDelay = dwTickCount + 3;  //一次穿入延时返回
                     else
                      GL_CTHL_AutoDelay = dwTickCount + 15;  //一次穿入延时返回
                  }
                }
                else if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,bRunning);//穿头下模下降异常
                }
                break;
            case 26:
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                   if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_AutoStep = 27;
                    GL_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                    GL_CTHL_AutoDelay = dwTickCount + 0;
                    GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    GL_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸输出
                    //退下出错警告
                    GL_CTHL_AutoDelay1 = dwTickCount + 1000;
                    GL_CTHL_AutoStep1 = 1;
                    if(!GL_CTHL_SF_Origin_IN)
                      GL_CTHL_CL_MotorStep = 50;  //合链电机回原点
                      
                  }
                }
                break;
            case 27: 
                if(dwTickCount >= GL_CTHL_AutoDelay) 
                {
                  //调试模式
                    if((!GL_CTHL_bTiaoShiMode) || GL_CTHL_START_IN_UP)
                    {
                           if(!cCXCONE)
                    {               
                        GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                        GL_CTHL_FKGD_VAVLE = 0;     //方块固定关
                         GL_CTHL_XKDW_VAVLE = 1;
                        GL_CTHL_AutoStep = 4;
                      //  GL_CTHL_AutoDelay=dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                        bCL_EN_FLG = 1;
              //      cXcxcrCnt=0;
                        AddToTal(GL_CTHL_TOTAL_ADDR);
                        AddToTal(GL_CTHL_WORK_TOTAL_ADDR);
                        AddToTal(GL_CTHL_CUR_TOTAL_ADDR);
                        CalProSP(GL_CTHL_SPEED_ADDR);
                        if(GL_CTHL_cZipCnt<3)
                            GL_CTHL_cZipCnt++;
                    }
                    else              
                    {
                     bRunning=0;
                      cCXCONE=0;
                    GL_CTHL_AutoStep = 0;
                    }
                    }                    
                }
                
                break;               
        }
        GL_CTHL_RunStepSave = GL_CTHL_AutoStep;   
    }       
        //退下模后启动送拉头
        switch(GL_CTHL_AutoStep1)
        {   
            case 1:
              if(cStopMode==1)
              {
                cStopMode=2;
                 bStop=1;
              }
              if(GL_CTHL_First_CT_VAVLE)
              {
                    if(dwTickCount >= GL_CTHL_AutoDelay1) 
                    { 
                        GL_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关    
                        GL_CTHL_AutoDelay1 = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                    }   
              }  
              else
              {                  
                if(GL_CTHL_CTM_Origin_IN && GL_CTHL_First_CT_Origin_IN)
                {
                    GL_CTHL_ZhuangLiaoStep = 1;
                    GL_CTHL_TryCnt = 0;
                    GL_CTHL_AutoStep1 = 0;
                    GL_CTHL_MGuo_VAVLE = 0;
                    GL_CTHL_JLTou_VAVLE = 0;
                    if(!bRunning)  //在调机状态下先判断有没有料
                    {
                        GL_CTHL_MGuo_VAVLE = 1;
                        GL_CTHL_ZhuangLiaoDelay = dwTickCount + 100;
                        bZhuangLiaoOkFlg = 0;
                    }
                    
                    
                }
                else if(dwTickCount >= GL_CTHL_AutoDelay1) 
                {
                  //穿头模和一次穿入回位异常
                    if(!GL_CTHL_CTM_Origin_IN)
                      GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,bRunning);
                    else if(!GL_CTHL_First_CT_Origin_IN)
                      GL_CTHL_SetAlarmCode(GL_CTHL_First_CT_Origin_ALARM,bRunning);                    
                } 
              }   
                break;
                
        }  
         
}





void GL_CTHL_CheckStart(void)
{
  /*
      if(cWULATOUCnt) // 无拉头警告后按
      {
            if(GL_CTHL_START_IN_UP)
            {
              if(!bRunning)
              {
                    if(GL_CTHL_SafeDoor_IN)
                    {  
                        bRunning=1;
                       GL_CTHL_TryCnt=0;
                       cWULATOUCnt=0;
                      GL_CTHL_ZhuangLiaoStep = 1; 
                      GL_CTHL_AutoStep=6;
                       bTuiLaTouOkFlg = 1;
                        bZhuangLiaoOkFlg= 0;
                       GL_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                       GL_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
                       
                    }
                    else
                    {
                        GL_CTHL_SetAlarmCode(GL_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                    }
              }
            }
      }
*/
     if(dwTickCount>GL_CTHL_bSFBBAOJIN_Delay)
      {
   
       SetClr(Y_AXIS,1);
         SetClr(X_AXIS,1);
      
     }
  if(GL_CTHL_START_IN_UP || bStart)
  {
    //bStart=0;
   
    if(cCHULIANBAOJIN) //无链停机启动
      {
             bRunning=1;
      GL_CTHL_AutoStep = 11; 
      
      cCHULIANBAOJIN=0;
      SetEn(X_AXIS, MOTOR_EN);
      SetEn(Y_AXIS, MOTOR_EN);
  //      dwXRealPos=0;
       GL_CTHL_TD_MotorStep=9;  
       GL_CTHL_cZipCnt=0;
                if(GetAlarm(X_AXIS)==0 || GetAlarm(Y_AXIS)==0 )
            {

              SetClr(Y_AXIS, 0);
              SetClr(X_AXIS, 0);
              SetEn(X_AXIS, MOTOR_DISEN); 
              GL_CTHL_bSFBBAOJIN_Delay= dwTickCount + 200;
            }

        GL_CTHL_TD_MotorDelay = dwTickCount + 200;
         GL_CTHL_AutoDelay = dwTickCount + 150;
        if(GetAlarmCode(GL_CTHL_ALARM_ADDR) != 0)
           SetAlarmCode(GL_CTHL_ALARM_ADDR,0);   

      }
  }
       //启动    自动启动 单一自动	 			
    if((GL_CTHL_START_IN_UP || bStart || GL_CTHL_bOnceStart) && !cCHULIANBAOJIN && !cTDNUMBER)
    {
        //单一启动
        if(GL_CTHL_bOnceStart)
        {
          GL_CTHL_bOnceStart=0;
          bSingOneFlg=1;//一次标志
          bSingOneCnt=1;//走完一条
        }
        else
        {
          bSingOneFlg=0;
          bSingOneCnt=0;
        }
        if(!bRunning)
        {
            
            if(GL_CTHL_SafeDoor_IN)
            {  
              GL_CTHL_CXDW_Stop = 0;
               cStopMode=0;
                bRunning = 1;
                cWULATOUCnt=0;
                cBanAuTo=0;
                cCXCONE=0;
                cCHULIANBAOJIN=0;
                GL_CTHL_CL_MotorStep = 40;
                bZhuangLiaoOkFlg= 0;
                GL_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + 180;
                GL_CTHL_LianLengthCheck = 0;
                GL_CTHL_LianLengthAutoCheck = 0;
                GL_CTHL_cZipCnt = 0;
                bTuiLaTouOkFlg = 1;
                bCL_EN_FLG = 0;
                cStopInCnt = 0;
                GL_CTHL_CTXMXJ_VAVLE = 0;
                GL_CTHL_bReStart = 0;
                //装料启动一次,保证下模已在原位(下面)
                if((GL_CTHL_ZhuangLiaoStep == 0) && !GL_CTHL_CTXMSS_VAVLE && GL_CTHL_CTM_Origin_IN)
                { 
                    GL_CTHL_ZhuangLiaoStep = 1;
                    GL_CTHL_TryCnt = 0;
                }   
                //已经定位好，并且保持在原位
                if(GL_CTHL_bDinweiOK && GL_CTHL_XKSC_Limit_IN && GL_CTHL_XKDW_VAVLE 
                   && GetEn(X_AXIS) && (GL_CTHL_RunStepSave != 19))
                {
                    SetPos(X_AXIS, 0);
                    GL_CTHL_GDXM_VAVLE = 1;
                    GL_CTHL_AutoStep = 5;
                    GL_CTHL_XSavePosBuff = 0;             
                } //穿插销不到位停止
                else if(((GL_CTHL_RunStepSave == 19) || (GL_CTHL_RunStepSave == 190) || (GL_CTHL_RunStepSave == 191))  
                        && GL_CTHL_CXHJD_VAVLE && GL_CTHL_CXHDW_VAVLE
                  && GL_CTHL_CTXMSS_VAVLE && GL_CTHL_CXDWZ_VAVLE)
                {
                    if(GL_CTHL_CX_Limit_IN)
                    {
                       GL_CTHL_AutoStep = 19;
                    }
                    else
                    {
                       GL_CTHL_AutoStep = 16;
                       GL_CTHL_bReStart = 1;
                       GL_CTHL_AutoDelay = dwTickCount + 100;
                       GL_CTHL_CXHJD_VAVLE = 0;
                       GL_CTHL_CXHDW_VAVLE = 0;
                    }
                }                  
                else 
                {   
                    GL_CTHL_AutoStep = 1;
                    GL_CTHL_AutoDelay = dwTickCount + 180;
                }
                GL_CTHL_cZipCnt = 0;
                
                SetEn(X_AXIS, MOTOR_EN);
                SetEn(Y_AXIS, MOTOR_EN);
                GL_CTHL_AlarmDisEnFlg=0;
                SetAlarmCode(GL_CTHL_ALARM_ADDR,0);
                
             }
             else
             {
                GL_CTHL_SetAlarmCode(GL_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
             }            
        }  
        bStart = 0;
    }  
    if(bStop)
    {
      bStop=0;
      bSingOneFlg=1;
      bSingOneCnt=0;
    }
    
 if(cTDNUMBER==1)
  {
   if(GL_CTHL_START_IN_UP || bStart) 
   {
      bRunning=1;
      GL_CTHL_AutoStep = 11; 
    cTDNUMBER=0;
      SetEn(X_AXIS, MOTOR_EN);
      SetEn(Y_AXIS, MOTOR_EN);
  //      dwXRealPos=0;
       GL_CTHL_TD_MotorStep=10;  
       GL_CTHL_cZipCnt=0;
       
        if(GetEn(X_AXIS)== MOTOR_DISEN)
        {
         SetEn(X_AXIS, MOTOR_EN); 
        }
        GL_CTHL_TD_MotorDelay = dwTickCount + 500;
         GL_CTHL_AutoDelay = dwTickCount + 150;
        if(GetAlarmCode(GL_CTHL_ALARM_ADDR) != 0)
           SetAlarmCode(GL_CTHL_ALARM_ADDR,0);   
   }
  }
  else if(cTDNUMBER==2)
  {
   if(GL_CTHL_START_IN_UP || bStart) 
   {
     cTDNUMBER=0;
    bRunning=1;
    GL_CTHL_AutoDelay = dwTickCount + 500;
   }
  
  }
    //停止
    if(GL_CTHL_STOP_IN_UP)
    {	

      if(cStopMode < 2)
        cStopMode++;
      if(bRunning)
      {   
        if(GL_CTHL_TD_MotorStep != 0)
        {
        cTDNUMBER=1;
         AxisEgmStop(X_AXIS);
         SetEn(X_AXIS, MOTOR_DISEN);
        bRunning=0;
         
        }
        else
        {
        cTDNUMBER=2;
        bRunning=0;
        }
          /*
        GL_CTHL_CXDW_Stop = 0;
        cStopMode=0;
        cXcxcrCnt=0;
        cWULATOUCnt=0;
        if(GL_CTHL_XKSC_Limit_IN)
          AxisEgmStop(X_AXIS);
        else
            AxisDecStop(X_AXIS);
        AxisEgmStop(Y_AXIS);
                    cBanAuTo=0;
                cCXCONE=0;
                cCHULIANBAOJIN=0;
        GL_CTHL_AutoStep = 0; 
        
        GL_CTHL_CL_MotorStep =0;    
        GL_CTHL_HL_VAVLE = 0;
        GL_CTHL_HLJJ_VAVLE = 0;
        GL_CTHL_bCLFirst_Step=0;  
        if(!GL_CTHL_bDinweiOK)
            GL_CTHL_XKDW_VAVLE  =0; 

        SetAlarmCode(GL_CTHL_ALARM_ADDR,0);    
        bRunning=0;
   */
      }
      else if(!bRunning)
      {
         bRunning=0;
          cXcxcrCnt=0;
          cStopMode=0;
          cWULATOUCnt=0;
                      cBanAuTo=0;
                cCXCONE=0;
                cTDNUMBER=0;
                cCHULIANBAOJIN=0;
         AxisEgmStop(X_AXIS);
          AxisEgmStop(Y_AXIS);
         SetEn(X_AXIS, MOTOR_DISEN);
         SetEn(Y_AXIS, MOTOR_DISEN);
          cStopMode=0;
          GL_CTHL_bDinweiOK = 0;
          
        if((GL_CTHL_SF_ALR_IN  && (GL_CTHL_PARAM_HareSelect == 0))|| ((!GetAlarm(X_AXIS)   && (GL_CTHL_PARAM_HareSelect == 1))))
        {
          SetEn(Z_AXIS, MOTOR_EN);
           SetClr(X_AXIS, 0);
          GL_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
        }
          GL_CTHL_TLiao_VAVLE=0;             
          
         if(!GL_CTHL_HSLiao_VAVLE || !GL_CTHL_MGuo_VAVLE)           
            GL_CTHL_JLTou_VAVLE  =0;  
         GL_CTHL_HSLiao_VAVLE  =0;     
         GL_CTHL_XKTD_VAVLE  =0;        
         GL_CTHL_XKDW_VAVLE  =0;       
         GL_CTHL_DXK_VAVLE  =0;   
         GL_CTHL_GDXM_VAVLE = 0;
         GL_CTHL_CXSX_VAVLE  =0;         
                 
         GL_CTHL_First_CT_VAVLE =0;     
         GL_CTHL_FKGD_VAVLE =0;         
         GL_CTHL_CXQJD_VAVLE =0;    
         GL_CTHL_SongDai_VAVLE = 0;    //松带
         GL_CTHL_CXDWZ_VAVLE  =0;       
         GL_CTHL_CXHJD_VAVLE =0;        
         GL_CTHL_CXHDW_VAVLE =0;        
         GL_CTHL_FKJD_VAVLE  =0;        
         GL_CTHL_HLJJ_VAVLE  =0;   
         GL_CTHL_HL_VAVLE = 0;
         GL_CTHL_CXHT_VAVLE = 0;
         GL_CTHL_CXSCDW_VAVLE =0;
         if((GL_CTHL_CTXMSS_VAVLE) || (GL_CTHL_CTM_Origin_IN && !GL_CTHL_CTXMSS_VAVLE))
            GL_CTHL_MGuo_VAVLE =0;
         if(GL_CTHL_CTXMSS_VAVLE || !GL_CTHL_CTM_Origin_IN)    
         {
            GL_CTHL_HeMoStep = 10;
         } 
         else if(!GL_CTHL_CTXMSS_VAVLE && !GL_CTHL_CTM_Limit_IN)          
            GL_CTHL_CTXMXJ_VAVLE = 1;
         GL_CTHL_CTXMSS_VAVLE =0;       
         GL_CTHL_AutoStep = 0;
         GL_CTHL_ZhuangLiaoStep=0;
         GL_CTHL_TLiaoStep=0;
         GL_CTHL_TD_MotorStep=0;
         GL_CTHL_JiaLianStep  =0;     
    //   GL_CTHL_ZhenDongStep =0;       
         GL_CTHL_SongLiaoStep   =0;     
         GL_CTHL_CL_MotorStep =0;      
         GL_CTHL_AutoStep1  =0;
         GL_CTHL_bFKCXTDDW_Step=0;
         GL_CTHL_bCXCR_Step=0;
         GL_CTHL_bCLFirst_Step=0;
         GL_CTHL_RunStepSave = 0;
         SetAlarmCode(GL_CTHL_ALARM_ADDR,0);  
         SetPos(X_AXIS, 0); 
    //    if(cStopInCnt < 3)
   //         cStopInCnt++;
  //      if(bStop)
  //          cStopInCnt = 0;
        GL_CTHL_TLiaoStep = 0; 
        GL_CTHL_AutoStep = 0;
        GL_CTHL_CXDW_Stop = 0;
        //穿合链电机是往零点方向时可以停止
 //       if((GetDir(Y_AXIS) == DIR_N) && GL_CTHL_SF_Origin_IN)
 //           AxisEgmStop(Y_AXIS);
        
        if(((GL_CTHL_SF_ALR_IN && (GL_CTHL_PARAM_HareSelect == 0)) || ((!GetAlarm(X_AXIS)  && (GL_CTHL_PARAM_HareSelect == 1)))) 
           ||  ((GL_CTHL_Y_SF_ALR_IN && (GL_CTHL_PARAM_HareSelect == 0)) || (!GetAlarm(Y_AXIS) && (GL_CTHL_PARAM_HareSelect == 1))))
        {
          SetEn(Z_AXIS, MOTOR_EN);  //清伺服警告
          SetClr(X_AXIS, 0);
          SetClr(Y_AXIS, 0);
          GL_CTHL_bSFBBAOJIN_Delay= dwTickCount + 200;
        }
  /*      if(cStopInCnt > 1)
        {
            GL_CTHL_CL_MotorStep = 0; 
            AxisEgmStop(Y_AXIS);
            GL_CTHL_ZhuangLiaoStep = 0;
        }    
        else
        {  
            GL_CTHL_TD_MotorStep = 0;  
            SetEn(X_AXIS, MOTOR_DISEN);
            SetEn(Y_AXIS, MOTOR_DISEN);
            GL_CTHL_bFKCXTDDW_Step = 0;   
            GL_CTHL_bCXCR_Step = 0;
            GL_CTHL_bCLFirst_Step = 0;
        }*/
      }
      bStop=0;
    }
     
   if(bAlarmStop)
    {   
      bRunning   = 0;
      bAlarmStop=0;
      cStopMode=0;
      cXcxcrCnt=0;
      if(GetAlarmCode(GL_CTHL_ALARM_ADDR) == GL_CTHL_SF_ALR_ALARM)
        GL_CTHL_X_EN_FLG=0;
     if(GetAlarmCode(GL_CTHL_ALARM_ADDR) == GL_CTHL_Y_SF_ALR_ALARM) 
        GL_CTHL_Y_EN_FLG=0; 
      AxisDecStop(X_AXIS);
      AxisEgmStop(Y_AXIS);
      
      if(!GL_CTHL_AlarmDisEnFlg)
      {
        GL_CTHL_AlarmDisEnFlg=1;
        GL_CTHL_AlarmDisEn_Time = dwTickCount + 1000;
      }

      if(GL_CTHL_CXSC_Limit_IN)
      {
        AxisEgmStop(X_AXIS);
      }
      GL_CTHL_AutoStep = 0; 
      GL_CTHL_CL_MotorStep =0;      
      GL_CTHL_bCLFirst_Step=0;  
      GL_CTHL_SongLiaoStep =0;
      GL_CTHL_ZhuangLiaoStep=0;
    }
    if(GL_CTHL_AlarmDisEnFlg && (dwTickCount >= GL_CTHL_AlarmDisEn_Time) && !bRunning)
    {
        GL_CTHL_AlarmDisEnFlg=0;
        SetEn(X_AXIS, MOTOR_DISEN);
        SetEn(Y_AXIS, MOTOR_DISEN);
    }
    
}   

//拖带电机控制动作  X轴
void GL_CTHL_TD_Motor(void)	 //
{   
       if(dwTickCount >= GL_CTHL_TestDelay)
       {
            GL_CTHL_TestDelay  = dwTickCount + 300;
            //GL_CTHL_SongDai_VAVLE = !GL_CTHL_SongDai_VAVLE;
       }
#if 1
     switch(GL_CTHL_TD_MotorStep)
	{
        //1步开始，纯定位, 没有穿入
        case 1:
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwTickCount >= GL_CTHL_TD_MotorDelay)  //给锁轴时间
            {
               GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                GL_CTHL_bTest = 0;
                bCheckEN_FLG = 1;
                GL_CTHL_CheckInX02PosBuff= 0;
                 GL_CTHL_TD_MotorStep = 2;   
                 SetPos(X_AXIS, 0);  //启动位置设为0点
                 if(GL_CTHL_PARAM_QianMaSelect==1) //尼龙
                 {
                    AxisContinueMoveAcc(X_AXIS,4000,DIR_P,800,600,15,15);
                 }
                else
                {
                    if(bRunning)  //自动工作中
                        AxisContinueMoveAcc(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed,DIR_P,800,600,15,15);
                    else
                        AxisContinueMoveAcc(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed,DIR_P,800,600,15,15);
                }
            }  
            break;
        case 2://检测到过链
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwXRealPos > GL_CTHL_PARAM_TuiDXM_Lenght)//200)    //穿入2CM后退
            {
                GL_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关    
                GL_CTHL_GDXM_VAVLE = 0;
                if(GL_CTHL_PARAM_QianMaSelect == 1)//直码
                    GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸输出
            }    
            if((dwXRealPos >= GL_CTHL_PARAM_WLCDSHEZHI_LENTH) && GL_CTHL_PARAM_WLCDSHEZHI_LENTH)
            {
              GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机              
            }
            if((dwXRealPos > (GL_CTHL_LianLengthAutoCheck+2000)) && GL_CTHL_LianLengthAutoCheck && GL_CTHL_cZipCnt>1)
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning);  
                   //无拉链自动停机
             }
            if(GL_CTHL_FK_Check)
            {
                GL_CTHL_SongDai_VAVLE = 1;       //松带
//              user_datas[122] = dwXRealPos;
                GL_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
                if(GL_CTHL_PARAM_QianMaSelect == 1) //直码
                    GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸输出
                GL_CTHL_GDXM_VAVLE = 0;
                GL_CTHL_XSavePosBuff = dwXRealPos;
                GL_CTHL_TD_MotorStep = 3;  
 //               user_datas[123] = dwXRealPos - GL_CTHL_CheckInX02PosBuff;
                if((dwXRealPos >= GL_CTHL_CheckInX02PosBuff) && GL_CTHL_CheckInX02PosBuff)
                { 
                    AxisMovePosAccDec(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed,GL_CTHL_PARAM_FKDW_Length - (dwXRealPos- GL_CTHL_CheckInX02PosBuff),
                                  GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_FKDW_Speed/2,10,50,100); 
                }
                else
                    AxisMovePosAccDec(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed,GL_CTHL_PARAM_FKDW_Length,
                                  GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_FKDW_Speed/2,10,50,100); 
            }
            if(GL_CTHL_CXSC_Limit_IN_UP)
            {
                GL_CTHL_X_CXPosBuff = dwXRealPos;
                if(GL_CTHL_PARAM_CR_MODE==0)
                 GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }    
            break;
        case 3:    
            GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(GL_CTHL_CXSC_Limit_IN_UP && !GL_CTHL_bTest)
            {
                GL_CTHL_bTest = 1;
                GL_CTHL_X_CXPosBuff = dwXRealPos;
//                user_datas[123] = GL_CTHL_X_CXPosBuff;                
            }             
             if(!X_DRV || (dwXRealPos >= (GL_CTHL_XSavePosBuff + GL_CTHL_PARAM_FKDW_Length)))
            {
                AxisEgmStop(X_AXIS);
               GL_CTHL_TD_MotorStep =4 ;  
               GL_CTHL_LianLengthAutoCheckOLD = GL_CTHL_LianLengthAutoCheck;
               GL_CTHL_LianLengthAutoCheck = dwXRealPos;
            }
             break;
        case 4:
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(GL_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
            {
                if(GL_CTHL_PARAM_CR_MODE==0)
                {
                  if ((dwXRealPos - GL_CTHL_X_CXPosBuff) > (GL_CTHL_PARAM_XCX_LENTH + GL_CTHL_PARAM_XCXWC_LENTH)) 
                  {
                    //user_datas[121] = 1;
                      GL_CTHL_TD_MotorStep = 0;
                      GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            
                  }         
                  else if((dwXRealPos - GL_CTHL_X_CXPosBuff) < (GL_CTHL_PARAM_XCX_LENTH - GL_CTHL_PARAM_XCXWC_LENTH))
                 {
                      //user_datas[121] = 2;
                     GL_CTHL_TD_MotorStep = 0;
                      GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }    
                   else if(GL_CTHL_X_CXPosBuff == 0)
                   {
                      //user_datas[121] = 3;
                       GL_CTHL_TD_MotorStep = 0;
                         GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }   
                   else
                   {
                     GL_CTHL_TD_MotorStep = 0;
                    }
                }
                else
                {
                  if(GL_CTHL_X_CXPosBuff == 0)
                   {
                      //user_datas[121] = 3;
                       GL_CTHL_TD_MotorStep = 0;
                         GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }   
                   else
                   {
                     GL_CTHL_TD_MotorStep = 0;
                   }
                }
            }
            else
            {
                GL_CTHL_TD_MotorStep = 0;
            }
          break;
          
          
        case 9:
             if(dwTickCount >= GL_CTHL_TD_MotorDelay)
            {
               SetEn(X_AXIS, MOTOR_EN);
              GL_CTHL_TD_MotorStep=10;
              GL_CTHL_TD_MotorDelay=dwTickCount+500;
              
            }
            break;
            //穿拉头定位
        case 10:   
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwTickCount >= GL_CTHL_TD_MotorDelay)
            {
                GL_CTHL_TD_MotorStep = 11;
                 GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                SetPos(X_AXIS, 0);  //启动位置设为0点
                dwXRealPos = 0;
                AxisContinueMoveAcc(X_AXIS,4000,DIR_P,800,1200,18,5);   
                GL_CTHL_CheckInX02PosBuff= 0;
                bCheckEN_FLG = 1;
                GL_CTHL_X_CXPosBuff = 0;
                GL_CTHL_bTest = 0;
                GL_CTHL_X_FKCheckPos = 0;
                GL_CTHL_X_CXPosBuff2 = 0;
                //user_datas[121] = 0;
            }
            break;
        case 11:   
            GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwXRealPos > 250)    //穿入2CM后退
            {
                if((GL_CTHL_cZipCnt < 2) || (GL_CTHL_LianLengthCheck < 350)) 
                {
                      if(GL_CTHL_PARAM_QianMaSelect == 0)
                          AxisContinueMoveChangeSpeed(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed,600,10,10); 
                      else
                          AxisContinueMoveChangeSpeed(X_AXIS,6000,600,10,10); 
                }      
                else ////两段速度移动距离    
                {
                    if(GL_CTHL_PARAM_QianMaSelect == 0)
                        AxisMovePosAccDecNotStop(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed + GL_CTHL_PARAM_TD_RunSpeed/3,GL_CTHL_LianLengthCheck-250,3000,7000,25,300,250); 
                    else
                    {
                        if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT ==1)
                          AxisMovePosAccDecNotStop(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed + GL_CTHL_PARAM_TD_RunSpeed/3,GL_CTHL_LianLengthCheck-250,3000,7000,25,300,250); 
                        else 
                          AxisMovePosAccDecNotStop(X_AXIS,GL_CTHL_PARAM_TD_RunSpeed + GL_CTHL_PARAM_TD_RunSpeed/3,GL_CTHL_LianLengthCheck-250,3000,7000,25,300,250); 
                    }
                }   
                GL_CTHL_TD_MotorStep = 12;
            }
            break;
        case 12:
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
 
                if(dwXRealPos > GL_CTHL_PARAM_TuiDXM_Lenght) 
                {               
                    GL_CTHL_CheckInX02PosBuff= 0;

                    GL_CTHL_GDXM_VAVLE = 0;
                    GL_CTHL_TD_MotorStep = 13;
                    
                }
            break;
        case 13://检测到过链
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwXRealPos > GL_CTHL_PARAM_TuiDXM_Lenght)//400) 
            {               
                GL_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关       
                if(GL_CTHL_PARAM_QianMaSelect == 1) //尼龙
                    GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸输出
            }
          if((dwXRealPos >= GL_CTHL_PARAM_WLCDSHEZHI_LENTH) && GL_CTHL_PARAM_WLCDSHEZHI_LENTH)
            {
                cCHULIANBAOJIN=1;
              GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机
 //             AxisDecStop(X_AXIS);
              GL_CTHL_TD_MotorStep = 0;
              //user_datas[121] = 10;
              AxisMovePosAccDec(X_AXIS,2000,600,
                                  GL_CTHL_PARAM_FKDW_Speed,1000,10,50,20);
            }
          if((dwXRealPos > (GL_CTHL_LianLengthAutoCheck+7000)) && GL_CTHL_LianLengthAutoCheck && GL_CTHL_cZipCnt>0)
                {
                        cCHULIANBAOJIN=1;
                    GL_CTHL_SetAlarmCode(GL_CTHL_WLZDTJ_ALARM,bRunning); 
                    AxisDecStop(X_AXIS); 
                    GL_CTHL_TD_MotorStep = 0;
                    //user_datas[121] = 11;
                    AxisMovePosAccDec(X_AXIS,2000,600,
                                  GL_CTHL_PARAM_FKDW_Speed,1000,10,50,20);
                    break;
                   //无拉链自动停机
                }
            if(GL_CTHL_FK_Check)
            {
                GL_CTHL_SongDai_VAVLE = 1;    //松带
                //user_datas[122] = GetCurSpeed(X_AXIS);//dwXRealPos;
             if(((GL_CTHL_LianLengthCheck*(80/100)) > dwXRealPos) && GL_CTHL_cZipCnt>1)
              {
              GL_CTHL_cZipCnt=0;        
              }
                if(GL_CTHL_cZipCnt < 2)
                    GL_CTHL_LianLengthCheck = dwXRealPos;
   
                //break;
                GL_CTHL_X_FKCheckPos = dwXRealPos + GL_CTHL_PARAM_FKDW_Length;
                GL_CTHL_X_FKJDCheckPos=dwXRealPos;
             //   GL_CTHL_TD_MotorStep = 14;  
//                if(GetCurSpeed(X_AXIS) <= 10000)
 //               user_datas[122] = GL_CTHL_PARAM_FKDW_Length - (dwXRealPos- GL_CTHL_CheckInX02PosBuff); 
                //if(GL_CTHL_PARAM_QianMaSelect == 0)
                if(GL_CTHL_cZipCnt>1)
                {
                  GL_CTHL_X_XCCheckPos=dwXRealPos;
                  GL_CTHL_TD_MotorStep=15;
                        AxisMovePosAccDec(X_AXIS,7000,GL_CTHL_PARAM_ECDW_Length,
                                  GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_FKDW_Speed,20,250,50);
                }
                else
                {
                    AxisMovePosAccDec(X_AXIS,7000,GL_CTHL_PARAM_FKDW_Length,
                                  GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_FKDW_Speed,20,250,50);
                   GL_CTHL_TD_MotorStep=15;
                
                }
 
//                else
//                  AxisMovePosAccDec(X_AXIS,8000,GL_CTHL_PARAM_FKDW_Length-20,
//                                  GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_FKDW_Speed,10,35,30);
                 //GL_CTHL_TD_MotorStep = 0;  
            }
          //方块还没有感应之前感应到插销的话，肯定错位
             if(GL_CTHL_CXSC_Limit_IN_UP)
            {
                //user_datas[121] = 4;
                GL_CTHL_X_CXPosBuff = dwXRealPos;
                if(GL_CTHL_PARAM_CR_MODE==0)
                GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常            
            }  
            break;  
  /*          
        case 14:
           if(GL_CTHL_X_CXPosBuff2 && dwXRealPos >= GL_CTHL_X_CXPosBuff2 + GL_CTHL_PARAM_CXSCDW_Length)
            {
              GL_CTHL_CXSCDW_VAVLE=1;
            }
            if(dwXRealPos >= GL_CTHL_X_FKJDCheckPos + GL_CTHL_PARAM_TDFKJD_Length)
            {
              GL_CTHL_FKJD_VAVLE = 1;
            }
          if(GL_CTHL_CXSC_Limit_IN_DW)
          {
            GL_CTHL_X_XCCheckPos=dwXRealPos;
             GL_CTHL_TD_MotorStep = 15;
          AxisMovePosAccDec(X_AXIS,GL_CTHL_PARAM_FKDW_Speed,GL_CTHL_PARAM_ECDW_Length,
                                 1200,1200,20,50,30);
          }
          break;*/
        case 15:
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
            if(dwXRealPos >= GL_CTHL_X_FKJDCheckPos + GL_CTHL_PARAM_TDFKJD_Length)
            {
              GL_CTHL_FKJD_VAVLE = 1;
            }
            //小插感应后多久下钩针
            if(GL_CTHL_X_CXPosBuff2 && dwXRealPos >= GL_CTHL_X_CXPosBuff2 + GL_CTHL_PARAM_CXSCDW_Length)
            {
              GL_CTHL_CXSCDW_VAVLE=1;
            }
            if(GL_CTHL_X_CXPosBuff && GL_CTHL_CXSC_Limit_IN_DW)
            {
              GL_CTHL_X_CXPosBuff2=dwXRealPos;
            }
            if(GL_CTHL_CXSC_Limit_IN_UP && !GL_CTHL_bTest)
            {
                GL_CTHL_bTest = 1;
                GL_CTHL_X_CXPosBuff = dwXRealPos;
 //               user_datas[123] = GL_CTHL_X_CXPosBuff;    
                //user_datas[121] = 128;
            }  
             if(GL_CTHL_cZipCnt>1)
             {
            if((!X_DRV ) || (dwXRealPos >= (GL_CTHL_X_XCCheckPos+GL_CTHL_PARAM_ECDW_Length)))
            {
               // user_datas[123] = dwXRealPos-GL_CTHL_CheckInX02PosBuff;
                AxisEgmStop(X_AXIS);
                GL_CTHL_TD_MotorStep = 16;    
                GL_CTHL_LianLengthAutoCheckOLD = GL_CTHL_LianLengthAutoCheck;
                GL_CTHL_LianLengthAutoCheck = dwXRealPos;
            }
             }
            else
            {
            
               if((!X_DRV ) || (dwXRealPos >= (GL_CTHL_X_FKCheckPos)))
            {
               // user_datas[123] = dwXRealPos-GL_CTHL_CheckInX02PosBuff;
                AxisEgmStop(X_AXIS);
                GL_CTHL_TD_MotorStep = 16;    
                GL_CTHL_LianLengthAutoCheckOLD = GL_CTHL_LianLengthAutoCheck;
                GL_CTHL_LianLengthAutoCheck = dwXRealPos;
            }
            
            }
            break;
        case 16:
          GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
         if(dwXRealPos >= GL_CTHL_X_FKJDCheckPos + GL_CTHL_PARAM_TDFKJD_Length)
            {
              GL_CTHL_FKJD_VAVLE = 1;
            }
         
          if(GL_CTHL_PARAM_CR_MODE==0)
          {
            if(((dwXRealPos - GL_CTHL_X_CXPosBuff) > (GL_CTHL_PARAM_XCX_LENTH + GL_CTHL_PARAM_XCXWC_LENTH)) && GL_CTHL_X_CXPosBuff)
            {
                  //user_datas[121] += 5;
                  GL_CTHL_TD_MotorStep = 0;
                 GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            
            }         
            else if(((dwXRealPos - GL_CTHL_X_CXPosBuff) < (GL_CTHL_PARAM_XCX_LENTH - GL_CTHL_PARAM_XCXWC_LENTH)) && GL_CTHL_X_CXPosBuff)
            {
                  //user_datas[121] += 6;
                  GL_CTHL_TD_MotorStep = 0;
                 GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }    
            else if(GL_CTHL_X_CXPosBuff == 0)
            {
                  //user_datas[121] += 7;
                  GL_CTHL_TD_MotorStep = 0;
                 GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }   
            else
            {
             GL_CTHL_TD_MotorStep = 0;
            }
          }
          else 
          {
            if(GL_CTHL_X_CXPosBuff == 0)
            {
                  //user_datas[121] += 7;
                  GL_CTHL_TD_MotorStep = 0;
                 GL_CTHL_SetAlarmCode(GL_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }   
            else
            {
             GL_CTHL_TD_MotorStep = 0;
            }
          }
          break;        
	}  
 //   if(bRunning)
 //       GL_CTHL_TDMotorStepSave = GL_CTHL_TD_MotorStep;
#endif    
}
//穿入电机动作，Y轴
void GL_CTHL_CL_Motor(void)	 //
{   
#if 1
    //1步开始,  穿链长度开始
  //20步开始  插销定位开始
  //40步,回原点为
    switch(GL_CTHL_CL_MotorStep)
	{
         //穿入长度位置
         case 1:
            
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
              if(GL_CTHL_SF_Origin_IN)
              {
                if(GL_CTHL_PARAM_CR_MODE != 0)   //电机穿入
                { 
        /*            
                    //穿入长度要根据检测长度减动一次穿入的3CM,反转的2CM
                    if((GL_CTHL_LianLengthAutoCheck < (GL_CTHL_PARAM_CL_Length + 700)) && (GL_CTHL_LianLengthAutoCheck>700))
                    {
                        GL_CTHL_Y_CL_Length=GL_CTHL_LianLengthAutoCheck-700;
                        
 //                       if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_CL_MAX_Length)
//                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_CL_MAX_Length-40;  
                        if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_Y_MAX_LENTH)
                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_Y_MAX_LENTH-40;     
                        AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,GL_CTHL_Y_CL_Length,2000,2000,50,50,150);
                    }
                    else if(GL_CTHL_LianLengthAutoCheck>700)
                    {
                        GL_CTHL_Y_CL_Length=GL_CTHL_LianLengthAutoCheck-GL_CTHL_PARAM_CL_Length; 
//if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_CL_MAX_Length)
 //                         GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_CL_MAX_Length-40;  
                        if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_Y_MAX_LENTH)
                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_Y_MAX_LENTH-40;    
                        AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,GL_CTHL_Y_CL_Length,2000,2000,50,50,100);
                    }     
*/ 
                    // (公分节判断)
                    if((GL_CTHL_LianLengthAutoCheck < (GL_CTHL_LianLengthAutoCheckOLD)) && 
                       (GL_CTHL_LianLengthAutoCheck < GL_CTHL_PARAM_GFJ_Length))   //
                    {
                       // GL_CTHL_cZipCnt = 0;
                        GL_CTHL_Y_CL_Length=GL_CTHL_LianLengthAutoCheck-900;
                        
 //                       if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_CL_MAX_Length)
//                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_CL_MAX_Length-40;  
                        if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_Y_MAX_LENTH)
                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_Y_MAX_LENTH-40; 
                        //正常穿入
                        if(GL_CTHL_PARAM_GFJ_WorkMode == 0)
                        {  
                              if(GL_CTHL_Y_CL_Length< 200)
                            GL_CTHL_Y_CL_Length = 200;  
                             AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,GL_CTHL_Y_CL_Length,1500,2500,50,300,0);
                        }    
                        //停止
                        else if(GL_CTHL_PARAM_GFJ_WorkMode == 1)
                        {
                            GL_CTHL_CL_MotorStep = 0; 
                            GL_CTHL_HLJJ_VAVLE = 0;
                            bCL_OK_FLG = 1;
                            bSingOneFlg= 1;
                            bSingOneCnt=0;
                            break;
                        }
                        else  if(GL_CTHL_PARAM_GFJ_WorkMode == 2)
                        {
                            GL_CTHL_CL_MotorStep = 0; 
                            GL_CTHL_HLJJ_VAVLE = 0;
                            bCL_OK_FLG = 1;
                            break;
                        }
                        
                    }
                    //穿入长度要根据检测长度减动一次穿入的3CM,反转的2CM
                    else if(GL_CTHL_LianLengthCheck+GL_CTHL_PARAM_FKDW_Length>700)
                    {
                      if(GL_CTHL_cZipCnt>1)
                      {
                        if(GL_CTHL_PARAM_CL_LENTH_TYPE == 0)//穿入长度类型为剩余长度
                          GL_CTHL_Y_CL_Length=GL_CTHL_LianLengthCheck+GL_CTHL_PARAM_FKDW_Length-GL_CTHL_PARAM_CL_Length-200; 
                        else//穿入长度类型为穿链长度
                        {
                          if(GL_CTHL_PARAM_CL_Length > GL_CTHL_LianLengthCheck+GL_CTHL_PARAM_FKDW_Length)
                            GL_CTHL_Y_CL_Length = GL_CTHL_LianLengthCheck+GL_CTHL_PARAM_FKDW_Length - 400;
                          else
                            GL_CTHL_Y_CL_Length=GL_CTHL_PARAM_CL_Length-200; 
                        }
                      }
                      else
                      {
                       GL_CTHL_Y_CL_Length=GL_CTHL_X_FKJDCheckPos+GL_CTHL_PARAM_FKDW_Length-GL_CTHL_PARAM_CL_Length-200; 
                      }

                        if(GL_CTHL_Y_CL_Length >= GL_CTHL_PARAM_Y_MAX_LENTH)
                          GL_CTHL_Y_CL_Length = GL_CTHL_PARAM_Y_MAX_LENTH-40;  
                         if(GL_CTHL_Y_CL_Length< 200)
                            GL_CTHL_Y_CL_Length = 200;  
                        AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,GL_CTHL_Y_CL_Length,1500,2500,50,300,00);
                    }     
                    GL_CTHL_CL_MotorStep = 2; 
                }
                else  //气缸穿入
                {
                    GL_CTHL_CL_MotorStep = 10; 
                    GL_CTHL_HL_VAVLE = 1;                    
                    GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_CLT_Time;                    
                    if(((GL_CTHL_LianLengthAutoCheckOLD > (GL_CTHL_LianLengthAutoCheck + 1200)) &&
                       GL_CTHL_LianLengthAutoCheck) && (GL_CTHL_cZipCnt > 1))
                    {
                        GL_CTHL_CL_MotorStep = 0;
                        bCL_OK_FLG = 1;               
                        GL_CTHL_HLJJ_VAVLE = 0;
                        GL_CTHL_HL_VAVLE = 0;
                    }                      
                }     
              }
            }
            break;
        case 2:
           
            if(!Y_DRV || dwYRealPos >= GL_CTHL_Y_CL_Length)  
            {
                AxisEgmStop(Y_AXIS);
                GL_CTHL_HLJJ_VAVLE = 0;
               GL_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
               GL_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
            }
            break; 
        case 3: 
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CL_MotorStep = 50;  
                
            }
            break;
         //气缸穿入   
        case 10:    
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CL_MotorStep = 11;
                bCL_OK_FLG = 1;               
                GL_CTHL_HLJJ_VAVLE = 0;
                GL_CTHL_HL_VAVLE = 0;
                GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_HL_BACK_Time;   //合链返回时间到后才能重新前夹链
            }
            break;
        case 11:
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                
                GL_CTHL_CL_MotorStep = 0;
            }  
            break;  
          //夹带插销到穿入位置  
        case 20: //此处最好算好定位长度相减
            GL_CTHL_LENTH = GL_CTHL_PARAM_CXDW_Length;//GL_CTHL_PARAM_XCX_LENTH + GL_CTHL_PARAM_CXDW_Length - (dwXRealPos - GL_CTHL_X_CXPosBuff);   
             //user_datas[121] = GL_CTHL_LENTH;
             //user_datas[122] = GL_CTHL_X_CXPosBuff; 
            if((GL_CTHL_LENTH > 0) || GL_CTHL_PARAM_CR_MODE==0)
            {
              GL_CTHL_CL_MotorStep = 21;
            }
            else
            {
              GL_CTHL_CL_MotorStep = 30;
            }
            GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_CXJZ_HT_DELAY;        
            break;
        case 21:
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            { 
              if(GL_CTHL_SF_Origin_IN)
              {
                if(GL_CTHL_PARAM_CR_MODE!= 0)
                {  
                    GL_CTHL_Y_CL_PosBuff = dwYRealPos;
                    //AxisMovePosAccDec(Y_AXIS,8000,GL_CTHL_LENTH,800,500,6,6,20); 
                    AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CXDW_SPEED,GL_CTHL_LENTH,300,300,10,10,20);
                }
                else
                {
                    GL_CTHL_CXHT_VAVLE = 1;
                    GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_XXHT_Time;
                }  
                GL_CTHL_CL_MotorStep = 22; 
              }
            }  
            break;
        case 22: 
            if(GL_CTHL_PARAM_CR_MODE!= 0)
            { 
              
                if((dwYRealPos > GL_CTHL_Y_CL_PosBuff+GL_CTHL_LENTH-GL_CTHL_PARAM_CXDW_Length) && !GL_CTHL_CXDW_Stop)
                  
                    GL_CTHL_CXSCDW_VAVLE = 1;   //Y21 插销上止定位电磁阀
                if(!Y_DRV /*|| (dwYRealPos >= GL_CTHL_PARAM_CXDW_Length)*/) //插销定位已经结束
                {
                    AxisEgmStop(Y_AXIS);
                    GL_CTHL_YsaveCXDWPosBuff = 0;
                    if(GL_CTHL_CXDW_Stop)
                    {  
                        GL_CTHL_CL_MotorStep = 23;
                        GL_CTHL_CL_MotorDelay = dwTickCount + 30;
                    }
                    else
                    {  
                        GL_CTHL_CL_MotorStep = 0;    
                        GL_CTHL_bXCBackOK = 1;
                        GL_CTHL_CXQJD_VAVLE = 0;//YYQ
                        //GL_CTHL_SongDai_VAVLE = 0;    //松带
                    }
                    
                    
                } 
            }
            else if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CL_MotorStep = 23;
                GL_CTHL_CL_MotorDelay = dwTickCount + 10;
                GL_CTHL_CXQJD_VAVLE = 0;
                //GL_CTHL_SongDai_VAVLE = 0;    //松带
                GL_CTHL_bXCBackOK = 1;
            }  
            break;
        case 23:   

            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CXHT_VAVLE = 0;
                GL_CTHL_CL_MotorStep = 0;
                if(GL_CTHL_CXDW_Stop&& !bRunning)
                    SetEn(Y_AXIS, MOTOR_DISEN);
                GL_CTHL_CXDW_Stop = 0;
            }
            break;
        case 30:
                    GL_CTHL_YsaveCXDWPosBuff = 0;
                    GL_CTHL_CL_MotorStep = 0;    
                    GL_CTHL_bXCBackOK = 1;
                    GL_CTHL_CXQJD_VAVLE = 0;//YYQ
                    //GL_CTHL_SongDai_VAVLE = 0;    //松带
            break;
            
          //回原点开始
        case 40: 
            if(GL_CTHL_PARAM_CR_MODE == 0)
            {
                GL_CTHL_CL_MotorStep = 0; 
                GL_CTHL_CXQJD_VAVLE = 0;
                //GL_CTHL_SongDai_VAVLE = 0;    //松带
                GL_CTHL_CXHT_VAVLE = 0;
                GL_CTHL_HL_VAVLE = 0;
                break;
            }
            else
            {  
          //要先离开    
            if(GL_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
            {
                GL_CTHL_CL_MotorStep = 41; 
                SetDir(Y_AXIS, DIR_P);
            }    
            else  
            {
                SetDir(Y_AXIS, DIR_N);
                GL_CTHL_CL_MotorStep = 46;
                
            }    
            if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                GL_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            }
            else  //已经锁轴
                GL_CTHL_CL_MotorDelay = dwTickCount + 5;  
            }
            break;
        case 41:
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CL_MotorStep = 42; 
                AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
            }
            break;
        case 42:
            if(!GL_CTHL_SF_Origin_IN)
            {
                GL_CTHL_CL_MotorStep = 43; 
                GL_CTHL_YSavePosBuff = dwYRealPos;
            }
            break;
        case 43:    
            //离开原点5CM停止
            if((dwYRealPos - GL_CTHL_YSavePosBuff) >= 800)
            {
                AxisEgmStop(Y_AXIS);
                GL_CTHL_CL_MotorStep = 46; //留空几步备用
                GL_CTHL_CL_MotorDelay = dwTickCount + 50;  
            }
            break;
        case 46:  
            if(dwTickCount >= GL_CTHL_CL_MotorDelay)
            {
                GL_CTHL_CL_MotorStep = 47; //检测回到原位
                if(!GL_CTHL_SF_Origin_IN)
                    AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,800,15,10);
            }
            break;
        case 47: 
           if(GL_CTHL_SF_Origin_IN)
           {
                GL_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
           }    
           break;
         //数控回原位 (条件为自动工作，SON一直没有松开)  
        case 50: 
            if(GL_CTHL_PARAM_CR_MODE == 0)
            {
                GL_CTHL_CL_MotorStep = 0; 
                GL_CTHL_HLJJ_VAVLE = 0;
                GL_CTHL_HL_VAVLE = 0;
                break;
            }
            else
            {  
                if(!GL_CTHL_SF_Origin_IN)
                { 
                  if(!Y_DRV)
                  {
                  if(dwYRealPos > 150)
                  {  //回零速度
                     SetDir(Y_AXIS, DIR_N);
                      AxisMovePosAccDecNotStop(Y_AXIS,GL_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos+151 ,3000,2500,50,150,00);          
                  } 
                  else
                      AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,1000,15,15);
                  }
                }
                GL_CTHL_CL_MotorStep = 51; 
            }
            break;
        case 51: 
            if(GL_CTHL_SF_Origin_IN)
            {
                GL_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
            }
            break;                 
	}
#endif    
}

void GL_CTHL_HeMo(void)
{
    switch(GL_CTHL_HeMoStep)
    {
        case 1:
            GL_CTHL_HeMoStep = 2;
            GL_CTHL_CTXMXJ_VAVLE = 1;
//GL_CTHL_JLTou_VAVLE = 0;    //接拉头关
            GL_CTHL_HeMo_Time = dwTickCount + 10;
            //GL_CTHL_TimeBuff=dwTickCount;
            break;
        case 2:    
           if(dwTickCount >= GL_CTHL_HeMo_Time)
           {
              GL_CTHL_HeMoStep = 3;
              GL_CTHL_CTXMSS_VAVLE = 1;
              GL_CTHL_HeMo_Time = dwTickCount + 25; 
           }
           break;
        case 3:    
          if(dwTickCount >= GL_CTHL_HeMo_Time)
          {
            GL_CTHL_HeMoStep = 4;
            GL_CTHL_CTXMXJ_VAVLE = 0;
            GL_CTHL_HeMo_Time = dwTickCount + 1800; 
          }  
          break;
    case 4: 
        if(!GL_CTHL_CTM_Origin_IN)
          GL_CTHL_JLTou_VAVLE = 0;    //接拉头
        if(GL_CTHL_CTM_Limit_IN)
        {
            GL_CTHL_JLTou_VAVLE = 0;    //接拉头
            GL_CTHL_HeMoStep = 0;
            //user_datas[127]=dwTickCount-GL_CTHL_TimeBuff;
        }
        else if((dwTickCount >= GL_CTHL_HeMo_Time)&& bRunning)   
        {
            GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Limit_ALARM,bRunning);  //穿头下模上升异常
        }
        break;   
    case 10:
        GL_CTHL_HeMoStep = 11;
        GL_CTHL_CTXMXJ_VAVLE = 1;
        GL_CTHL_CTXMSS_VAVLE = 0;
        GL_CTHL_HeMo_Time = dwTickCount + 200;
        //GL_CTHL_TimeBuff=dwTickCount;
        break;
    case 11:
        if(dwTickCount >= GL_CTHL_HeMo_Time)
        {
            //GL_CTHL_HeMoStep = 0;
            GL_CTHL_CTXMXJ_VAVLE = 0;
            
        }
        if(GL_CTHL_CTM_Origin_IN)
        {
          GL_CTHL_HeMoStep = 0;
          GL_CTHL_CTXMXJ_VAVLE = 0;
          //user_datas[127]=dwTickCount-GL_CTHL_TimeBuff;
        }
          
        break;
    }
}


//装拉头动作
void GL_CTHL_ZLT_Step(void)
{
    switch(GL_CTHL_ZhuangLiaoStep)
    {
        case 1:
          
             if(bZhuangLiaoOkFlg)
             {
                  GL_CTHL_ZhuangLiaoStep = 0;
             }
             else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
             {
                
                   if(((GL_CTHL_MGuo_VAVLE && GL_CTHL_LTou_Check) || (!GL_CTHL_MGuo_VAVLE)) && !GL_CTHL_JLiao_Limit_IN  )//说明没有拉头
                   {       
                          //穿头模和一次穿入必须在原位,接料不能有输出
                          if(GL_CTHL_CTM_Origin_IN && !GL_CTHL_CTXMSS_VAVLE)
                          {  
                              GL_CTHL_First_CT_VAVLE = 0;
                               GL_CTHL_JLTou_VAVLE = 0;
                              GL_CTHL_MGuo_VAVLE = 0;                     
                              if(GL_CTHL_TLiaoStep == 0)
                              {
                                 GL_CTHL_TLiaoStep = 1;        
                               GL_CTHL_ZhuangLiaoStep = 2; 
                              }
                           }                      
                        else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay + 1000)  //警告横送拉必须保证穿头模和一次穿入在原位,接料不能有输出
                        {
                          GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,bRunning);
                            
                        }  
                   }
                   else  //已经有拉头直接跳到结束
                   {
                         GL_CTHL_ZhuangLiaoDelay = dwTickCount + 40;
                         GL_CTHL_ZhuangLiaoStep = 9;
                   }  
             }
             break;            
        case 2:        
            if(GL_CTHL_TLiaoStep == 0)  //推料已经完成
            {
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                GL_CTHL_JLTou_VAVLE = 0;
                GL_CTHL_MGuo_VAVLE = 0;   
                if(!GL_CTHL_JLiao_Limit_IN && GL_CTHL_First_CT_Origin_IN)
                {
                    GL_CTHL_ZhuangLiaoStep = 3;
                    GL_CTHL_HSLiao_VAVLE = 1;   
                }
            }
            break;
        case 3:
            //横送到位
            if(GL_CTHL_HSLiao_Limit_IN && !GL_CTHL_HSLiao_Origin_IN)
            {
                GL_CTHL_ZhuangLiaoStep = 4;
//                GL_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + 2;
            }
            else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_HSLiao_Limit_ALARM,bRunning);
            }
            break;
        case 4:
            if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
            {
                GL_CTHL_ZhuangLiaoStep = 5;
                GL_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
                GL_CTHL_CTXMSS_VAVLE = 0;   //Y20 穿头下模上升电磁阀
                GL_CTHL_CTXMXJ_VAVLE = 0;   //Y21 穿头下模下降电磁阀
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
            }  
            break;
        case 5:    
            if(GL_CTHL_JLiao_Limit_IN)
            {
                GL_CTHL_ZhuangLiaoStep = 6;
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + GL_CTHL_PARAM_MaGou_DELAY;
            }
            else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)  //接拉头(接料)到们信号异常
            {
                 GL_CTHL_SetAlarmCode(GL_CTHL_JLiao_Limit_ALARM,bRunning);
            }
            break;
        case 6:       
            if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)  //延时码勾
            {
                GL_CTHL_MGuo_VAVLE = 1; //码勾输出
                GL_CTHL_ZhuangLiaoStep = 7;
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + GL_CTHL_PARAM_HSLiaoOff_DELAY;
                bTuiLaTouOkFlg = 0;   //认为拉头没法带出
            }
            break;
        case 7:  
            if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
            {
                GL_CTHL_HSLiao_VAVLE = 0; 
                GL_CTHL_ZhuangLiaoStep = 8;
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
            }
            break;
        case 8:  
            if(!GL_CTHL_HSLiao_Limit_IN)  //
            {
                GL_CTHL_ZhuangLiaoStep = 9;
                GL_CTHL_TLiaoStep = 1; //推拉头
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + GL_CTHL_PARAM_CheckLT_DELAY;   //也是给下模能上升的时间
            }          
            else if (GL_CTHL_LTou_Check)  //时间内信号这说明没有拉头
            {
                //重送3次
               GL_CTHL_TryCnt++;
               GL_CTHL_JLTou_VAVLE = 0;    //接拉头关
                GL_CTHL_MGuo_VAVLE = 0;     //码勾打开
                if(GL_CTHL_TryCnt >= 3)
                {
                    GL_CTHL_TryCnt = 0;
                    bZhuangLiaoOkFlg = 0;
                    GL_CTHL_ZhuangLiaoStep = 0;
                    GL_CTHL_SetAlarmCode(GL_CTHL_ZLT_ALARM,bRunning);
                    cWULATOUCnt=1;
                }
                else
                {
                    GL_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                    GL_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                }  
            }
            else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_HSLiao_Limit_ALARM,bRunning);
                if(bRunning)
                {
                    GL_CTHL_ZhuangLiaoStep = 0 ;
                }  
            }  
            break;
        case 9:   
            if(GL_CTHL_LTou_Check)  //时间内信号这说明没有拉头
            {
                GL_CTHL_TryCnt++;
                GL_CTHL_JLTou_VAVLE = 0;    //接拉头关
                GL_CTHL_MGuo_VAVLE = 0;     //码勾打开
                if(GL_CTHL_TryCnt >= 3)
                {
                  GL_CTHL_TryCnt=0;
                    bZhuangLiaoOkFlg = 0;
                    GL_CTHL_ZhuangLiaoStep = 0;
                    GL_CTHL_SetAlarmCode(GL_CTHL_ZLT_ALARM,bRunning);
                    cWULATOUCnt=1;
                }
                else
                {
                    GL_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                    GL_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                }  
            }
            else if((dwTickCount >= GL_CTHL_ZhuangLiaoDelay) || GL_CTHL_HSLiao_Origin_IN)
            {
                bZhuangLiaoOkFlg = 1;
                GL_CTHL_ZhuangLiaoStep = 0;
                GL_CTHL_ZhuangLiaoDelay=dwTickCount+10;
            }
            break;
          //装拉头不成攻重新送拉头
        case 20: 
            if(GL_CTHL_HSLiao_Origin_IN)
            {
                GL_CTHL_JLTou_VAVLE = 0;    //接拉头关
                GL_CTHL_MGuo_VAVLE = 0;     //码勾打开
                GL_CTHL_ZhuangLiaoStep = 1;
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + 10;
            }
            else if(dwTickCount >= GL_CTHL_ZhuangLiaoDelay)
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_HSLiao_Origin_ALARM,bRunning);
            }  
            break;
    }  
}

void GL_CTHL_TLiao_Step(void)
{
    switch(GL_CTHL_TLiaoStep)
    {
        case 1:
            if(bTuiLaTouOkFlg)
            {
                GL_CTHL_TLiaoStep = 0; 
            }
            else
            {
                GL_CTHL_TLiao_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                GL_CTHL_TLiaoStep = 2;
            }
            break;
        case 2:    //横送料在原位
            if(GL_CTHL_HSLiao_Origin_IN && !GL_CTHL_HSLiao_Limit_IN && !GL_CTHL_HSLiao_VAVLE)
            {
                GL_CTHL_TLiao_VAVLE = 1;    //推料(推拉头)输出
                GL_CTHL_TLiao_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                GL_CTHL_TLiaoStep = 3;
            }
            else if(dwTickCount >= GL_CTHL_TLiao_Delay) 
                GL_CTHL_SetAlarmCode(GL_CTHL_HSLiao_Origin_ALARM,1);          
            break;
        case 3:  //推拉头到位
            if(!GL_CTHL_TLiao_Origin_IN)
            { 
                GL_CTHL_TLiao_Delay = dwTickCount + GL_CTHL_PARAM_TLiao_BACKDELAY;
                GL_CTHL_TLiaoStep = 4;
            }
            else if(dwTickCount >= GL_CTHL_TLiao_Delay) 
                GL_CTHL_SetAlarmCode(GL_CTHL_TLiao_Limit_ALARM,1);        
            break;
        case 4:
            if(dwTickCount >= GL_CTHL_TLiao_Delay)
            {
                GL_CTHL_TLiao_VAVLE       = 0;
                GL_CTHL_TLiao_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME; 
                GL_CTHL_TLiaoStep = 5;
            }
            break;
        case  5:
            if(GL_CTHL_TLiao_Origin_IN)
            {
                GL_CTHL_TLiaoStep = 0;
                GL_CTHL_TLiao_Delay = dwTickCount;
                bTuiLaTouOkFlg    = 1;
            }
            else if(dwTickCount >= GL_CTHL_TLiao_Delay) 
                GL_CTHL_SetAlarmCode(GL_CTHL_TLiao_Limit_ALARM,0);    
            break;
    } 
   
}
//振动盘控制
void GL_CTHL_ZhenDongAction(void)
{
 

#if 1  

//    if(bRunning)
//    {
    if(GL_CTHL_bZDP)      
    {
        if(GL_CTHL_ZhenDongPian_OUT == 1)
        {
            if(GL_CTHL_ZDP_IN)
            {
                if(dwTickCount >= GL_CTHL_ZDP_Delay)
                {
                    GL_CTHL_ZhenDongPian_OUT = 0;
                    GL_CTHL_ZDP_Delay = dwTickCount + GL_CTHL_PARAM_ZDP_Stop_TIME;//GL_CTHL_PARAM_ZDP_Stop_TIME + 50;
                }
            }
            else
            {
                GL_CTHL_ZDP_Delay = dwTickCount + GL_CTHL_PARAM_ZDP_Start_TIME;//GL_CTHL_PARAM_ZDP_Start_TIME;
            }   
        }
        else
        {  
            if(!GL_CTHL_ZDP_IN)
            {  
                if(dwTickCount >= GL_CTHL_ZDP_Delay)
                {
                    GL_CTHL_ZhenDongPian_OUT = 1;  
                    GL_CTHL_ZDP_Delay = dwTickCount + GL_CTHL_PARAM_ZDP_Start_TIME;//GL_CTHL_PARAM_ZDP_Start_TIME
                }
            }
            else
              GL_CTHL_ZDP_Delay = dwTickCount + GL_CTHL_PARAM_ZDP_Stop_TIME;//GL_CTHL_PARAM_ZDP_Stop_TIME+ 50;
        }
    }
    else
    {
        GL_CTHL_ZhenDongPian_OUT = 1;
    }
    GL_CTHL_CuiQi_VAVLE = ~GL_CTHL_ZhenDongPian_OUT;
#endif    
}
void GL_CTHL_bFKCXTDDWStep(void)
{
    switch(GL_CTHL_bFKCXTDDW_Step)
    {
        case 1:                
                GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                GL_CTHL_FKGD_VAVLE = 0;     //方块固定关
                GL_CTHL_bFKCXTDDW_Step = 2;                
                break;
            case 2: 
                if(!GL_CTHL_XKTD_Origin_IN)  //斜口推带原位离开
                {
                    GL_CTHL_bFKCXTDDW_Step = 3;
                    GL_CTHL_bFKCXTDDW_Delay = dwTickCount + 20;
                }  
                break;
            case 3://斜口定位
                if(dwTickCount >= GL_CTHL_bFKCXTDDW_Delay)
                {
                    GL_CTHL_XKDW_VAVLE = 1;
                    GL_CTHL_bFKCXTDDW_Step = 4;
                    GL_CTHL_bFKCXTDDW_Delay = dwTickCount + GL_CTHL_PARAM_XKDW_TD_DELAY;
                }  
                break;
            case 4:
                if(dwTickCount >= GL_CTHL_bFKCXTDDW_Delay)
                {
                    AxisContinueMoveAcc(X_AXIS,1200,DIR_P,800,600,10,10);//拖带电机                       
                    GL_CTHL_bFKCXTDDW_Step = 5;
                    GL_CTHL_XSavePosBuff = dwXRealPos;
                    SetPos(X_AXIS, 0);  //启动位置设为0点
                    dwXRealPos = 0;
                }
                break;
            case 5:
                if(GL_CTHL_XKSC_Limit_IN)   //方块到位
                {
                    AxisEgmStop(X_AXIS);
                    GL_CTHL_bFKCXTDDW_Step = 0;
                    GL_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭 
                    GL_CTHL_bFKCXTDDW_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                   
                }
                else if(dwXRealPos >= (GL_CTHL_XSavePosBuff + 800))
                {
                     GL_CTHL_SetAlarmCode(GL_CTHL_FKCXDW_ALARM,bRunning);//方块插销定位异常警告
                    
                }  
                break;
    
    }  
}

//插销穿入动作
void GL_CTHL_bCXCRStep(void)
{

    switch(GL_CTHL_bCXCR_Step)
    {
            case 11:
                if(!GL_CTHL_CXDW_Stop)
                    GL_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                GL_CTHL_FKGD_VAVLE = 0;     //方块固定关
                GL_CTHL_bCXCR_Step = 12;               
                break;
            case 12: 
                if(!GL_CTHL_XKTD_Origin_IN || GL_CTHL_CXDW_Stop)  //斜口推带原位离开
                {
                    GL_CTHL_bCXCR_Step = 13;
                    GL_CTHL_bCXCR_Delay = dwTickCount + 65;
                }  
                break;
            case 13: 
                if(GL_CTHL_PARAM_CR_MODE == 1)
                {  
                    if((GL_CTHL_CL_MotorStep == 0) && (GL_CTHL_SF_Origin_IN) && (dwTickCount >= GL_CTHL_bCXCR_Delay))  //插销前夹带回到原位
                    {
                        GL_CTHL_bCXCR_Step = 14; 
                        if(!GL_CTHL_CXDW_Stop)
                            GL_CTHL_FKGD_VAVLE = 1;     //方块固定关
                        GL_CTHL_CXQJD_VAVLE = 1;    //插销前夹带   
                        //GL_CTHL_SongDai_VAVLE = 1;    //松带
                        GL_CTHL_bCXCR_Delay = dwTickCount + 0;
                    }
                }//气缸穿入
                else
                {
                    GL_CTHL_bCXCR_Step = 14; 
                    if(!GL_CTHL_CXDW_Stop)
                        GL_CTHL_FKGD_VAVLE = 1;     //方块固定关
                    GL_CTHL_CXQJD_VAVLE = 1;    //插销前夹带    
                    //GL_CTHL_SongDai_VAVLE = 1;    //松带
                    GL_CTHL_bCXCR_Delay = dwTickCount + 0;
                }   
                break;
            case 14:
                if(dwTickCount >= GL_CTHL_bCXCR_Delay)
                {
                    GL_CTHL_bCXCR_Step = 15; 
                    if(!GL_CTHL_CXDW_Stop)
                        GL_CTHL_FKGD_VAVLE = 1;     //方块固定
                    //Y轴启动插销
                    GL_CTHL_CL_MotorStep = 20;  //插销定位                   
                }
                break;
            case 15:   
                if(GL_CTHL_CL_MotorStep == 0)   //插销定位完成
                {
                    if(!GL_CTHL_CXDW_Stop)
                    {
                        GL_CTHL_bCXCR_Step = 16; 
                        GL_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                        GL_CTHL_bCXCR_Delay = dwTickCount + 10;  //延时插销下移
                    }
                    else
                    {                     
                        GL_CTHL_bCXCR_Step = 0;                     
                    }  
                    GL_CTHL_CXDW_Stop = 0;
                }  
                break;
            case 16: 
                if(dwTickCount >= GL_CTHL_bCXCR_Delay)
                {
                    GL_CTHL_bCXCR_Step = 17; 
                     if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0)
                        GL_CTHL_CXSX_VAVLE = 0;    //插销上下
                    else
                      GL_CTHL_CXSX_VAVLE = 1;    //插销顶出
                    GL_CTHL_bCXCR_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
                }
                break;
            case 17:   
                if(GL_CTHL_CXXY_Limit_IN)
                {
               //   if(GL_CTHL_START_IN_UP)
                  {
                    GL_CTHL_bCXCR_Step = 18; 
                 if( cXcxcrCnt==0 && !X_DRV)  //拖带电机反转
                {
             //    SetDir(X_AXIS, DIR_N);
                 AxisMovePosAccDec(X_AXIS,10000,-GL_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);
                }
                    GL_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                    //GL_CTHL_SongDai_VAVLE = 0;    //松带
                    GL_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
                    GL_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    GL_CTHL_bCXCR_Delay = dwTickCount + GL_CTHL_PARAM_CXCR_DELAY;

                  }
                }  
                else if(dwTickCount >= GL_CTHL_bCXCR_Delay)  
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_CXGL_Limit_ALARM,bRunning);//插销下移异常
                    
                }
                break;
            case 18:   
  //              if(START_IN_UP)
                {
                if(dwTickCount >= GL_CTHL_bCXCR_Delay) 
                {
                    GL_CTHL_bCXCR_Step = 19; 
                    
                    GL_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
                    GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
                    GL_CTHL_bCXCR_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME +1000;  //插销穿入到位异常时间
                    if(GL_CTHL_PARAM_CR_MODE == 1)
                        GL_CTHL_CL_MotorStep = 50;  //合链电机回原点
                }
                }
                break;
            case 19:  
//                 if( cXcxcrCnt > 1)  
                {
//                    GL_CTHL_SetAlarmCode(GL_CTHL_CX_Limit_ALARM,bRunning); //插销穿入到位异常  
                }
                
                if( GL_CTHL_CX_Limit_IN  )
                {
                    cXcxcrCnt=0;
                    bZhuangLiaoOkFlg = 0;
                    GL_CTHL_bCXCR_Step = 0;
 //                   GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
              
                } 
                else if (dwTickCount >= GL_CTHL_bCXCR_Delay)
                {
                   GL_CTHL_SetAlarmCode(GL_CTHL_CX_Limit_ALARM,bRunning); //插销穿入到
                                     GL_CTHL_bCXCR_Step = 0;
 /*                  
                  cXcxcrCnt++;
              
                   GL_CTHL_CXHJD_VAVLE=0;
                   GL_CTHL_CXHDW_VAVLE=0;
                   GL_CTHL_CXDWZ_VAVLE = 0;
                   GL_CTHL_CXSX_VAVLE=1;
                  GL_CTHL_bCXCR_Step = 11;
*/
                }
               
              break;
  }
}

void GL_CTHL_bCLFirstStep(void)
{
    switch(GL_CTHL_bCLFirst_Step)
    {
           case 19:   
                GL_CTHL_JLTou_VAVLE = 0;        //接拉头
                bZhuangLiaoOkFlg = 0;
                GL_CTHL_bCLFirst_Step = 20;
                GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                GL_CTHL_bCLFirst_Delay = dwTickCount + GL_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
                break;
            case 20:  
                if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                    GL_CTHL_bCLFirst_Step = 21;
                    GL_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
                    GL_CTHL_bCLFirst_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                }
                break;
            case 21:   
                if(!GL_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
                {
                    GL_CTHL_bCLFirst_Step = 22;
                    GL_CTHL_bCLFirst_Delay = dwTickCount + GL_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
                }
                else if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                   GL_CTHL_SetAlarmCode(GL_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
                }
                break;
            case 22:
                if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                    GL_CTHL_bCLFirst_Step = 23;                                     
                    GL_CTHL_MGuo_VAVLE = 0;     //码勾退
                    GL_CTHL_bCLFirst_Delay = dwTickCount + GL_CTHL_PARAM_MGOff_XiaMo_DELAY;
                    GL_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    GL_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                     if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0)
                        GL_CTHL_CXSX_VAVLE = 1;    //插销上下
                    else
                      GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
                } 
                break;
            case 23:  
                if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                    GL_CTHL_bCLFirst_Step = 24;
                    GL_CTHL_CTXMSS_VAVLE = 0; //穿头下模下降
                    GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    GL_CTHL_bCLFirst_Delay = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                } 
                break;
            case 24: 
                if(!GL_CTHL_CTM_Limit_IN)
                {
                     GL_CTHL_bCLFirst_Step= 25;
                    GL_CTHL_bCLFirst_Delay = dwTickCount + 25;  //一次穿入延时返回
                }
                else if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                    GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,bRunning); //穿头下模下降异常
                }
                break;
            case 25:
                if(dwTickCount >= GL_CTHL_bCLFirst_Delay) 
                {
                  
                     GL_CTHL_bCLFirst_Step= 0;
                    GL_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                    GL_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    
                    
                    //退下出错警告
                    GL_CTHL_AutoDelay1 = dwTickCount + GL_CTHL_VAVLE_ERROR_TIME;
                    GL_CTHL_AutoStep1 = 1;
                    bTuiLaTouOkFlg = 1;
                }
                break;
    }
}
//手动动作
void GL_CTHL_ManualAction(void)
{ 
      if(cBanAuTo)
  {
  GL_CTHL_PARAM_XCRU=1;
  }
  else
  {
  GL_CTHL_PARAM_XCRU=0;
  }
  //监控
  if(cCXCONE)
  {
  GL_CTHL_PARAM_CXCR=1;
  }
  else
  {
  GL_CTHL_PARAM_CXCR=0;
  }
      if(bRunning) // 运行灯输出
      {
      GL_CTHL_Run_State=1;
      GL_CTHL_Stop_State=0;
      }
      else 
      {
        GL_CTHL_Stop_State=1;
      GL_CTHL_Run_State=0;
      }
     if(GetEn(X_AXIS)==MOTOR_EN) 
     {
        GL_CTHL_X_EN_FLG=1;
        GL_CTHL_bXAxisEnSta=1;
     }
     else
     {
       GL_CTHL_bXAxisEnSta=0;
     }
     if(GetEn(Y_AXIS)==MOTOR_EN) 
        GL_CTHL_Y_EN_FLG=1; 
     
      if(dwTickCount>GL_CTHL_bSFBBAOJIN_Delay)
      {
        
        if((((!GL_CTHL_SF_ALR_IN) && (GL_CTHL_PARAM_HareSelect == 0))|| (GetAlarm(X_AXIS) && (GL_CTHL_PARAM_HareSelect == 1))) 
           && GL_CTHL_X_EN_FLG && (dwTickCount>GL_CTHL_XAlarm_Time)) // 伺服报警
        {
            GL_CTHL_SetAlarmCode(GL_CTHL_SF_ALR_ALARM,0);
        }
        else
        {
          GL_CTHL_XAlarm_Time=dwTickCount+1000;
        }
        if((((!GL_CTHL_Y_SF_ALR_IN) && (GL_CTHL_PARAM_HareSelect == 0)) || (GetAlarm(Y_AXIS) && (GL_CTHL_PARAM_HareSelect == 1))) 
           && GL_CTHL_Y_EN_FLG && GL_CTHL_PARAM_CR_MODE && (dwTickCount>GL_CTHL_YAlarm_Time)) // 伺服报警
        {
            GL_CTHL_SetAlarmCode(GL_CTHL_Y_SF_ALR_ALARM,0);
        } 
        else
        {
          GL_CTHL_YAlarm_Time=dwTickCount+1000;
        }
        //清伺服警报关
       SetEn(Z_AXIS, MOTOR_DISEN);
        SetClr(X_AXIS, 1);
        SetClr(Y_AXIS, 1);

     }
     else
     {
       GL_CTHL_XAlarm_Time=dwTickCount+1000;
       GL_CTHL_YAlarm_Time=dwTickCount+1000;
     }
     if((dwYRealPos >  (GL_CTHL_PARAM_Y_MAX_LENTH+20)) && Y_DRV && (GetDir(Y_AXIS)==DIR_P))
     {
       AxisEgmStop(Y_AXIS);
       if(GL_CTHL_PARAM_CR_MODE != 0)
       {
          GL_CTHL_SetAlarmCode(GL_CTHL_YAxis_Limit_ALARM,0);
       }
     }
     
 
    if(bRunning == 0)  
    {   
        if(bClearTotal) //切断计数清零
        {
            bClearTotal       = 0;
            ClrcToTal(QDCT_TOTAL_ADDR);
        }
        if(GL_CTHL_bTLiao )                 //手动推料(推拉头)
        {
            GL_CTHL_bTLiao = 0;           
            if(GL_CTHL_TLiao_VAVLE)
               GL_CTHL_TLiao_VAVLE = 0;//GL_CTHL_TLiao_VAVLE; 
            else if(!GL_CTHL_HSLiao_VAVLE && GL_CTHL_HSLiao_Origin_IN)
            {
                GL_CTHL_TLiao_VAVLE = 1;
            } 
            else//条件警告
            {
              GL_CTHL_SetAlarmCode(GL_CTHL_HENSONGLIAO_ALARM,0); // 横送料不能输出
            }

        } 
        if(GL_CTHL_bHSL)     //手动横送料   
        {
            GL_CTHL_bHSL= 0;
            if(!GL_CTHL_First_CT_VAVLE)
            {
                if(GL_CTHL_HSLiao_VAVLE)
                {
                    GL_CTHL_HSLiao_VAVLE = 0;//~GL_CTHL_HSLiao_VAVLE;
                }
                else if(!GL_CTHL_TLiao_VAVLE && GL_CTHL_TLiao_Origin_IN && GL_CTHL_CTM_Origin_IN && !GL_CTHL_JLiao_Limit_IN &&
                        !GL_CTHL_JLTou_VAVLE && !GL_CTHL_CTXMSS_VAVLE && !GL_CTHL_CXDWZ_VAVLE && (!GL_CTHL_bMG || (GL_CTHL_bMG && GL_CTHL_LTou_Check)))
                {
                    GL_CTHL_HSLiao_VAVLE = 1;
                }  
                else   //条件警告  最后一个括号条件为已经有拉头
                {
                    if(!GL_CTHL_TLiao_Origin_IN)
                        GL_CTHL_SetAlarmCode(GL_CTHL_TLiao_Limit_ALARM,0); 
                    else if(!GL_CTHL_CTM_Origin_IN)
                        GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,0); 
                    else if(GL_CTHL_JLiao_Limit_IN)
                        GL_CTHL_SetAlarmCode(GL_CTHL_JLiao_Limit_ALARM,0); 

                }  
            }
        }           
        if(GL_CTHL_bJLT)                  //接拉头
        {
            GL_CTHL_bJLT = 0;
            if(GL_CTHL_JLTou_VAVLE)
                GL_CTHL_JLTou_VAVLE = 0;
            else if(!GL_CTHL_First_CT_VAVLE && !GL_CTHL_CTXMSS_VAVLE && GL_CTHL_CTM_Origin_IN && GL_CTHL_First_CT_Origin_IN)
            {
                GL_CTHL_MGuo_VAVLE = 0;
                GL_CTHL_JLTou_VAVLE = 1;
                GL_CTHL_CTXMXJ_VAVLE = 0;
            } 
            else//条件警告
            {
                if(!GL_CTHL_CTM_Origin_IN)
                 GL_CTHL_SetAlarmCode(GL_CTHL_CTM_Origin_ALARM,0); 
                else if(!GL_CTHL_First_CT_Origin_IN)
                  GL_CTHL_SetAlarmCode(GL_CTHL_First_CT_Origin_ALARM,0); 
            }
        } 
        if(GL_CTHL_bMG)                   //码勾
        {
            GL_CTHL_bMG = 0;
            GL_CTHL_MGuo_VAVLE = !GL_CTHL_MGuo_VAVLE;
        } 
        
         //斜码插入
        if(GL_CTHL_bBanZiDong)
        {
           GL_CTHL_bBanZiDong=0;
           cBanAuTo=1;
            bSingOneFlg=0;
           cCHULIANBAOJIN=0;
 //          GL_CTHL_PARAM_BanAuto_MODE=1;
          GL_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
          GL_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
          GL_CTHL_ZhuangLiaoStep = 1; 
           bTuiLaTouOkFlg = 1;
           bZhuangLiaoOkFlg= 0;
           bCL_EN_FLG=0;
           GL_CTHL_AutoStep = 1;  
           bRunning=1;
        }
         //小插插入
         if(GL_CTHL_CXC)//穿小插
        {
           GL_CTHL_CXC=0;
           cCXCONE=1;
           cBanAuTo=0;
              cCHULIANBAOJIN=0;
     //    GL_CTHL_PARAM_BanAuto_MODE=0;
           GL_CTHL_AutoStep = 11;  
           bRunning=1;
           if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                GL_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            } 
        }
        
        
        if(GL_CTHL_bFKJD)                 //方块夹带
        {
            GL_CTHL_bFKJD = 0;
            GL_CTHL_FKJD_VAVLE = !GL_CTHL_FKJD_VAVLE;
        } 
        if(GL_CTHL_bXKTD)                  //斜口推带
        {
            GL_CTHL_bXKTD = 0;
            if(GL_CTHL_XKTD_VAVLE)
                GL_CTHL_XKTD_VAVLE = 0;
            else if(((!GL_CTHL_DXK_VAVLE && (!GL_CTHL_XKSC_Limit_IN  || !GL_CTHL_CTXMSS_VAVLE))) || GL_CTHL_PARAM_QianMaSelect)
                GL_CTHL_XKTD_VAVLE = 1;
            else//条件警告
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_DXKCTXM_Origin_ALARM,0);          
            }
        } 
        if(GL_CTHL_bXKDW)                  //斜口定位
        {
            GL_CTHL_bXKDW = 0;
            GL_CTHL_XKDW_VAVLE = ~GL_CTHL_XKDW_VAVLE;
        } 
        if(GL_CTHL_bCTXM)                  //穿头下模
        {
            GL_CTHL_bCTXM = 0;
            if(GL_CTHL_CTXMSS_VAVLE)
            {
                GL_CTHL_HeMoStep = 10;
                
 //               GL_CTHL_JLTou_VAVLE = 0;
 //                GL_CTHL_CTXMXJ_VAVLE = 0;
        GL_CTHL_CTXMSS_VAVLE = 0;
            }    
            else if(!GL_CTHL_HSLiao_VAVLE && GL_CTHL_HSLiao_Origin_IN && (!GL_CTHL_XKSC_Limit_IN || !GL_CTHL_XKTD_VAVLE))                
            { 
 //               GL_CTHL_MGuo_VAVLE = 1;
              if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT==0)
                 GL_CTHL_CXSX_VAVLE=1;
                GL_CTHL_HeMoStep = 1;
//                GL_CTHL_CTXMSS_VAVLE = 1;
//                GL_CTHL_CTXMXJ_VAVLE = 1;
//                GL_CTHL_XMXJ_Time = dwTickCount + 450;
            }  
        } 
        if(GL_CTHL_bDXK)                  //顶斜口
        {
            GL_CTHL_bDXK = 0;
            if(GL_CTHL_DXK_VAVLE)
            {
                GL_CTHL_DXK_VAVLE = 0;

            }    
             else if(!GL_CTHL_XKTD_VAVLE)
             {  
                GL_CTHL_DXK_VAVLE = 1;
                GL_CTHL_GDXM_VAVLE = 1;
             }   
             else  //条件警告
             {
                  GL_CTHL_SetAlarmCode(GL_CTHL_XKTD_ALARM,0);   
             } 
        } 
        if(GL_CTHL_bXKGD)       //固定斜码电磁阀
        {
            GL_CTHL_bXKGD = 0;
            GL_CTHL_GDXM_VAVLE = ~GL_CTHL_GDXM_VAVLE;
        }
        if(GL_CTHL_bFKGD)                 //方块固定
        {
            GL_CTHL_bFKGD = 0;
            GL_CTHL_FKGD_VAVLE = ~GL_CTHL_FKGD_VAVLE;
        } 
        if(GL_CTHL_bCXQJD)                 //插销前夹带
        {
            GL_CTHL_bCXQJD = 0;
            GL_CTHL_CXQJD_VAVLE = ~GL_CTHL_CXQJD_VAVLE;
            GL_CTHL_SongDai_VAVLE = GL_CTHL_CXQJD_VAVLE;    //松带
        } 
        if(GL_CTHL_bCXSY)                 //插销下移电磁阀
        {
            GL_CTHL_bCXSY = 0;
            GL_CTHL_CXSX_VAVLE = !GL_CTHL_CXSX_VAVLE;
        } 
        //
        if(GL_CTHL_bCXHT)
        {
            if(GL_CTHL_PARAM_CR_MODE == 0)
            {
                GL_CTHL_bCXHT = 0;
                GL_CTHL_CXHT_VAVLE = ~GL_CTHL_CXHT_VAVLE;
                GL_CTHL_CXDW_Stop = 0;
            }
            else
            {
                //Y轴启动插销
                    GL_CTHL_CL_MotorStep = 20;  //插销定位 
                    SetEn(Y_AXIS, MOTOR_EN);
                GL_CTHL_CXDW_Stop = 1;
            }
        }  
        
        if(GL_CTHL_bCXDWZ)                 //Y14 插销定位针电磁阀
        {
            GL_CTHL_bCXDWZ = 0;
            if(GL_CTHL_CXDWZ_VAVLE)
                GL_CTHL_CXDWZ_VAVLE = 0;
            else if(GL_CTHL_HSLiao_Origin_IN)
            {
                GL_CTHL_CXDWZ_VAVLE = 1;
            }
            else //条件警告
            {
            GL_CTHL_SetAlarmCode(GL_CTHL_HENSONGLIAO_ALARM,0);   
            }
                
        } 
        if(GL_CTHL_bCXHJD)                 //Y15 插销后夹带电磁阀
        {
            GL_CTHL_bCXHJD = 0;
            GL_CTHL_CXHJD_VAVLE =~GL_CTHL_CXHJD_VAVLE;
        } 
        if(GL_CTHL_bCXHDW)                 //Y16 插销后定位电磁阀
        {
            GL_CTHL_bCXHDW = 0;
            if(GL_CTHL_CXHDW_VAVLE)
                GL_CTHL_CXHDW_VAVLE = 0;
            else if(!GL_CTHL_CXQJD_VAVLE)
            {
                GL_CTHL_CXHDW_VAVLE = 1;
                GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
            }
            else//条件警告
            {
            GL_CTHL_SetAlarmCode(GL_CTHL_CXQJD_ALARM,0);  
            }
        } 
        if(GL_CTHL_bFirst_CT)              //Y20 一次穿头电磁阀
        {
            GL_CTHL_bFirst_CT = 0;
            GL_CTHL_First_CT_VAVLE = ~GL_CTHL_First_CT_VAVLE;
        } 
        if(GL_CTHL_bHLJJ)                  //Y21 合链夹具电磁阀
        {
            GL_CTHL_bHLJJ = 0;
            GL_CTHL_HLJJ_VAVLE = ~GL_CTHL_HLJJ_VAVLE;
        } 
        if(GL_CTHL_bHL)
        {
            GL_CTHL_bHL = 0;
            GL_CTHL_HL_VAVLE = ~GL_CTHL_HL_VAVLE;
        }  
        
        if(GL_CTHL_bCXSCDW)               //Y23 插销上止定位电磁阀 
        {
            GL_CTHL_bCXSCDW = 0;
            GL_CTHL_CXSCDW_VAVLE = ~GL_CTHL_CXSCDW_VAVLE;
        } 
        //自动装料
        if(GL_CTHL_bAutoZhuangLiao)
        {
            GL_CTHL_bAutoZhuangLiao = 0;
            if(GL_CTHL_ZhuangLiaoStep == 0)
            {
                bTuiLaTouOkFlg = 1;
                bZhuangLiaoOkFlg = 0;
                GL_CTHL_ZhuangLiaoStep = 1;
                GL_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                GL_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
            }  
        }
        //测试电机
        if(GL_CTHL_bCLMotor_N)
        {           
            SetEn(Y_AXIS, MOTOR_EN);
            if(!GL_CTHL_SF_Origin_IN)
            {  
                if(!Y_DRV)
                  //                Y轴       运行速度                    启动速度        加速度  减速度
                        AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,1000,15,15);
            } 
            else
            {
                GL_CTHL_bCLMotor_N = 0;
            }
              
        }
        
        if(GL_CTHL_bCLMotor_P)  //后退限位已经取消
        {
            SetEn(Y_AXIS, MOTOR_EN);
           if(!Y_DRV)
              //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(Y_AXIS,2000,DIR_P,1000,1000,15,15);
        }
        
        
        
        if(!GL_CTHL_bCLMotor_P && !GL_CTHL_bCLMotor_N && (GL_CTHL_TD_MotorStep == 0) && (GL_CTHL_bFKCXTDDW_Step==0)&& (GL_CTHL_CL_MotorStep == 0))
        {
              AxisEgmStop(Y_AXIS);//AxisDecStop(Y_AXIS); 
        }
/*       
        if(GL_CTHL_bCLMotor_N)
        {      
          GL_CTHL_bCLMotor_N=0;
            SetEn(Y_AXIS, MOTOR_EN);
 
                if(!Y_DRV)
                  //                Y轴       运行速度                    启动速度        加速度  减速度
                       AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,-GL_CTHL_PARAM_CL_Length,2000,2000,50,50,50);
        }
        
        if(GL_CTHL_bCLMotor_P)  //后退限位已经取消
        {
          GL_CTHL_bCLMotor_P=0;
            SetEn(Y_AXIS, MOTOR_EN);
           if(!Y_DRV)
              //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisMovePosAccDec(Y_AXIS,GL_CTHL_PARAM_CL_Speed,GL_CTHL_PARAM_CL_Length,2000,2000,50,50,50);
        }
*/       
        //合链电机返回原点
        if(GL_CTHL_bCLMotor_O)
        {
            GL_CTHL_bCLMotor_O = 0;
            if(GL_CTHL_CL_MotorStep == 0)
                GL_CTHL_CL_MotorStep = 40;
        } 
        //拖带方块定位 ,因这步为前拖带定位, 很多电磁阀要关掉       
        if(GL_CTHL_bFKTDDW)
        {
            GL_CTHL_bFKTDDW = 0;
            if(GL_CTHL_TD_MotorStep == 0)
            {
                GL_CTHL_XKDW_VAVLE = 0;     //斜口定位
                GL_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                //GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
           
                      GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
 //               GL_CTHL_CXSX_VAVLE = 1;     //插销下移
                GL_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                GL_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                GL_CTHL_bHLJJ = 0;          //合链夹具
                GL_CTHL_FKJD_VAVLE = 0;     //方块夹带
                if((GetEn(X_AXIS) == MOTOR_DISEN))
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    GL_CTHL_TD_MotorDelay = dwTickCount + 200;                    
                } 
                else
                    GL_CTHL_TD_MotorDelay = dwTickCount + 50;
                GL_CTHL_TD_MotorStep = 1;
                GL_CTHL_cZipCnt = 0;
            } 
        } 
        //拖带方块插销定位(斜口推带，斜口定位，顶斜口)
        if(GL_CTHL_bFKCXTDDW)
        {
            GL_CTHL_bFKCXTDDW = 0;
            if((GL_CTHL_bFKCXTDDW_Step == 0) && (GL_CTHL_CL_MotorStep == 0) && 
               !GL_CTHL_CTXMSS_VAVLE)
            {
                GL_CTHL_bFKCXTDDW_Step = 1;
                SetEn(X_AXIS, MOTOR_EN);
                GL_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                //GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
         
                    GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
                GL_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                GL_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                GL_CTHL_HLJJ_VAVLE = 0;          //合链夹具
            }  
        } 
        //插销穿入(包含电机前定位,插销下移,后夹,后定位)
        if(GL_CTHL_bCXCR) 
        {
            GL_CTHL_bCXCR = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(GL_CTHL_CTXMSS_VAVLE && GL_CTHL_MGuo_VAVLE && !GL_CTHL_CXQJD_VAVLE &&
               GL_CTHL_CTM_Limit_IN && !GL_CTHL_LTou_Check)
            {                
                if(GL_CTHL_CL_MotorStep == 0)
                {
                     GL_CTHL_bCXCR_Step = 11; 
                      if(GL_CTHL_PARAM_UP_DOWN_OUT_SELECT == 0)
                        GL_CTHL_CXSX_VAVLE = 1;    //插销上下
                    else
                      GL_CTHL_CXSX_VAVLE = 0;    //插销顶出
 //                    GL_CTHL_CXSX_VAVLE = 1;     //Y06 插销下移电磁阀关
                     GL_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                     GL_CTHL_CXHDW_VAVLE = 0;
                     GL_CTHL_HL_VAVLE = 0;
                     
                     if(GL_CTHL_PARAM_CR_MODE==0)
                        GL_CTHL_CXSCDW_VAVLE = 1;
                     if(GL_CTHL_PARAM_CR_MODE == 1)
                     {   
                         SetEn(Y_AXIS, MOTOR_EN);
                         if(!GL_CTHL_SF_Origin_IN)
                            GL_CTHL_CL_MotorStep = 40;
                     }
                }
            }
            else   //警告不能自动穿插销
            {
                GL_CTHL_SetAlarmCode(GL_CTHL_WFZIDONGCX_ALARM,0);  
            }
        }
        //电机合链动作
        if(GL_CTHL_bMotorHL)
        {
            GL_CTHL_bMotorHL = 0;
            if(GL_CTHL_PARAM_CR_MODE == 1)
            {
                if(GL_CTHL_SF_Origin_IN)
                {
                    if((GL_CTHL_CL_MotorStep == 0) && !GL_CTHL_CTXMSS_VAVLE && (!GL_CTHL_CTM_Limit_IN))
                    {
                        bCL_OK_FLG = 0;   
                        GL_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                        GL_CTHL_CL_MotorStep = 1;
                        GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_HLJJ_CL_DELAY + 130;
                        if((GetEn(Y_AXIS) == MOTOR_DISEN))
                        {
                            SetEn(Y_AXIS, MOTOR_EN);
                            GL_CTHL_CL_MotorDelay = dwTickCount + 250;                    
                        } 
                        if((GL_CTHL_LianLengthAutoCheck ==0) || (GL_CTHL_PARAM_CL_Length == 0))
                        {
                            GL_CTHL_LianLengthAutoCheck = 1000;
                            GL_CTHL_PARAM_CL_Length = 1000;
                        }  
                    }
                }
                else
                {
                    GL_CTHL_bCLMotor_O = 1;            
                }
            }
            else
            {
                GL_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                GL_CTHL_CL_MotorStep = 1;
                GL_CTHL_CL_MotorDelay = dwTickCount + GL_CTHL_PARAM_HLJJ_CL_DELAY;
            }   
        } 
        //一次穿链动作
        if(GL_CTHL_bCL_First)
        {
            GL_CTHL_bCL_First = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(GL_CTHL_CTXMSS_VAVLE && GL_CTHL_MGuo_VAVLE && !GL_CTHL_CXQJD_VAVLE &&
               GL_CTHL_CTM_Limit_IN && !GL_CTHL_LTou_Check && (GL_CTHL_CL_MotorStep == 0))
            {  
                GL_CTHL_bCLFirst_Step = 19;
                GL_CTHL_CXHJD_VAVLE = 1;    //插销后夹带 
                GL_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                GL_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                //GL_CTHL_SongDai_VAVLE = 0;          //Y30 松带
            }
        }
        if(GL_CTHL_bSongZhou)
        {
          GL_CTHL_bSongZhou=0;
          if(GetEn(X_AXIS)==MOTOR_EN) 
           {
              SetEn(X_AXIS, MOTOR_DISEN);
           }
           else
           {
             SetEn(X_AXIS, MOTOR_EN);
           }  
        }

            if((!GL_CTHL_bTiaoShiMode) && GL_CTHL_START_IN_UP)
                nodelink_reset();
    }        
}

#endif