GC23005/Machine/ChuanChiMachine/CCChuantou_HeLian.c

#include "global.h"

#if Chuan_Chi_MACHINE  ==  1

void CC_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag);
void CC_CTHL_ManualAction(void);
void CC_CTHL_AutoStepAction(void);
void CC_CTHL_TableAction(void);
void CC_CTHL_TD_Motor(void);
void CC_CTHL_CL_Motor(void);
void CC_CTHL_CheckStart(void);
void CC_CTHL_TLiao_Step(void);  //推料(推拉头)
void CC_CTHL_AlarmProtect(void);
void CC_CTHL_ZLT_Step(void);
void CC_CTHL_ZhenDongAction(void);
void CC_CTHL_bFKCXTDDWStep(void);
void CC_CTHL_bCXCRStep(void);
void CC_CTHL_bCLFirstStep(void);


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

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

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

void CC_CTHL_Action(void)
{ 
    user_datas[121] = CC_CTHL_LianLengSave;
 //   user_datas[122] =axis_x->cur_speed;
  //  user_datas[123] = CC_CTHL_bCXCR_Step;
    dwXRealPos = GetPos(X_AXIS);
    dwYRealPos = GetPos(Y_AXIS);
    dwZRealPos = GetPos(Z_AXIS);  
    user_datas[124] = dwXRealPos;
    user_datas[125] = dwYRealPos;
    
    user_datas[126] = GetAlarm(X_AXIS);
    user_datas[127] = GetAlarm(Y_AXIS);
   user_datas[128] = CC_CTHL_AutoStep;  
    
    CC_CTHL_ZhenDongAction();
    CC_CTHL_AlarmProtect();
    CC_CTHL_CheckStart();    
    CC_CTHL_ZLT_Step();
    CC_CTHL_TLiao_Step();
    CC_CTHL_TD_Motor();
    CC_CTHL_CL_Motor();
    CC_CTHL_bFKCXTDDWStep();
    CC_CTHL_bCXCRStep();
    CC_CTHL_bCLFirstStep();
    CC_CTHL_ManualAction();

    CC_CTHL_AutoStepAction();  
}

void CC_CTHL_AlarmProtect(void)
{ 
    

 
}


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

   

    if(bRunning)
    {
        switch(CC_CTHL_AutoStep)
        {
            case 1:
              if(CC_CTHL_SF_Origin_IN || cBanAuTo)
              {
        /*       CC_CTHL_AutoStep = 10;       //测试拖带定位
               CC_CTHL_AutoDelay = dwTickCount + 1000;
               break; */
            if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
              {
                CC_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                CC_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                CC_CTHL_FKGD_VAVLE = 0;     //方块固定关
            //    CC_CTHL_XKDW_VAVLE = 1;
                CC_CTHL_AutoStep = 2;
           //     CC_CTHL_AutoDelay = dwTickCount + 10;
                if(CC_CTHL_ZhuangLiaoStep == 0)
                { 
                    CC_CTHL_ZhuangLiaoStep = 1;
                    CC_CTHL_TryCnt = 0;
                }   
              }
              }
                break;
            case 2: 
            if(!CC_CTHL_XKTD_Origin_IN)// && (dwTickCount >= CC_CTHL_AutoDelay))  //斜口推带原位离开
            {
               if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
              {
                    CC_CTHL_AutoStep = 3;
                    CC_CTHL_XKDW_VAVLE = 1;
                    CC_CTHL_AutoDelay = dwTickCount + 20;
              }
                }  
                break;
            case 3://斜口定位
                if(dwTickCount >= CC_CTHL_AutoDelay)
                {                   
                    CC_CTHL_AutoStep = 4;
           //         CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_XKDW_TD_DELAY;
                }  
                break;
            case 4:
               if(!cBanAuTo)
              {
              if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
              {
                    AxisMovePosAccDecNotStop(X_AXIS,1600,1500,600,1000,5,3,00); 
                    CC_CTHL_AutoStep = 5;
                    cDJzzcd=0;
                   CC_CTHL_XSavePosBuff = dwXRealPos;
             //       SetPos(X_AXIS, 0);  //启动位置设为0点
                      if(cZipCnt < 1)
                         CC_CTHL_AutoDelay = dwTickCount +350;
                      else
                       CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_FKJD_DELAY;
              }
              }
               else
                {
               CC_CTHL_AutoStep = 5;
                 CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_FKJD_DELAY;
                   CC_CTHL_XSavePosBuff = dwXRealPos;
              }
                 
                break;
            case 5:
              if(dwTickCount >= CC_CTHL_AutoDelay)
                {
                  CC_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                  
                }
                if(bCL_EN_FLG && (dwXRealPos >= 230) && CC_CTHL_XKSC_Limit_IN)
                {                    
                    CC_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                }

                if(CC_CTHL_XKSC_Limit_IN)   //方块上止到位
                {
                    CC_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                 if(!CC_CTHL_PARAM_DCGO_LENGTH)
                     AxisEgmStop(X_AXIS);
                  else
                  {
                    if(!cDJzzcd)
                    {
                    AxisMovePosAccDec(X_AXIS,1000,CC_CTHL_PARAM_DCGO_LENGTH,800,600,10,20,0); 
                    cDJzzcd=1;
                    }
                
                  }
                   // AxisMovePosAccDec(X_AXIS,1200,10,1200,1200,6,6,0);  
                if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
              {      
                CC_CTHL_CXHJD_VAVLE=1;
              
                    CC_CTHL_QDXK_VAVLE = 1;
                    CC_CTHL_FKJD_VAVLE=0;
                  
                    CC_CTHL_AutoStep = 6;              
                    
                    CC_CTHL_bLTCHECK_Delay = dwTickCount + 20;
                    //电机穿入可以启动
                    bCL_OK_FLG = 1;   //不用穿合链的话认为已经完成
                    if(bCL_EN_FLG)
                    {
                      dwYRealPos=0;
                        bCL_OK_FLG = 0;
                        CC_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                        CC_CTHL_CL_MotorStep = 1;
                        CC_CTHL_CL_MotorDelay = dwTickCount + CC_CTHL_PARAM_HLJJ_CL_DELAY;
                        
                        CC_CTHL_AutoDelay = dwTickCount + 50 + CC_CTHL_PARAM_HLJJ_CL_DELAY;  
                    }
                    else
                    {
                        CC_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭      
                        CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;       
                    }   
              }
                }
                else if(dwXRealPos >= (CC_CTHL_XSavePosBuff + 1500))
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_FKCXDW_ALARM,bRunning);  //方块插销定位异常警告
                    
                }  
                break;
            case 6:
                if((dwYRealPos > 1000) || (CC_CTHL_CL_MotorStep==0))
                {
                    CC_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭      
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;    
                }  
              
                if(CC_CTHL_XKTD_Origin_IN)      //斜口推带回到原位
                {
               if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
               {
                    if(bZhuangLiaoOkFlg && (CC_CTHL_ZhuangLiaoStep == 0))
                    {
                         if(dwTickCount >= CC_CTHL_bLTCHECK_Delay)
                         {
                   
                              if(!CC_CTHL_LTou_Check)
                              {
                                if(CC_CTHL_PARAM_DXKFZ_LENTH && !X_DRV)  //拖带电机反转
                                  {
                                   AxisMovePosAccDec(X_AXIS,8000,-CC_CTHL_PARAM_DXKFZ_LENTH,800,600,20,30,0); 
                                  if(!CC_CTHL_PARAM_NLSL_MODE)
                                       CC_CTHL_FKJD_VAVLE= 0;   //方块夹带气缸关
                                     
                                  }
                                if(CC_CTHL_PARAM_CXCC_MODE)
                                    CC_CTHL_CXCC_VAVLE = 1;
                                CC_CTHL_CTXM_VAVLE = 1; //穿头下模上升
                                if(CC_CTHL_PARAM_NLSL_MODE)
                                    CC_CTHL_KALATOU_VAVLE=1;
                                CC_CTHL_AutoStep = 7;
                                CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                              }
                              else
                              {
                                 cWULATOUCnt=1;
                                CC_CTHL_SetAlarmCode(CC_CTHL_ZLT_ALARM,bRunning);  // 没有拉头                               
                              }
                            }
                         
                    } 
                 }
                }
                else if((dwTickCount >= CC_CTHL_AutoDelay) && !CC_CTHL_XKTD_VAVLE  && !cBanAuTo) 
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_XKTD_Origin_ALARM,bRunning); //斜口推带回到异常
                }
                break;
            case 7: 
                if(!CC_CTHL_CTM_Origin_IN)
                {
                    CC_CTHL_JLTou_VAVLE = 0;    //接拉头
                }
                if(CC_CTHL_CTM_Limit_IN) 
                {
                 if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                  if(CC_CTHL_PARAM_NLSL_MODE)
                  {
                  
                    CC_CTHL_XKTD_VAVLE=1;
                  }
                    CC_CTHL_JLTou_VAVLE = 0;
                    CC_CTHL_AutoStep = 8;    
                   CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_DXKYS_DELAY;
                 }
                }  
                else if(dwTickCount >= CC_CTHL_AutoDelay)
                {
                  CC_CTHL_SetAlarmCode(CC_CTHL_CTM_Limit_ALARM,bRunning);  //穿头下模上升异常
                }
                break;

        case 8:
               if(!X_DRV)  //延时顶斜口
               {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                 if((dwTickCount >= CC_CTHL_AutoDelay) || (CC_CTHL_PARAM_NLSL_MODE))
                 {  
                 if(!CC_CTHL_PARAM_NLSL_MODE)
                    CC_CTHL_DXK_VAVLE=1;
                   CC_CTHL_CXHJD_VAVLE=0;
                  CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_DXK_XKDW_Off_DELAY;
                  CC_CTHL_AutoStep = 9;
                 }
                 }

               }
               break;
            case 9: 
                if((dwTickCount >= CC_CTHL_AutoDelay) && (bCL_OK_FLG))  //顶斜口延时退斜口上止定位
                {
                    if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
 //                   AxisMovePosAccDec(X_AXIS,2000,-150,1200,1200,3,6,0);  //反转1.5CM
                    CC_CTHL_XKDW_VAVLE = 0;    //斜口上止定位关
                    CC_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
                    CC_CTHL_AutoStep = 10;    
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_XK_CR_DELAY;
                 }
                }              
                break;
            case 10:  
                if(!cBanAuTo)
               {
                if((dwTickCount >= CC_CTHL_AutoDelay) && !X_DRV)
                {
                    if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_TD_MotorStep = 10;   //启动拖带穿入            
                    CC_CTHL_AutoStep = 11;  
                 }

                }
                }
               else
               {
                CC_CTHL_AutoStep = 801; 
                  CC_CTHL_AutoDelay = dwTickCount + 1000;
               }
                break;
             case 801:
              if(dwTickCount >= CC_CTHL_AutoDelay)
              {
                 
                  bRunning=0;
                  cBanAuTo=0;
                CC_CTHL_KALATOU_VAVLE=0;
                   cCHULIANBAOJIN=1;
                  CC_CTHL_QDXK_VAVLE=0;
                  CC_CTHL_XKTD_VAVLE = 0;
                  CC_CTHL_DXK_VAVLE=0;
                  CC_CTHL_AutoStep = 0; 
              
              }
              break;
            case 11:
              
                if(CC_CTHL_TD_MotorStep == 0)  //穿入定位完成
                {      
             /*   //测试拖带定位  
                    CC_CTHL_AutoStep = 1;       
                    CC_CTHL_AutoDelay = dwTickCount + 1000;
                     if(cZipCnt<3)
                        cZipCnt++;
                    break;  */
              cTESTONE=0;
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                        CC_CTHL_XKDW_VAVLE = 0;    //斜口上止定位关
                        CC_CTHL_XKTD_VAVLE = 1;     //斜口推带气缸输出 
                        CC_CTHL_CXSCDW_VAVLE = 1;   //Y21 插销上止定位电磁阀
                        cXcxcrCnt = 0;
                        if(CC_CTHL_CL_MotorStep == 0 && CC_CTHL_SF_Origin_IN)
                        {                          
                           CC_CTHL_CXQJD_VAVLE = 1;
                        }                 
                        CC_CTHL_AutoStep = 12; 
                 //       CC_CTHL_AutoDelay = dwTickCount + 50;
                 }
                }  
                break;        
            case 12: 
                if((CC_CTHL_CL_MotorStep == 0)&& (CC_CTHL_SF_Origin_IN))  //插销前夹带回到原位
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 14; 
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_XCQJD_XCDW_DELAY;
                    if(cXcxcrCnt != 1)
                    {                        
                      CC_CTHL_CXQJD_VAVLE = 1;                    
                    }
                 }
                }
                if(!CC_CTHL_SF_Origin_IN)
                {
                CC_CTHL_CL_MotorStep=50;
                
                }
                break;
            case 14:
                if(dwTickCount >= CC_CTHL_AutoDelay)
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_XKDW_VAVLE = 1; //斜口定位 
                    CC_CTHL_AutoStep = 15; 
                    CC_CTHL_FKGD_VAVLE = 1;     //方块固定
                    //Y轴启动插销
                    if(cXcxcrCnt != 1)
                    {   
                      CC_CTHL_CL_MotorStep = 20;  //插销定位     
                    }
                 }
                }
                break;
            case 15:   
                if(CC_CTHL_CL_MotorStep == 0)   //插销定位完成
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 16; 
                    CC_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                    CC_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    CC_CTHL_AutoDelay = dwTickCount + 10;  //延时插销下移
                 }
                }  
                break;
            case 16: 
                if(dwTickCount >= CC_CTHL_AutoDelay)
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 17; 
                     if(CC_CTHL_PARAM_CXCC_MODE)
                       CC_CTHL_CXCC_VAVLE = 0;
                    else
                       CC_CTHL_CXCC_VAVLE = 1;     //Y06 插销下移电磁阀
                    CC_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
                 }
                }
                break;
            case 17:   
                 if(CC_CTHL_PARAM_CXCC_MODE)
                {
                  if(CC_CTHL_CXCC_Limit_IN)
                  {
                     if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                      CC_CTHL_AutoStep = 18; 
                      if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
                      {
                          AxisMovePosAccDec(X_AXIS,8000,-CC_CTHL_PARAM_TDFZ_LENTH,800,600,20,30,0);               
                      }
                      CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀     
                      CC_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
                      CC_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                      CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_SCDWOff_CXDW_DELAY;
                 }
                  }  
                  else if(dwTickCount >= CC_CTHL_AutoDelay)  
                  {
                      CC_CTHL_SetAlarmCode(CC_CTHL_CXCC_Limit_ALARM,bRunning); //插销下移异常
                      
                  }
                }
              else
              {             
                    CC_CTHL_AutoStep = 18; 
                    if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
                    {
                        AxisMovePosAccDec(X_AXIS,8000,-CC_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);               
                    }
                    CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                    CC_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关   
                      
                    CC_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_SCDWOff_CXDW_DELAY;              
              }
                break;
            case 18:   
  //              if(START_IN_UP)
                {
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 19; 
                    cBAOHUCNT=0;
                     CC_CTHL_SongDai_VAVLE=0;
                  //   CC_CTHL_SongDai_VAVLE=0;
                    CC_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
                    CC_CTHL_AutoDelay = dwTickCount + 500;  //插销穿入到位异常时间
                    CC_CTHL_CL_MotorStep = 50;  //合链电机回原点
                 }
                }
                }
                break;
            case 19:   
                
                if(CC_CTHL_CX_Limit_IN && (cXcxcrCnt<4))
                {
                  if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                   cXcxcrCnt=0;
                   cXiaoChaCNT=0;
                   user_datas[100]=0;
                    bZhuangLiaoOkFlg = 0;
                  CC_CTHL_CXCC_VAVLE=0;
                    CC_CTHL_AutoStep = 901;
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_FKGD_DELAY; //退方块固定时间
                    CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                 }
                   
                }  
                else if ((dwTickCount >= CC_CTHL_AutoDelay) && (cXcxcrCnt<3) )
                {
                   cXcxcrCnt++;
                   CC_CTHL_CXHJD_VAVLE=0;
                   CC_CTHL_CXHDW_VAVLE=0;
                   if(!CC_CTHL_PARAM_CXCC_MODE)
                      CC_CTHL_CXCC_VAVLE=0;
                    else
                      CC_CTHL_CXCC_VAVLE=1;
                   if(cXcxcrCnt<3)
                   {
                     CC_CTHL_CXSCDW_VAVLE=1;
                     CC_CTHL_AutoStep = 12;
                     CC_CTHL_AutoDelay = dwTickCount + 120;
                   }
                }
                else if((dwTickCount >= (CC_CTHL_AutoDelay +3000))  && !CC_CTHL_CX_Limit_IN )
                {
                   cXiaoChaCNT=1;
                   if(!CC_CTHL_PARAM_CXCC_MODE)
                     CC_CTHL_CXCC_VAVLE=0;
                   else
                     CC_CTHL_CXCC_VAVLE=1; 
                   CC_CTHL_CXHJD_VAVLE =0;
               
                   cBAOHUCNT=1;
                  CC_CTHL_SetAlarmCode(CC_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                
                }
      
               if( cXcxcrCnt > 2) 
                {
                   cXiaoChaCNT=1;
              
                     CC_CTHL_CXCC_VAVLE=0;
                   CC_CTHL_CXHJD_VAVLE =0;
                   cBAOHUCNT=1;
                  CC_CTHL_SetAlarmCode(CC_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                  if(CC_CTHL_START_IN_UP)
                  {
                  
                   CC_CTHL_SetAlarmCode(0,bRunning); 
                     CC_CTHL_CXSCDW_VAVLE=1;
                     CC_CTHL_AutoStep = 12;
                     CC_CTHL_CXHJD_VAVLE=0;
                     cXiaoChaCNT=0;
                      cBAOHUCNT=0;
                       cXcxcrCnt=0;
                     CC_CTHL_CXHDW_VAVLE=0;
                   if(!CC_CTHL_PARAM_CXCC_MODE)
                     CC_CTHL_CXCC_VAVLE=0;
                   else
                     CC_CTHL_CXCC_VAVLE=1;
                  
                  
                  }
                }
      
              break;
              
            case 901:
                if(dwTickCount >= CC_CTHL_AutoDelay)
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                 CC_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    CC_CTHL_AutoStep = 20;
                    if(!cBAOHUCNT)
                       CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
                    else
                    {
                      CC_CTHL_AutoDelay = dwTickCount + 1000;//手动插销保护时间
                      cBAOHUCNT=0;
                    }
                 }
             
                }
            break;
            case 20:  
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 21;
                  //   CC_CTHL_FKJD_VAVLE=0;
                    CC_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                 }
                }
                break;
            case 21:   
                if(!CC_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 22;
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
                 }
                }
                else if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
                }
                break;
            case 22:
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 23;
                    CC_CTHL_MGuo_VAVLE = 0;     //码勾退
                    if(CC_CTHL_PARAM_LTJJ_MODE)
                    {
                    CC_CTHL_LTJJ_VAVLE=1;
                    }
                    CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_PARAM_MGOff_XiaMo_DELAY;
                    CC_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    CC_CTHL_FKJD_VAVLE=0;
                 //   CC_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                    CC_CTHL_CXCC_VAVLE = 0;     //Y06 插销下移电磁阀关
                 }
                } 
                break;
            case 23:  
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                   
                    if(!CC_CTHL_LTJJ_Origin_IN || !CC_CTHL_PARAM_LTJJ_MODE)
                    {
                       CC_CTHL_CTXM_VAVLE = 0; //穿头下模下降
                        CC_CTHL_AutoStep = 24;
                      CC_CTHL_AutoDelay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                    }
                    else if(dwTickCount >= CC_CTHL_AutoDelay+3000)
                    {
                      CC_CTHL_SetAlarmCode(CC_CTHL_XMKH_Origin_ALARM,bRunning);
            
                    }
                 }
                } 
                break;
            case 24: 
                if(!CC_CTHL_CTM_Limit_IN)
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 25;
                    CC_CTHL_FKJD_VAVLE=0;
                    CC_CTHL_CXHJD_VAVLE = 0;  
                    CC_CTHL_AutoDelay = dwTickCount + 20;  //一次穿入延时返回
                 }
                }
                else if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_CTM_Origin_ALARM,bRunning);//穿头下模下降异常
                }
                break;
            case 25:
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_AutoStep = 26;
                    CC_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                    CC_CTHL_AutoDelay = dwTickCount + 5;
                 
                    //退下出错警告
                    CC_CTHL_AutoDelay1 = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                    CC_CTHL_AutoStep1 = 1;
                 }
                }
                break;
        
          
            case 26: 
                if(dwTickCount >= CC_CTHL_AutoDelay) 
                {
                     if(!cCXCONE)
                    {
                   if(!CC_CTHL_DANBU_MODE || CC_CTHL_START_IN_UP)
                 {
                    CC_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出   
                    CC_CTHL_FKGD_VAVLE = 0;     //方块固定关            
                    CC_CTHL_AutoStep = 4;
                    bCL_EN_FLG = 1;
                    cXcxcrCnt=0;
                    AddToTal(CC_CTHL_TOTAL_ADDR);
                   AddToTal(CC_CTHL_TRUST_ALARM_ADDR);
                    AddToTal(CC_CTHL_TEST_ALARM_ADDR);
                    CalProSP(CC_CTHL_SPEED_ADDR);
                    if(cZipCnt<3)
                        cZipCnt++;
                 }
                }
                  else
                    {
                    bRunning=0;
                      cCXCONE=0;
                    CC_CTHL_AutoStep = 0;
                    
                    }
                }
                break;
                
        }   
    }       
        //退下模后启动送拉头
        switch(CC_CTHL_AutoStep1)
        {   
            case 1:
              if(cStopMode==1 || bSingOneFlg )
              {
                bCL_EN_FLG=1;
                cStopMode=2;
                bSingOneFlg=0;
                 bStop=1;
              }
                if(CC_CTHL_CTM_Origin_IN && CC_CTHL_First_CT_Origin_IN)
                {
                    CC_CTHL_ZhuangLiaoStep = 1;
                    CC_CTHL_TryCnt = 0;
                    CC_CTHL_AutoStep1 = 0;
                    CC_CTHL_MGuo_VAVLE = 0;
                    CC_CTHL_JLTou_VAVLE = 0;
                }
                else if(dwTickCount >= CC_CTHL_AutoDelay1) 
                {
                  //穿头模和一次穿入回位异常
                    if(!CC_CTHL_CTM_Origin_IN)
                      CC_CTHL_SetAlarmCode(CC_CTHL_CTM_Origin_ALARM,bRunning);
                    else if(!CC_CTHL_First_CT_Origin_IN)
                      CC_CTHL_SetAlarmCode(CC_CTHL_First_CT_Origin_ALARM,bRunning);                    
                } 
                break;
                
        }  
         
}





void CC_CTHL_CheckStart(void)
{
  
  
  if(cXCXQXQD)
  {
            if(CC_CTHL_START_IN_UP || bStart)
              {
                  bStart=0;
                if(!bRunning)
                {
                  if(CC_CTHL_SafeDoor_IN )
                  {
                   bRunning=1;             
                   cXCXQXQD =0;  
                 CC_CTHL_TD_MotorStep = 0;   
                   CC_CTHL_AutoStep=11;
                   }
                    else
                    {
                        CC_CTHL_SetAlarmCode(CC_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                    }
                }
              }
  
  
  }
      if(cWULATOUCnt) // 无拉头警告后按
      {
            if(CC_CTHL_START_IN_UP || bStart)
            {
              bStart=0;
              if(!bRunning)
              {
                    if(CC_CTHL_SafeDoor_IN)
                    {  
                        bRunning=1;
                       CC_CTHL_TryCnt=0;
                       cWULATOUCnt=0;
                      CC_CTHL_ZhuangLiaoStep = 1; 
                      CC_CTHL_AutoStep=6;
                       bTuiLaTouOkFlg = 1;
                        bZhuangLiaoOkFlg= 0;
                       CC_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                       CC_CTHL_LTJJ_VAVLE=0;
                       CC_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
                    }
                    else
                    {
                        CC_CTHL_SetAlarmCode(CC_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                    }
              }
            }
      }
    if(!CC_CTHL_SafeDoor_IN && bRunning)
    {
      bStop=1;
      CC_CTHL_SetAlarmCode(CC_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
     }
      
       //启动    自动启动 单一自动	 			
    if((CC_CTHL_START_IN_UP || bStart || CC_CTHL_bSingleone) && !cWULATOUCnt  && !cXCXQXQD)
    {
     if(cCHULIANBAOJIN) //无链停机启动
      {
             bRunning=1;
      CC_CTHL_AutoStep = 11;  
      cCHULIANBAOJIN=0;
    //  SetEn(X_AXIS, MOTOR_EN);
  //    SetEn(Y_AXIS, MOTOR_EN);
  //      dwXRealPos=0;
      CC_CTHL_PARAM_BanAuto_MODE=0;
       CC_CTHL_TD_MotorStep=9;
       if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
        {
           SetClr(Y_AXIS, MOTOR_NOALARM);
            SetClr(X_AXIS, MOTOR_NOALARM); 
            SetEn(X_AXIS, MOTOR_DISEN);
         CC_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
        }
        cZipCnt=0;
        CC_CTHL_TD_MotorDelay = dwTickCount + 500;
         CC_CTHL_AutoDelay = dwTickCount + 150;
        if(GetAlarmCode(CC_CTHL_ALARM_ADDR) != 0)
           SetAlarmCode(CC_CTHL_ALARM_ADDR,0);   

      }
      
        if(!bRunning)
        {
            if(CC_CTHL_SafeDoor_IN)
            {  
               cStopMode=0;
                if(CC_CTHL_bSingleone)
                {
                  bSingOneFlg=1;
                }
                bRunning = 1;
                cWULATOUCnt=0;
                  cBanAuTo=0;
               cCXCONE=0;
               CC_CTHL_PARAM_BanAuto_MODE=0;
                cHeLian=0;
                SetEn(X_AXIS, MOTOR_EN);
                SetEn(Y_AXIS, MOTOR_EN);        
                CC_CTHL_CL_MotorStep = 40;
                CC_CTHL_AutoStep = 1;
                bTuiLaTouOkFlg = 1;
                CC_CTHL_PARAM_ZDP_AUTO= 0;
                bZhuangLiaoOkFlg= 0;
               if(!CC_CTHL_PARAM_LTJJ_MODE)
                    {
                    CC_CTHL_LTJJ_VAVLE=0;
                    }
               
                CC_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                CC_CTHL_LTJJ_VAVLE=0;
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
             //   bCL_EN_FLG = 0;
                cZipCnt = 0;
                cQDXK_DXK=0;
                CC_CTHL_LianLengthCheck = 0;
                cStopInCnt = 0;
             }
             else
             {
                CC_CTHL_SetAlarmCode(CC_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
             }            
        }  
     CC_CTHL_bSingleone=0;
        bStart = 0;
    }   
  if(CC_CTHL_STOP_INJT_UP)
  {
           bRunning=0;
           CC_CTHL_PARAM_BanAuto_MODE=0;
          cXcxcrCnt=0;
          cStopMode=0;
              cCHULIANBAOJIN=0;
            cXCXQXQD=0;
          cWULATOUCnt=0;
            cBanAuTo=0;
          cCXCONE=0;
          bCL_EN_FLG=0;
         AxisEgmStop(X_AXIS);
          AxisEgmStop(Y_AXIS);
         SetEn(X_AXIS, MOTOR_DISEN);
         SetEn(Y_AXIS, MOTOR_DISEN);
          cStopMode=0;
          cQDXK_DXK=0;
        
       if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
        {
           SetClr(Y_AXIS, MOTOR_NOALARM);
            SetClr(X_AXIS, MOTOR_NOALARM);
         CC_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
        }
          CC_CTHL_TLiao_VAVLE=0;             
         CC_CTHL_HSLiao_VAVLE  =0;    
         CC_CTHL_JLTou_VAVLE  =0;     
         CC_CTHL_XKTD_VAVLE  =0;        
         CC_CTHL_XKDW_VAVLE  =0;       
         CC_CTHL_DXK_VAVLE  =0;         
         CC_CTHL_CXCC_VAVLE  =0;         
         CC_CTHL_CTXM_VAVLE =0;         
         CC_CTHL_First_CT_VAVLE =0;     
         CC_CTHL_FKGD_VAVLE =0;         
         CC_CTHL_CXQJD_VAVLE =0;        
         CC_CTHL_CXDWZ_VAVLE  =0;       
         CC_CTHL_CXHJD_VAVLE =0;        
         CC_CTHL_CXHDW_VAVLE =0;        
         CC_CTHL_FKJD_VAVLE  =0;        
         CC_CTHL_HLJJ_VAVLE  =0;                       
         CC_CTHL_CXSCDW_VAVLE =0;
         CC_CTHL_MGuo_VAVLE =0;
         CC_CTHL_QDXK_VAVLE=0;
         CC_CTHL_LTJJ_VAVLE  =0;      
         CC_CTHL_AutoStep = 0;
         CC_CTHL_ZhuangLiaoStep=0;
         CC_CTHL_TLiaoStep=0;
         CC_CTHL_TD_MotorStep=0;
         CC_CTHL_JiaLianStep  =0;        
         CC_CTHL_SongLiaoStep   =0;     
         CC_CTHL_CL_MotorStep =0;      
         CC_CTHL_AutoStep1  =0;
         CC_CTHL_bFKCXTDDW_Step=0;
         CC_CTHL_bCXCR_Step=0;
         CC_CTHL_bCLFirst_Step=0;
         if(GetAlarmCode(CC_CTHL_ALARM_ADDR) != 0)
            SetAlarmCode(CC_CTHL_ALARM_ADDR,0);  
          SetPos(X_AXIS, 0); 

        CC_CTHL_TLiaoStep = 0; 
        CC_CTHL_AutoStep = 0;
        
        //穿合链电机是往零点方向时可以停止
        if(GetDir(Y_AXIS) == DIR_N)
            AxisEgmStop(Y_AXIS);
  }
    
    //停止
    if(CC_CTHL_STOP_IN_UP || bStop)
    {	
    CC_CTHL_PARAM_BanAuto_MODE=0;
      if(cStopMode < 2)
        cStopMode++;
      if(bRunning && cStopMode==2)
      {   
        bRunning=0;
        cStopMode=0;
        cXcxcrCnt=0;
          bSingOneFlg=0;
        cXCXQXQD=0;
        cCHULIANBAOJIN=0;
        CC_CTHL_PARAM_BanAuto_MODE=0;
        cWULATOUCnt=0;
          cBanAuTo=0;
       cCXCONE=0;
        AxisEgmStop(X_AXIS);
        AxisEgmStop(Y_AXIS);
        CC_CTHL_AutoStep = 0; 
        CC_CTHL_CL_MotorStep =0;      
        CC_CTHL_bCLFirst_Step=0;  
        CC_CTHL_ZhuangLiaoStep=0;
      //  CC_CTHL_XKTD_VAVLE = 0; 
        cQDXK_DXK=0;
     //   CC_CTHL_XKDW_VAVLE =0;
       
        if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
        {
           SetClr(Y_AXIS, MOTOR_NOALARM);
            SetClr(X_AXIS, MOTOR_NOALARM);
         CC_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
        }
        if(GetAlarmCode(CC_CTHL_ALARM_ADDR) != 0)
           SetAlarmCode(CC_CTHL_ALARM_ADDR,0);    
        
      }
      else if(!bRunning)
      {
         bRunning=0;
          cXcxcrCnt=0;
          cStopMode=0;
              cCHULIANBAOJIN=0;
            cXCXQXQD=0;
          cWULATOUCnt=0;
          bCL_EN_FLG=0;
            bSingOneFlg=0;
         AxisEgmStop(X_AXIS);
          AxisEgmStop(Y_AXIS);
          (X_AXIS, MOTOR_DISEN);
         SetEn(Y_AXIS, MOTOR_DISEN);
          cStopMode=0;
          cQDXK_DXK=0;
        
       if(GetAlarm(Y_AXIS)==0 || GetAlarm(X_AXIS)==0)
        {
           SetClr(Y_AXIS, MOTOR_NOALARM);
            SetClr(X_AXIS, MOTOR_NOALARM);
         CC_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
        }
          CC_CTHL_TLiao_VAVLE=0;             
         CC_CTHL_HSLiao_VAVLE  =0;    
         CC_CTHL_JLTou_VAVLE  =0;     
         CC_CTHL_XKTD_VAVLE  =0;        
         CC_CTHL_XKDW_VAVLE  =0;       
         CC_CTHL_DXK_VAVLE  =0;         
         CC_CTHL_CXCC_VAVLE  =0;         
         CC_CTHL_CTXM_VAVLE =0;         
         CC_CTHL_First_CT_VAVLE =0;     
         CC_CTHL_FKGD_VAVLE =0;         
         CC_CTHL_CXQJD_VAVLE =0;        
         CC_CTHL_CXDWZ_VAVLE  =0;       
         CC_CTHL_CXHJD_VAVLE =0;        
         CC_CTHL_CXHDW_VAVLE =0;        
         CC_CTHL_FKJD_VAVLE  =0;        
         CC_CTHL_HLJJ_VAVLE  =0;                       
         CC_CTHL_CXSCDW_VAVLE =0;
         CC_CTHL_MGuo_VAVLE =0;
         CC_CTHL_QDXK_VAVLE=0;
             CC_CTHL_LTJJ_VAVLE  =0;
         CC_CTHL_AutoStep = 0;
         CC_CTHL_ZhuangLiaoStep=0;
         CC_CTHL_TLiaoStep=0;
         CC_CTHL_TD_MotorStep=0;
         CC_CTHL_JiaLianStep  =0;        
         CC_CTHL_SongLiaoStep   =0;     
         CC_CTHL_CL_MotorStep =0;      
         CC_CTHL_AutoStep1  =0;
         CC_CTHL_bFKCXTDDW_Step=0;
         CC_CTHL_bCXCR_Step=0;
         CC_CTHL_bCLFirst_Step=0;
         if(GetAlarmCode(CC_CTHL_ALARM_ADDR) != 0)
            SetAlarmCode(CC_CTHL_ALARM_ADDR,0);  
          SetPos(X_AXIS, 0); 

        CC_CTHL_TLiaoStep = 0; 
        CC_CTHL_AutoStep = 0;
        
        //穿合链电机是往零点方向时可以停止
        if(GetDir(Y_AXIS) == DIR_N)
            AxisEgmStop(Y_AXIS);

      }
      bStop=0;
    }
     
   if(bAlarmStop)
    {   
      bRunning   = 0;
      bAlarmStop=0;
      cStopMode=0;
      cXcxcrCnt=0;
      AxisEgmStop(X_AXIS);
      AxisEgmStop(Y_AXIS);
      CC_CTHL_AutoStep = 0; 
      cQDXK_DXK=0;
      CC_CTHL_CL_MotorStep =0;      
      CC_CTHL_bCLFirst_Step=0;  
     // CC_CTHL_SongLiaoStep =0;
      CC_CTHL_ZhuangLiaoStep=0;
       
    }
}   

//拖带电机控制动作  X轴
void CC_CTHL_TD_Motor(void)	 //
{   
#if 1
     switch(CC_CTHL_TD_MotorStep)
	{
        //1步开始，纯定位, 没有穿入
        case 1:
            if(dwTickCount >= CC_CTHL_TD_MotorDelay)  //给锁轴时间
            {
                bCheckEN_FLG = 1;
               // CC_CTHL_SongDai_VAVLE=0;
                 CC_CTHL_SongDai_VAVLE=0;
                CC_CTHL_CheckInX02PosBuff= 0;
                 CC_CTHL_TD_MotorStep = 2;   
                 SetPos(X_AXIS, 0);  //启动位置设为0点
                 AxisContinueMoveAcc(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed*2/3,DIR_P,800,600,15,15);
                 CC_CTHL_X_CXPosBuff=0;
            }  
            break;
        case 2://检测到过链
            if(dwXRealPos > 400)    //穿入2CM后退
            {
                if(CC_CTHL_PARAM_NLSL_MODE)
                  {
                    CC_CTHL_XKTD_VAVLE=0;
                  }
                CC_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关  
                CC_CTHL_QDXK_VAVLE = 0;
            }    
            if(dwXRealPos >= CC_CTHL_PARAM_WLCDSHEZHI_LENTH)
            {
              CC_CTHL_SetAlarmCode(CC_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机              
            }
            if(CC_CTHL_FK_Check)
            {
               CC_CTHL_SongDai_VAVLE=1;
                CC_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
                CC_CTHL_QDXK_VAVLE = 0;
                CC_CTHL_XSavePosBuff = dwXRealPos;
                CC_CTHL_TD_MotorStep = 3;  
                user_datas[123] = dwXRealPos - CC_CTHL_CheckInX02PosBuff;
                if((dwXRealPos >= CC_CTHL_CheckInX02PosBuff) && CC_CTHL_CheckInX02PosBuff)
                    AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed*2/3,CC_CTHL_PARAM_FKDW_Length - (dwXRealPos- CC_CTHL_CheckInX02PosBuff)-160,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,250,50); 
                else
                    AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed*2/3,CC_CTHL_PARAM_FKDW_Length-120,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,250,50); 
            }
            break;
        case 3:    
            if(CC_CTHL_CXSC_Limit_IN_UP)
            {
                CC_CTHL_X_CXPosBuff = dwXRealPos;
                
            }  
           
             if(!X_DRV || (dwXRealPos >= (CC_CTHL_XSavePosBuff + CC_CTHL_PARAM_FKDW_Length)))
            {
                AxisEgmStop(X_AXIS);
               CC_CTHL_TD_MotorStep =4 ; 
               CC_CTHL_LianLengthAutoCheck = dwXRealPos;
            }
             break;
        case 4:
          if(CC_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
            {
                   
                  if ((dwXRealPos - CC_CTHL_X_CXPosBuff) > (CC_CTHL_PARAM_XCX_LENTH + CC_CTHL_PARAM_XCXWC_LENTH)) 
                  {
//                    user_datas[121] = 1;
                      CC_CTHL_TD_MotorStep = 0;
                      CC_CTHL_SetAlarmCode(CC_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            
                  }         

                   else if(CC_CTHL_X_CXPosBuff == 0)
                   {
  //                    user_datas[121] = 3;
                       CC_CTHL_TD_MotorStep = 0;
                         CC_CTHL_SetAlarmCode(CC_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }   
                   else
                   {
                     CC_CTHL_TD_MotorStep = 0;
                     CC_CTHL_X_CXPosBuff=dwXRealPos;
                     
                    }

            }
            else
            {
                CC_CTHL_TD_MotorStep = 0;
           //     CC_CTHL_X_CXPosBuff=dwXRealPos;
            }
          break;
        case 9:
           if(dwTickCount >= CC_CTHL_TD_MotorDelay)
            {
            CC_CTHL_TD_MotorStep = 10;
            CC_CTHL_TD_MotorDelay=dwTickCount+500;
             SetEn(X_AXIS, MOTOR_EN);
            
            }
          break;
            //穿拉头定位
        case 10:   
            if(dwTickCount >= CC_CTHL_TD_MotorDelay)
            {
              CC_CTHL_SongDai_VAVLE=0;
                CC_CTHL_TD_MotorStep = 11;
                SetPos(X_AXIS, 0);  //启动位置设为0点
                dwXRealPos = 0;
                AxisContinueMoveAcc(X_AXIS,CC_CTHL_PARAM_TDCR_LowSpeed,DIR_P,1200,1200,15,15);   
                CC_CTHL_CheckInX02PosBuff= 0;
                CC_CTHL_X_CXPosBuff=0;
                bCheckEN_FLG = 1;
            }
            break;
        case 11:  
      if(dwXRealPos > 350)    //穿入2CM后退
        {
           if(CC_CTHL_PARAM_NLSL_MODE)
                  {
                    CC_CTHL_XKTD_VAVLE=0;
                  }
          CC_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            CC_CTHL_QDXK_VAVLE =0;
        }
            if(dwXRealPos > CC_CTHL_PARAM_TDCR_LowSpeedLength)    //穿入2CM后退
            {
               CC_CTHL_KALATOU_VAVLE=0;
                CC_CTHL_CheckInX02PosBuff= 0;
                CC_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
                 CC_CTHL_QDXK_VAVLE = 0;
                  if(CC_CTHL_PARAM_NLSL_MODE)
                  {
                    CC_CTHL_XKTD_VAVLE=0;
                  }
                CC_CTHL_TD_MotorStep = 12;
                if((cZipCnt < 2) || (CC_CTHL_LianLengthCheck < CC_CTHL_PARAM_TDCR_LowSpeedLength))
                    AxisContinueMoveAcc(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed*2/3,DIR_P,3000,600,10,10); 
                else ////两段速度移动距离                
                {  
 
                      AxisMovePosAccDecNotStop(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed ,CC_CTHL_LianLengthCheck-(CC_CTHL_PARAM_TDCR_LowSpeedLength),1500,7000,30,300,250); 

                }
            }
            
             if(CC_CTHL_FK_Check)    //在这里检测到说明速度还没有起来
            {
            //   CC_CTHL_SongDai_VAVLE=1;
               CC_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
                 CC_CTHL_QDXK_VAVLE = 0;
                  if(CC_CTHL_PARAM_NLSL_MODE)
                  {
                    CC_CTHL_XKTD_VAVLE=0;
                  }
                CC_CTHL_TD_MotorDelay= dwTickCount + CC_CTHL_PARAM_FKJDSECONG_DEALY;
                CC_CTHL_LianLengthReal = dwXRealPos;
 
                CC_CTHL_XSavePosBuff = dwXRealPos;
                CC_CTHL_TD_MotorStep = 13;  
           //     user_datas[122] = CC_CTHL_PARAM_FKDW_Length - (dwXRealPos- CC_CTHL_CheckInX02PosBuff);
                
               if((dwXRealPos >= CC_CTHL_CheckInX02PosBuff) && CC_CTHL_CheckInX02PosBuff)
                   AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed,CC_CTHL_PARAM_FKDW_Length - (dwXRealPos- CC_CTHL_CheckInX02PosBuff),
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,250,40); 
                else
                    AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed,CC_CTHL_PARAM_FKDW_Length,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,250,40); 
                 //CC_CTHL_TD_MotorStep = 0;  
            }
               else if(CC_CTHL_CXSC_Limit_IN_DW)
               {
                     AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed * 2/3,CC_CTHL_PARAM_FKDW_Length,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,250,50); 
            
               }
             else if(CC_CTHL_CXSC_Limit_IN_UP)
               {
                   CC_CTHL_SetAlarmCode(CC_CTHL_DK_ERROR_ALARM,bRunning);
               }
            break;
        case 12://检测到过链  

          if(cZipCnt<2)
          { 
            if(dwXRealPos >= CC_CTHL_PARAM_WLCDSHEZHI_LENTH)
            {
                if(bRunning)
                {
                    cCHULIANBAOJIN=1;
                    SetEn(X_AXIS, MOTOR_DISEN);
                    AxisEgmStop(X_AXIS);
                    SetPos(X_AXIS, 0);  //启动位置设为0点
            //     dwXRealPos=0;
                }
                CC_CTHL_SetAlarmCode(CC_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机             
            }
          }
          else
          {
            if(dwXRealPos >= CC_CTHL_LianLengthAutoCheckERROR + CC_CTHL_PARAM_WUCD_LENTH)
            {
                if(bRunning)
                {
                  cCHULIANBAOJIN=1;
                  SetEn(X_AXIS, MOTOR_DISEN);
                  AxisEgmStop(X_AXIS);
                  SetPos(X_AXIS, 0);  //启动位置设为0点
          //     dwXRealPos=0;
                }
                CC_CTHL_SetAlarmCode(CC_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机             
            }
          
          }
            if(CC_CTHL_FK_Check)
            {
                 CC_CTHL_SongDai_VAVLE=1;
                CC_CTHL_TD_MotorDelay= dwTickCount + CC_CTHL_PARAM_FKJDSECONG_DEALY;
                CC_CTHL_LianLengthReal = dwXRealPos;
                //if(cZipCnt == 1)
                 //   user_datas[122] = dwXRealPos;
 //               user_datas[121] = dwXRealPos;
                if((cZipCnt == 1)  || dwXRealPos < (CC_CTHL_LianLengthCheck*0.85) || dwXRealPos>(CC_CTHL_LianLengthCheck*1.3))
                    CC_CTHL_LianLengthCheck = dwXRealPos;
                
                CC_CTHL_LianLengthCheckOLD=CC_CTHL_LianLengthNEWCheck;
                CC_CTHL_LianLengthNEWCheck  = dwXRealPos; 
                //break;
                CC_CTHL_XSavePosBuff = dwXRealPos;
                CC_CTHL_TD_MotorStep = 13;  
           //     user_datas[122] = CC_CTHL_PARAM_FKDW_Length - (dwXRealPos- CC_CTHL_CheckInX02PosBuff);
               if(cZipCnt > 1 )
               {
               if((dwXRealPos >= CC_CTHL_CheckInX02PosBuff) && CC_CTHL_CheckInX02PosBuff)
                   AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed,CC_CTHL_PARAM_FKDW_Length - (dwXRealPos- CC_CTHL_CheckInX02PosBuff),
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,300,50); 
                else
                    AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed,CC_CTHL_PARAM_FKDW_Length,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,300,50); 
               }
               else
               {
               
                 AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed,CC_CTHL_PARAM_first_length,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,30,300,50); 
               }
                 //CC_CTHL_TD_MotorStep = 0;  
            }
            else if(CC_CTHL_CXSC_Limit_IN_DW)
               {
                      AxisMovePosAccDec(X_AXIS,CC_CTHL_PARAM_TD_RunSpeed * 2/3,CC_CTHL_PARAM_FKDW_Length,
                                  CC_CTHL_PARAM_FKDW_Speed,CC_CTHL_PARAM_FKDW_Speed,10,150,50); 
             
               }
            else if(CC_CTHL_CXSC_Limit_IN_UP)
                 {
                 CC_CTHL_SetAlarmCode(CC_CTHL_DK_ERROR_ALARM,bRunning);
               }
         if(CC_CTHL_CXSC_Limit_IN_UP)
          {
            cXCGYcheck=1;
          CC_CTHL_LianLengthXC_Check=dwXRealPos;
         //  SetPos(Y_AXIS, 0);  //启动位置设为0点
          }
            break;   
        case 13:
          if(CC_CTHL_CXSC_Limit_IN_UP)
          {
            cXCGYcheck=1;
          CC_CTHL_LianLengthXC_Check=dwXRealPos;
         //  SetPos(Y_AXIS, 0);  //启动位置设为0点
          }
           if(dwTickCount >= CC_CTHL_TD_MotorDelay)
            {
                CC_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            
            }
            if(CC_CTHL_CXSC_Limit_IN_UP)
            {
                CC_CTHL_X_CXPosBuff = dwXRealPos;
             
            }  
            if((!X_DRV ))// || (dwXRealPos >= (CC_CTHL_XSavePosBuff + CC_CTHL_PARAM_FKDW_Length)))
            {
               // user_datas[123] = dwXRealPos-CC_CTHL_CheckInX02PosBuff;
                CC_CTHL_LianLengthBCLENGTH_Check=dwXRealPos-CC_CTHL_LianLengthXC_Check;
                AxisEgmStop(X_AXIS);
                CC_CTHL_TD_MotorStep = 14; 
       /*       if(cZipCnt>2)
                {
                 if(((CC_CTHL_LianLengthNEWCheck+CC_CTHL_LianLengthCheckOLD)*0.5) < (CC_CTHL_LianLengthCheck*0.95))
                 {
                   cZipCnt=0;  
                   cHeLian=1;
                 }
                }*/
                if(cZipCnt==1)
                    CC_CTHL_LianLengthAutoCheckERROR = dwXRealPos;
                
                if(cZipCnt==1)
                 CC_CTHL_LianLengSave=dwXRealPos;

                CC_CTHL_LianLengthAutoCheck = dwXRealPos;
                user_datas[122] = dwXRealPos-CC_CTHL_X_CXPosBuff;
            }
            break;
        case 14:
          
       if(CC_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
            {
               
                  if ((dwXRealPos - CC_CTHL_X_CXPosBuff) > (CC_CTHL_PARAM_XCX_LENTH + CC_CTHL_PARAM_XCXWC_LENTH)) 
                  {
                  //  user_datas[121] = 1;
                      CC_CTHL_TD_MotorStep = 0;
                      cXCXQXQD=1;
                      CC_CTHL_SetAlarmCode(CC_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            
                  }         
                  else if((dwXRealPos - CC_CTHL_X_CXPosBuff) < (CC_CTHL_PARAM_XCX_LENTH - CC_CTHL_PARAM_XCXWC_LENTH))
                 {
                   //   user_datas[121] = 2;
                     CC_CTHL_TD_MotorStep = 0;
                      cXCXQXQD=1;
                      CC_CTHL_SetAlarmCode(CC_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }    
                   else if(CC_CTHL_X_CXPosBuff == 0)
                   {
                  //    user_datas[121] = 3;
                       CC_CTHL_TD_MotorStep = 0;
                        cXCXQXQD=1;
                         CC_CTHL_SetAlarmCode(CC_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                   }   
                   else
                   {
                  
                     CC_CTHL_TD_MotorStep = 15;
                    }

            }
            else
            {
       
                CC_CTHL_TD_MotorStep = 15;
            }
          break;
        case 15:
  //          if(CC_CTHL_START_IN_UP)
                CC_CTHL_TD_MotorStep = 0;
          
          
	}   
#endif    
}
//穿入电机动作，Y轴
void CC_CTHL_CL_Motor(void)	 //
{   
#if 0
    //1步开始,  穿链长度开始
  //20步开始  插销定位开始
  //40步,回原点为
    switch(CC_CTHL_CL_MotorStep)
	{
         //穿入长度位置
         case 1:
            
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
              // SetDir(Y_AXIS, DIR_P);
                if(CC_CTHL_PARAM_CL_Length >= CC_CTHL_PARAM_CL_MAX_Length)
                    CC_CTHL_PARAM_CL_Length = CC_CTHL_PARAM_CL_MAX_Length;
                //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
                if((CC_CTHL_LianLengthAutoCheck < (CC_CTHL_PARAM_CL_Length + 500 )) && bRunning) 
                    AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,(CC_CTHL_LianLengthAutoCheck-500),800,600,6,6,50);       
                else
                    AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,(CC_CTHL_PARAM_CL_Length-100),800,600,6,6,50); 
                CC_CTHL_CL_MotorStep = 2; 
            }
            break;
        case 2:
            if((dwYRealPos + 120) > CC_CTHL_PARAM_CL_Length)
                CC_CTHL_HLJJ_VAVLE = 0;
            if(!Y_DRV || dwYRealPos >= CC_CTHL_PARAM_CL_Length)  
            {
                CC_CTHL_HLJJ_VAVLE = 0;
               CC_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
               CC_CTHL_CL_MotorDelay = dwTickCount + 40;  //延时数控回零点
            }
            break; 
        case 3: 
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 50;  
            }
            break;
          //夹带插销到穿入位置  
        case 20: //此处最好算好定位长度相减
            if(cXcxcrCnt > 0)
            {
             CC_CTHL_LENTH = CC_CTHL_PARAM_CXDW_Length + 30; 
             CC_CTHL_CL_MotorStep = 21;
            }
            else
            {
            CC_CTHL_LENTH = CC_CTHL_PARAM_CXDW_Length ;
            CC_CTHL_CL_MotorStep = 21;
            }         
            break;
        case 21:
              SetDir(Y_AXIS, DIR_P);
              AxisMovePosAccDec(Y_AXIS,8000,CC_CTHL_LENTH,800,500,6,6,50);            
              CC_CTHL_CL_MotorStep = 22; 
            break;
        case 22: 
            if(!Y_DRV || (dwYRealPos >= CC_CTHL_LENTH)) //插销定位已经结束
            {
                AxisEgmStop(Y_AXIS);
                CC_CTHL_YsaveCXDWPosBuff = 0;
                CC_CTHL_CL_MotorStep = 0;                       
            } 
            break;
          //回原点开始
        case 40: 
          //要先离开    
            if(CC_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
            {
                CC_CTHL_CL_MotorStep = 41; 
                SetDir(Y_AXIS, DIR_P);
            }    
            else  
            {
                SetDir(Y_AXIS, DIR_N);
                CC_CTHL_CL_MotorStep = 46;
                
            }    
            if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                CC_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            }
            else  //已经锁轴
                CC_CTHL_CL_MotorDelay = dwTickCount + 5;            
            break;
        case 41:
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 42; 
                AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
            }
            break;
        case 42:
            if(!CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 43; 
                CC_CTHL_YSavePosBuff = dwYRealPos;
            }
            break;
        case 43:    
            //离开原点5CM停止
            if((dwYRealPos - CC_CTHL_YSavePosBuff) >= 800)
            {
                AxisEgmStop(Y_AXIS);
                CC_CTHL_CL_MotorStep = 46; //留空几步备用
                CC_CTHL_CL_MotorDelay = dwTickCount + 50;  
            }
            break;
        case 46:  
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 47; //检测回到原位
                if(!CC_CTHL_SF_Origin_IN)
                    AxisContinueMoveAcc(Y_AXIS,1500,DIR_N,1000,800,15,10);
            }
            break;
        case 47: 
           if(CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
            }    
          break;
         //数控回原位 (条件为自动工作，SON一直没有松开)  
        case 50: 
            if(dwYRealPos > 150)
            {  //回零速度
               SetDir(Y_AXIS, DIR_N);
                AxisMovePosAccDecNotStop(Y_AXIS,CC_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos + 150,5000,2000,10,50,50);
             
                    
            } 
            else
                AxisContinueMoveAcc(Y_AXIS,1000,DIR_N,1000,1000,15,15);
            CC_CTHL_CL_MotorStep = 51; 
            break;
        case 51: 
            if(CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
            } 
            break;
                 
	}
#endif

#if 1
    //1步开始,  穿链长度开始
  //20步开始  插销定位开始
  //40步,回原点为
    switch(CC_CTHL_CL_MotorStep)
	{
         //穿入长度位置
         case 1:     
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
              if(CC_CTHL_SF_Origin_IN)
              {
               if(!CC_CTHL_PARAM_AUTO_MODE) 
               {
                //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
                if(CC_CTHL_LianLengthAutoCheck <= 700)
                    {
                        CC_CTHL_Y_CL_Length=CC_CTHL_LianLengthAutoCheck-200;
                       if(CC_CTHL_Y_CL_Length<10)
                         CC_CTHL_Y_CL_Length=200;
                        if(CC_CTHL_Y_CL_Length >= CC_CTHL_PARAM_CL_MAX_Length)
                          CC_CTHL_Y_CL_Length = CC_CTHL_PARAM_CL_MAX_Length-40;  
                    AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,CC_CTHL_Y_CL_Length,800,600,6,6,50);     
                }
                else if(CC_CTHL_LianLengthAutoCheck>700)
                {
                  
                   user_datas[123] =CC_CTHL_LianLengthAutoCheck;
                        if(cZipCnt>1)
                           CC_CTHL_Y_CL_Length=CC_CTHL_LianLengSave-CC_CTHL_PARAM_HLTSY_LENTH-300;
                        else
                        {
                          if(cZipCnt<1)
                             CC_CTHL_Y_CL_Length=CC_CTHL_LianLengthAutoCheck-CC_CTHL_PARAM_HLTSY_LENTH-100;
                          else
                             CC_CTHL_Y_CL_Length=CC_CTHL_LianLengthAutoCheck-CC_CTHL_PARAM_HLTSY_LENTH-300; 
                        }
                   if(cZipCnt>1)
                   {
                      if(CC_CTHL_LianLengthAutoCheck<(CC_CTHL_LianLengSave*0.7))
                      {
                           CC_CTHL_Y_CL_Length=CC_CTHL_LianLengthAutoCheck-CC_CTHL_PARAM_HLTSY_LENTH-300;
                           cZipCnt=0;
                      }
                   }
                       if(CC_CTHL_Y_CL_Length<200)
                         CC_CTHL_Y_CL_Length=200;   
                        if(CC_CTHL_Y_CL_Length >= CC_CTHL_PARAM_CL_MAX_Length)
                          CC_CTHL_Y_CL_Length = CC_CTHL_PARAM_CL_MAX_Length-40;  
                    AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,CC_CTHL_Y_CL_Length,800,600,6,6,50); 
                
                }
               
               }
               
              else
              {
                  if(CC_CTHL_PARAM_CL_Length >= CC_CTHL_PARAM_CL_MAX_Length)
                        CC_CTHL_PARAM_CL_Length = CC_CTHL_PARAM_CL_MAX_Length;
                    //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
                    if((CC_CTHL_LianLengthAutoCheck < (CC_CTHL_PARAM_CL_Length + 500 )) && bRunning) 
                        AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,(CC_CTHL_LianLengthAutoCheck-500),800,600,6,6,50);       
                    else
                        AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_CL_Speed,(CC_CTHL_PARAM_CL_Length-100),800,600,6,6,50); 
                        
              }
                CC_CTHL_CL_MotorStep = 2; 
              }
            }
            break;
        case 2:
          if(CC_CTHL_PARAM_AUTO_MODE)
          {
            if((dwYRealPos + 120) > CC_CTHL_PARAM_CL_Length)
                CC_CTHL_HLJJ_VAVLE = 0;
            if(!Y_DRV || dwYRealPos >= CC_CTHL_PARAM_CL_Length)  
            {
                CC_CTHL_HLJJ_VAVLE = 0;
               CC_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
               CC_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
            }
          }
          else
          {
          if((dwYRealPos + 120) > CC_CTHL_Y_CL_Length)
                CC_CTHL_HLJJ_VAVLE = 0;
            if(!Y_DRV || dwYRealPos >= CC_CTHL_Y_CL_Length)  
            {
                CC_CTHL_HLJJ_VAVLE = 0;
               CC_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
               CC_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
            }
          
          }
            break; 
        case 3: 
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 50;  
            }
            break;
          //夹带插销到穿入位置  
        case 20: //此处最好算好定位长度相减
         
      
           if(!CC_CTHL_PARAM_XCXJY_MODE)
            {
            if(cXcxcrCnt > 0)
            {
              if(cXcxcrCnt==1)
               CC_CTHL_LENTH = CC_CTHL_PARAM_CXDW_Length+CC_CTHL_PARAM_TDFZ_LENTH + 50; 
              if(cXcxcrCnt>1)
                CC_CTHL_LENTH = CC_CTHL_PARAM_CXDW_Length +CC_CTHL_PARAM_TDFZ_LENTH + 120;
             CC_CTHL_CL_MotorStep = 21;
            }
            else
            {
            CC_CTHL_LENTH = CC_CTHL_PARAM_CXDW_Length ;
            CC_CTHL_CL_MotorStep = 21;
            }  
        }
            else
          {
             dwYRealPos=0;
            CC_CTHL_LianLengthERROR_Check=dwYRealPos; 
            AxisContinueMoveAcc(Y_AXIS,CC_CTHL_PARAM_XCLACHU_SPEED,DIR_P,1200,1200,5,30);   
            CC_CTHL_CL_MotorStep = 21; 

          
          }
            break;
        case 21:
           if(!CC_CTHL_PARAM_XCXJY_MODE)
            {
              SetDir(Y_AXIS, DIR_P);
              CC_CTHL_Y_CL_PosBuff = dwYRealPos;
              AxisMovePosAccDec(Y_AXIS,CC_CTHL_PARAM_XCLACHU_SPEED,CC_CTHL_LENTH,800,500,6,6,50);            
              CC_CTHL_CL_MotorStep = 22; 
           }
           else
         {
               if(CC_CTHL_CXSC_Limit_IN_UP || cXcxcrCnt>0)
              {
              CC_CTHL_LianLengthXC_Check=dwYRealPos;
              CC_CTHL_CL_MotorStep = 22;
              }
              else if(dwYRealPos> (CC_CTHL_LianLengthERROR_Check+200) )
             {
                cXCGYcheck=0;
                AxisEgmStop(Y_AXIS);
            //    user_datas[128] = dwYRealPos;  
                CC_CTHL_CL_MotorStep = 0;
                CC_CTHL_LianLengthXC_Check=0;
                SetPos(Y_AXIS, 0);  //启动位置设为0点
             }  
            
            
             
         }
            break;
        case 22: 
          if(!CC_CTHL_PARAM_XCXJY_MODE)
          {
            if(dwYRealPos >= CC_CTHL_Y_CL_PosBuff+CC_CTHL_LENTH-CC_CTHL_PARAM_CXDW_Length) //插销定位已经结束
            {
              CC_CTHL_CXSCDW_VAVLE = 1;                     
            }
          
          if(!Y_DRV || (dwYRealPos >= CC_CTHL_Y_CL_PosBuff+CC_CTHL_LENTH)) //插销定位已经结束
            {
                AxisEgmStop(Y_AXIS);
                CC_CTHL_YsaveCXDWPosBuff = 0;
                CC_CTHL_CL_MotorStep = 0;                       
            } 
        }
    else
    {
      if(cXcxcrCnt==0)
         CC_CTHL_LENTH=CC_CTHL_PARAM_CXDW_Length;
      else
         CC_CTHL_LENTH=CC_CTHL_PARAM_CXDW_Length+200;
             if(dwYRealPos>(CC_CTHL_LianLengthXC_Check+CC_CTHL_LENTH))
             {
            // user_datas[128] = dwYRealPos;  
                cXCGYcheck=0;
                AxisEgmStop(Y_AXIS);
                CC_CTHL_CL_MotorStep = 0;
                CC_CTHL_LianLengthXC_Check=0;
                SetPos(Y_AXIS, 0);  //启动位置设为0点
             
               }
              else if(dwYRealPos> (CC_CTHL_LianLengthERROR_Check+200))
              {
              
               cXCGYcheck=0;
           //    user_datas[128] = dwYRealPos;  
                AxisEgmStop(Y_AXIS);
                CC_CTHL_CL_MotorStep = 0;
                CC_CTHL_LianLengthXC_Check=0;
               SetPos(Y_AXIS, 0);  //启动位置设为0点
              }
    }
            break;
        case 30:
                    CC_CTHL_YsaveCXDWPosBuff = 0;
                    CC_CTHL_CL_MotorStep = 0;  
            break;
          //回原点开始
        case 40: 
          //要先离开    
            if(CC_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
            {
                CC_CTHL_CL_MotorStep = 41; 
                SetDir(Y_AXIS, DIR_P);
            }    
            else  
            {
                SetDir(Y_AXIS, DIR_N);
                CC_CTHL_CL_MotorStep = 46;
                
            }    
            if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                CC_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            }
            else  //已经锁轴
                CC_CTHL_CL_MotorDelay = dwTickCount + 5;            
            break;
        case 41:
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 42; 
                AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
            }
            break;
        case 42:
            if(!CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 43; 
                CC_CTHL_YSavePosBuff = dwYRealPos;
            }
            break;
        case 43:    
            //离开原点5CM停止
            if((dwYRealPos - CC_CTHL_YSavePosBuff) >= 800)
            {
                AxisEgmStop(Y_AXIS);
                CC_CTHL_CL_MotorStep = 46; //留空几步备用
                CC_CTHL_CL_MotorDelay = dwTickCount + 50;  
            }
            break;
        case 46:  
            if(dwTickCount >= CC_CTHL_CL_MotorDelay)
            {
                CC_CTHL_CL_MotorStep = 47; //检测回到原位
                if(!CC_CTHL_SF_Origin_IN)
                    AxisContinueMoveAcc(Y_AXIS,1500,DIR_N,1000,800,15,10);
            }
            break;
        case 47: 
           if(CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
            }    
          break;
         //数控回原位 (条件为自动工作，SON一直没有松开)  
        case 50: 
            if(dwYRealPos > 151)
            {  //回零速度
              
              SetDir(Y_AXIS, DIR_N);
               AxisMovePosAccDecNotStop(Y_AXIS,CC_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos + 150,5000,2500,30,200,00);
                  } 
             else
                AxisContinueMoveAcc(Y_AXIS,1000,DIR_N,1000,1000,15,15);
            CC_CTHL_CL_MotorStep = 51; 
            break;
        case 51: 
            if(CC_CTHL_SF_Origin_IN)
            {
                CC_CTHL_CL_MotorStep = 0;       
                AxisEgmStop(Y_AXIS); 
                SetPos(Y_AXIS, 0);
            } 
            break;
                 
	}
#endif      
}



//装拉头动作
void CC_CTHL_ZLT_Step(void)
{

    switch(CC_CTHL_ZhuangLiaoStep)
    {
        case 1:
          
             if(bZhuangLiaoOkFlg)
             {
                  CC_CTHL_ZhuangLiaoStep = 0;
             }
             else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
             {
                
                   if(((CC_CTHL_MGuo_VAVLE && CC_CTHL_LTou_Check) || (!CC_CTHL_MGuo_VAVLE)) && !CC_CTHL_JLiao_Limit_IN  )//说明没有拉头
                   {       
                          //穿头模和一次穿入必须在原位,接料不能有输出
                          if(CC_CTHL_CTM_Origin_IN && !CC_CTHL_CTXM_VAVLE)
                          {  
                              CC_CTHL_First_CT_VAVLE = 0;
                               CC_CTHL_JLTou_VAVLE = 0;
                              CC_CTHL_MGuo_VAVLE = 0;                     
                              if(CC_CTHL_TLiaoStep == 0)
                              {
                                 CC_CTHL_TLiaoStep = 1;        
                               CC_CTHL_ZhuangLiaoStep = 2; 
                              }
                           }
                      
                        else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay + 500)  //警告横送拉必须保证穿头模和一次穿入在原位,接料不能有输出
                        {
                          CC_CTHL_SetAlarmCode(CC_CTHL_CTM_Origin_ALARM,bRunning);
                            
                        }  
                   }
                   else  //已经有拉头直接跳到结束
                   {
                         CC_CTHL_ZhuangLiaoDelay = dwTickCount + 40;
                         CC_CTHL_ZhuangLiaoStep = 9;
                   }  
             }
             break;            
        case 2:        
            if(CC_CTHL_TLiaoStep == 0)  //推料已经完成
            {
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                CC_CTHL_JLTou_VAVLE = 0;
                CC_CTHL_MGuo_VAVLE = 0;   
                if(!CC_CTHL_JLiao_Limit_IN && CC_CTHL_First_CT_Origin_IN)
                {
                    CC_CTHL_ZhuangLiaoStep = 3;
                    CC_CTHL_HSLiao_VAVLE = 1; 
                    
                  if(CC_CTHL_PARAM_LTJJ_MODE)
                    {
                    CC_CTHL_LTJJ_VAVLE=1;
                    }
                  else
                    CC_CTHL_LTJJ_VAVLE=0;
                     
                }
            }
            break;
        case 3:
            //横送到位
            if(CC_CTHL_HSLiao_Limit_IN && !CC_CTHL_HSLiao_Origin_IN)
            {
                CC_CTHL_ZhuangLiaoStep = 4;
//                CC_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + 5;
            }
            else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                CC_CTHL_SetAlarmCode(CC_CTHL_HSLiao_Limit_ALARM,bRunning);
            }
            break;
        case 4:
            if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                CC_CTHL_ZhuangLiaoStep = 5;
                CC_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
            }  
            break;
        case 5:    
            if(CC_CTHL_JLiao_Limit_IN)
            {
                CC_CTHL_LTJJ_VAVLE=0;
                CC_CTHL_ZhuangLiaoStep = 6;
                if(CC_CTHL_PARAM_LTJJ_MODE)
                {
                  CC_CTHL_ZhuangLiaoDelay = dwTickCount + CC_CTHL_PARAM_MaGou_DELAY+30;
                }
                else
                {
                  CC_CTHL_ZhuangLiaoDelay = dwTickCount + CC_CTHL_PARAM_MaGou_DELAY;
                }
            }
            else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)  //接拉头(接料)到们信号异常
            {
                 CC_CTHL_SetAlarmCode(CC_CTHL_JLiao_Limit_ALARM,bRunning);
            }
            break;
        case 6:       
            if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)  //延时码勾
            {
              if(!CC_CTHL_PARAM_LTJJ_MODE || CC_CTHL_LTJJ_Origin_IN) 
              {
                CC_CTHL_MGuo_VAVLE = 1; //码勾输出
                CC_CTHL_ZhuangLiaoStep = 7;
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + CC_CTHL_PARAM_HSLiaoOff_DELAY;
                bTuiLaTouOkFlg = 0;  
              }
              else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay+3000)
              {
               CC_CTHL_SetAlarmCode(CC_CTHL_XMKH_Origin_ALARM,bRunning);
              }
            }
            break;
        case 7:  
            if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                CC_CTHL_HSLiao_VAVLE = 0; 
                CC_CTHL_ZhuangLiaoStep = 8;
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
            }
            break;
        case 8:  
            if(!CC_CTHL_HSLiao_Limit_IN)  //
            {
                CC_CTHL_ZhuangLiaoStep = 9;
                CC_CTHL_TLiaoStep = 1; //推拉头
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + CC_CTHL_PARAM_CheckLT_DELAY;   //也是给下模能上升的时间
            }          
            else if (CC_CTHL_LTou_Check)  //时间内信号这说明没有拉头
            {
                //重送3次
               CC_CTHL_TryCnt++;
               CC_CTHL_JLTou_VAVLE = 0;    //接拉头关
                CC_CTHL_MGuo_VAVLE = 0;     //码勾打开
                if(CC_CTHL_TryCnt >= CC_CTHL_PARAM_SLT_NUMBER)
                {
                    CC_CTHL_TryCnt = 0;
                    bZhuangLiaoOkFlg = 0;
                    CC_CTHL_ZhuangLiaoStep = 0;
                    CC_CTHL_SetAlarmCode(CC_CTHL_ZLT_ALARM,bRunning);
                    cWULATOUCnt=1;
                }
                else
                {
                    CC_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                    CC_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                }  
            }
            else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                CC_CTHL_SetAlarmCode(CC_CTHL_HSLiao_Limit_ALARM,bRunning);
                if(bRunning)
                {
                    CC_CTHL_ZhuangLiaoStep = 0 ;
                }  
            }  
            break;
        case 9:   
            if(CC_CTHL_LTou_Check)  //时间内信号这说明没有拉头
            {
                CC_CTHL_TryCnt++;
                CC_CTHL_JLTou_VAVLE = 0;    //接拉头关
                CC_CTHL_MGuo_VAVLE = 0;     //码勾打开
                if(CC_CTHL_TryCnt >= 3)
                {
                  CC_CTHL_TryCnt=0;
                    bZhuangLiaoOkFlg = 0;
                    CC_CTHL_ZhuangLiaoStep = 0;
                    CC_CTHL_SetAlarmCode(CC_CTHL_ZLT_ALARM,bRunning);
                    cWULATOUCnt=1;
                }
                else
                {
                    CC_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                    CC_CTHL_ZhuangLiaoDelay = dwTickCount + QDCT_VAVLE_ERROR_TIME;
                }  
            }
            else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                bZhuangLiaoOkFlg = 1;
                CC_CTHL_ZhuangLiaoStep = 0;
            }
            break;
          //装拉头不成攻重新送拉头
        case 20: 
            if(CC_CTHL_HSLiao_Origin_IN)
            {
                CC_CTHL_JLTou_VAVLE = 0;    //接拉头关
                CC_CTHL_MGuo_VAVLE = 0;     //码勾打开
                CC_CTHL_ZhuangLiaoStep = 1;
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + 10;
            }
            else if(dwTickCount >= CC_CTHL_ZhuangLiaoDelay)
            {
                CC_CTHL_SetAlarmCode(CC_CTHL_HSLiao_Origin_ALARM,bRunning);
            }  
            break;
    }  
}

void CC_CTHL_TLiao_Step(void)
{
    switch(CC_CTHL_TLiaoStep)
    {
        case 1:
            if(bTuiLaTouOkFlg)
            {
                CC_CTHL_TLiaoStep = 0; 
            }
            else
            {
                CC_CTHL_TLiao_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                CC_CTHL_TLiaoStep = 2;
            }
            break;
        case 2:    //横送料在原位
            if(CC_CTHL_HSLiao_Origin_IN && !CC_CTHL_HSLiao_Limit_IN && !CC_CTHL_HSLiao_VAVLE)
            {
                CC_CTHL_TLiao_VAVLE = 1;    //推料(推拉头)输出
                CC_CTHL_TLiao_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                CC_CTHL_TLiaoStep = 3;
            }
            else if(dwTickCount >= CC_CTHL_TLiao_Delay) 
                CC_CTHL_SetAlarmCode(CC_CTHL_HSLiao_Origin_ALARM,1);          
            break;
        case 3:  //推拉头到位
            if(CC_CTHL_TLiao_Limit_IN)
            { 
                CC_CTHL_TLiao_Delay = dwTickCount + CC_CTHL_PARAM_TLiao_BACKDELAY;
                CC_CTHL_TLiaoStep = 4;
            }
            else if(dwTickCount >= CC_CTHL_TLiao_Delay) 
                CC_CTHL_SetAlarmCode(CC_CTHL_TLiao_Limit_ALARM,1);        
            break;
        case 4:
            if(dwTickCount >= CC_CTHL_TLiao_Delay)
            {
                CC_CTHL_TLiao_VAVLE       = 0;
                CC_CTHL_TLiao_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME; 
                CC_CTHL_TLiaoStep = 5;
            }
            break;
        case  5:
            if(!CC_CTHL_TLiao_Limit_IN)
            {
                CC_CTHL_TLiaoStep = 0;
                CC_CTHL_TLiao_Delay = dwTickCount;
                bTuiLaTouOkFlg    = 1;
            }
            else if(dwTickCount >= CC_CTHL_TLiao_Delay) 
                CC_CTHL_SetAlarmCode(CC_CTHL_TLiao_Limit_ALARM,0);    
            break;
    } 
   
}
//振动盘控制
void CC_CTHL_ZhenDongAction(void)
{
 
#if 0  
    if((CC_CTHL_bDLP || bRunning) && CC_CTHL_ZhenDongPian_OUT && CC_CTHL_PARAM_DALIAOPIAN)
    {        
        if(CT_DLP_Time >= dwTickCount)
        {
            CT_ZDP_Delay = dwTickCount + CT_PARAM_DLP_TIME + 40;  
            CT_DaLaPian_VAVLE = ~CT_DaLaPian_VAVLE;
        }
    }
    else
        CT_DaLaPian_VAVLE = 0;   
#endif
    
#if 1  

//    if(bRunning)
//    {
/*
      switch(CC_CTHL_PARAM_ZDP_AUTO)
      {
          case 0:
                if(CC_CTHL_ZhenDongPian_OUT == 0)
                {
                    if(!CC_CTHL_ZDP_IN)
                    {
                        if(dwTickCount >= CC_CTHL_ZDP_Delay)
                        {
                            CC_CTHL_ZhenDongPian_OUT = 1;
                            CC_CTHL_ZDP_Delay = dwTickCount + CC_CTHL_PARAM_ZDP_Stop_TIME;//CC_CTHL_PARAM_ZDP_Stop_TIME + 50;
                        }
                    }
                    else
                    {
                        CC_CTHL_ZDP_Delay = dwTickCount + CC_CTHL_PARAM_ZDP_Start_TIME;//CC_CTHL_PARAM_ZDP_Start_TIME;
                    }   
                }
                else
                {  
                    if(CC_CTHL_ZDP_IN)
                    {  
                        if(dwTickCount >= CC_CTHL_ZDP_Delay)
                        {
                             CC_CTHL_ZhenDongPian_OUT = 0;  
                             CC_CTHL_ZDP_Delay = dwTickCount + CC_CTHL_PARAM_ZDP_Start_TIME;//CC_CTHL_PARAM_ZDP_Start_TIME
                        }
                    }
                    else
                        CC_CTHL_ZDP_Delay = dwTickCount + CC_CTHL_PARAM_ZDP_Stop_TIME;//CC_CTHL_PARAM_ZDP_Stop_TIME+ 50;
                }
           break;
        case 1:
           CC_CTHL_ZhenDongPian_OUT=0;
           CC_CTHL_ZDP_Delay = dwTickCount;
          break;
        case 2:     
          CC_CTHL_ZhenDongPian_OUT=1;
          CC_CTHL_ZDP_Delay = dwTickCount;
          break;
      }    
      
     
       }
      else
        CC_CTHL_DaLaPian_OUT = 0; */

     if(CC_CTHL_ZDP_IN)
       {
          if(CC_CTHL_PARAM_LaPian_EN)
          {
              if(dwTickCount >= CC_CTHL_DLP_Delay)
              {
                  
                  CC_CTHL_DaLaPian_OUT = !CC_CTHL_DaLaPian_OUT;
                  
                  if(CC_CTHL_DaLaPian_OUT)
                    CC_CTHL_DLP_Delay = dwTickCount + CC_CTHL_PARAM_DaLaPian;
                  else
                    CC_CTHL_DLP_Delay = dwTickCount + CC_CTHL_PARAM_DaLaPian+50;
              }  
          }
       }
          else
            CC_CTHL_DaLaPian_OUT = 0;    
#endif    
}
void CC_CTHL_bFKCXTDDWStep(void)
{
    switch(CC_CTHL_bFKCXTDDW_Step)
    {
        case 1:
                CC_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                CC_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                CC_CTHL_FKGD_VAVLE = 0;     //方块固定关
                CC_CTHL_bFKCXTDDW_Step = 2;
                
                break;
            case 2: 
                if(!CC_CTHL_XKTD_Origin_IN)  //斜口推带原位离开
                {
                    CC_CTHL_bFKCXTDDW_Step = 3;
                    CC_CTHL_bFKCXTDDW_Delay = dwTickCount + 20;
                }  
                break;
            case 3://斜口定位
                if(dwTickCount >= CC_CTHL_bFKCXTDDW_Delay)
                {
                    CC_CTHL_XKDW_VAVLE = 1;
                    CC_CTHL_bFKCXTDDW_Step = 4;
           //         CC_CTHL_bFKCXTDDW_Delay = dwTickCount + CC_CTHL_PARAM_XKDW_TD_DELAY;
                }  
                break;
            case 4:
                if(dwTickCount >= CC_CTHL_bFKCXTDDW_Delay)
                {
                    AxisContinueMoveAcc(X_AXIS,1200,DIR_P,800,600,10,10);//拖带电机                       
                    CC_CTHL_bFKCXTDDW_Step = 5;
                    CC_CTHL_XSavePosBuff = dwXRealPos;
                    SetPos(X_AXIS, 0);  //启动位置设为0点
                    dwXRealPos = 0;
                }
                break;
            case 5:
                if(CC_CTHL_XKSC_Limit_IN)   //方块到位
                {
                    AxisEgmStop(X_AXIS);
                    CC_CTHL_QDXK_VAVLE=1;
                    CC_CTHL_bFKCXTDDW_Step = 6;
                    CC_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭 
                    CC_CTHL_bFKCXTDDW_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                   
                }
                else if(dwXRealPos >= (CC_CTHL_XSavePosBuff + 800))
                {
                     CC_CTHL_SetAlarmCode(CC_CTHL_FKCXDW_ALARM,bRunning);//方块插销定位异常警告
                    
                }  
                break;
          case 6:  
              if(CC_CTHL_PARAM_TDFZ_LENTH && !X_DRV)  //拖带电机反转
                  AxisMovePosAccDec(X_AXIS,8000,-CC_CTHL_PARAM_DXKFZ_LENTH,800,600,6,6,0); 
              if(CC_CTHL_PARAM_CXCC_MODE)
                   CC_CTHL_CXCC_VAVLE = 1;
               CC_CTHL_bFKCXTDDW_Step = 0;
          break;
    
    }  
}

//插销穿入动作
void CC_CTHL_bCXCRStep(void)
{
    switch(CC_CTHL_bCXCR_Step)
    {
            case 11:
                CC_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                CC_CTHL_FKGD_VAVLE = 0;     //方块固定关
                CC_CTHL_CXSCDW_VAVLE=1;
                CC_CTHL_bCXCR_Step = 12;      
             
                break;
            case 12: 
                if(!CC_CTHL_XKTD_Origin_IN)  //斜口推带原位离开
                {
                    CC_CTHL_bCXCR_Step = 13;
               //     CC_CTHL_CXQJD_VAVLE = 1;    //插销前夹带  
                    CC_CTHL_bCXCR_Delay = dwTickCount + 20;
                }  
                break;
            case 13: 
                if((CC_CTHL_CL_MotorStep == 0) && (CC_CTHL_SF_Origin_IN) && (dwTickCount >= CC_CTHL_bCXCR_Delay))  //插销前夹带回到原位
                {
                    CC_CTHL_bCXCR_Step = 14; 
                 //  CC_CTHL_FKGD_VAVLE = 1;     //方块固定开
                    CC_CTHL_CXQJD_VAVLE = 1;    //插销前夹带                    
                    CC_CTHL_bCXCR_Delay = dwTickCount + CC_CTHL_PARAM_XCQJD_XCDW_DELAY;
                }
                break;
            case 14:
                if(dwTickCount >= CC_CTHL_bCXCR_Delay)
                {
                    CC_CTHL_bCXCR_Step = 15; 
                    CC_CTHL_FKGD_VAVLE = 1;     //方块固定
                    //Y轴启动插销
                    CC_CTHL_CL_MotorStep = 20;  //插销定位                   
                }
                break;
            case 15:   
                if(CC_CTHL_CL_MotorStep == 0)   //插销定位完成
                {
                    CC_CTHL_bCXCR_Step = 16; 
                    CC_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                    CC_CTHL_bCXCR_Delay = dwTickCount + 10;  //延时插销下移
                }  
                break;
            case 16: 
                if(dwTickCount >= CC_CTHL_bCXCR_Delay)
                {
                    CC_CTHL_bCXCR_Step = 17;
                   if(CC_CTHL_PARAM_CXCC_MODE)
                          CC_CTHL_CXCC_VAVLE = 0;
                       else
                          CC_CTHL_CXCC_VAVLE = 1;     //Y06 插销下移电磁阀
                    if(CC_CTHL_PARAM_NLSL_MODE == 0)
                      CC_CTHL_bCXCR_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
                    else
                      CC_CTHL_bCXCR_Delay = dwTickCount + 80;  //插销下移异常时间
                }
                break;
            case 17:   
                if((CC_CTHL_CXCC_Limit_IN) || CC_CTHL_PARAM_NLSL_MODE)
                {
           
                  if(CC_CTHL_CXCC_Limit_IN || (dwTickCount >= CC_CTHL_bCXCR_Delay))
                  {
                    CC_CTHL_bCXCR_Step = 18; 
                     if( cXcxcrCnt==0 && !X_DRV)  //拖带电机反转
                    {
                     AxisMovePosAccDec(X_AXIS,10000,-CC_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);
                    }
                    CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                    CC_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
                    CC_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                    CC_CTHL_bCXCR_Delay = dwTickCount + CC_CTHL_PARAM_SCDWOff_CXDW_DELAY;

                  }
                }  
                else if(dwTickCount >= CC_CTHL_bCXCR_Delay)  
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_CXCC_Limit_ALARM,bRunning);//插销下移异常
                    
                }
                break;
            case 18:   
  //              if(START_IN_UP)
                {
                if(dwTickCount >= CC_CTHL_bCXCR_Delay) 
                {
                    CC_CTHL_bCXCR_Step = 19; 
                    
                    CC_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
                    CC_CTHL_bCXCR_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME +1000;  //插销穿入到位异常时间
                    CC_CTHL_CL_MotorStep = 50;  //合链电机回原点
                }
                }
                break;
            case 19:  
                 if( cXcxcrCnt > 1)  
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_CX_Limit_ALARM,bRunning); //插销穿入到位异常  
                }
                
                if( CC_CTHL_CX_Limit_IN  &&  cXcxcrCnt<2 )
                {
                    cXcxcrCnt=0;
                    bZhuangLiaoOkFlg = 0;
                    CC_CTHL_bCXCR_Step = 0;
                    CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
              
                } 
                else if (dwTickCount >= CC_CTHL_bCXCR_Delay)
                {
                  cXcxcrCnt++;
              
                   CC_CTHL_CXHJD_VAVLE=0;
                   CC_CTHL_CXHDW_VAVLE=0;
                   CC_CTHL_CXDWZ_VAVLE = 0;
                       if(CC_CTHL_PARAM_CXCC_MODE)
                          CC_CTHL_CXCC_VAVLE = 0;
                       else
                          CC_CTHL_CXCC_VAVLE = 1;     //Y06 插销下移电磁阀
                  CC_CTHL_bCXCR_Step = 11;
                }
               
              break;
  }
}

void CC_CTHL_bCLFirstStep(void)
{
    switch(CC_CTHL_bCLFirst_Step)
    {
           case 19:   
                CC_CTHL_JLTou_VAVLE = 0;        //接拉头
                bZhuangLiaoOkFlg = 0;
                CC_CTHL_bCLFirst_Step = 20;
                CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                CC_CTHL_CXCC_VAVLE = 0;     //Y06 插销下移电磁阀关
                CC_CTHL_bCLFirst_Delay = dwTickCount + CC_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
                break;
            case 20:  
                if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                    CC_CTHL_bCLFirst_Step = 21;
                    CC_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
                    CC_CTHL_bCLFirst_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                }
                break;
            case 21:   
                if(!CC_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
                {
                    CC_CTHL_bCLFirst_Step = 22;
                    CC_CTHL_bCLFirst_Delay = dwTickCount + CC_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
                }
                else if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                   CC_CTHL_SetAlarmCode(CC_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
                }
                break;
            case 22:
                if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                    CC_CTHL_bCLFirst_Step = 23;                                     
                    CC_CTHL_MGuo_VAVLE = 0;     //码勾退
                    CC_CTHL_bCLFirst_Delay = dwTickCount + CC_CTHL_PARAM_MGOff_XiaMo_DELAY;
                    CC_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    CC_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                    CC_CTHL_CXCC_VAVLE = 0;     //Y06 插销下移电磁阀关
                } 
                break;
            case 23:  
                if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                    CC_CTHL_bCLFirst_Step = 24;
                    CC_CTHL_CTXM_VAVLE = 0; //穿头下模下降
                    CC_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    CC_CTHL_bCLFirst_Delay = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                } 
                break;
            case 24: 
                if(!CC_CTHL_CTM_Limit_IN)
                {
                     CC_CTHL_bCLFirst_Step= 25;
                    CC_CTHL_bCLFirst_Delay = dwTickCount + 25;  //一次穿入延时返回
                }
                else if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                    CC_CTHL_SetAlarmCode(CC_CTHL_CTM_Origin_ALARM,bRunning); //穿头下模下降异常
                }
                break;
            case 25:
                if(dwTickCount >= CC_CTHL_bCLFirst_Delay) 
                {
                  
                     CC_CTHL_bCLFirst_Step= 0;
                    CC_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                    CC_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                    
                    
                    //退下出错警告
                    CC_CTHL_AutoDelay1 = dwTickCount + CC_CTHL_VAVLE_ERROR_TIME;
                    CC_CTHL_AutoStep1 = 1;
                    bTuiLaTouOkFlg = 1;
                }
                break;
    }
}
//手动动作
void CC_CTHL_ManualAction(void)
{ 

  
    if(cBanAuTo)
  {
  CC_CTHL_PARAM_XCRU=1;
  }
  else
  {
  CC_CTHL_PARAM_XCRU=0;
  }
  //监控
  if(cCXCONE)
  {
  CC_CTHL_PARAM_CXCR=1;
  }
  else
  {
  CC_CTHL_PARAM_CXCR=0;
  }
      if(bRunning && user_datas[100]==0) // 运行灯输出
      {
        CC_CTHL_Run_State=1;
        CC_CTHL_Stop_State=0;
      }
      else if(!bRunning && user_datas[100]==0)
      {
        CC_CTHL_Run_State=0;
         CC_CTHL_Stop_State=0;
      }
      if(user_datas[100] != 0)
      {
         CC_CTHL_Run_State=0;
         CC_CTHL_Stop_State=1;
      }
  
    if( (GetAlarm(Y_AXIS)==0) || (GetAlarm(X_AXIS)==0)) // 伺服报警
    {
 //     cCHULIANBAOJIN=1;
   //   CC_CTHL_SetAlarmCode(CC_CTHL_SF_ALR_ALARM,0);
    }
     if(dwTickCount >= CC_CTHL_bSFBBAOJIN_Delay)  
     {
      
         SetClr(Y_AXIS,MOTOR_ALARM);
           SetClr(X_AXIS,MOTOR_ALARM);
     }
 
   if(bRunning == 0)  
    {   
        if(bClearTotal) //切断计数清零
        {
            bClearTotal       = 0;
            ClrcToTal(QDCT_TOTAL_ADDR);
        }
        if(CC_CTHL_bTLiao )                 //手动推料(推拉头)
        {
            CC_CTHL_bTLiao = 0;           
            if(CC_CTHL_TLiao_VAVLE)
               CC_CTHL_TLiao_VAVLE = 0;//CC_CTHL_TLiao_VAVLE; 
            else if(!CC_CTHL_HSLiao_VAVLE && CC_CTHL_HSLiao_Origin_IN)
            {
                CC_CTHL_TLiao_VAVLE = 1;
            } 
            else//条件警告
            {
              CC_CTHL_SetAlarmCode(CC_CTHL_HENSONGLIAO_ALARM,0); // 横送料不能输出
            }

        } 

        if(CC_CTHL_bHSL)     //手动横送料   
        {
            CC_CTHL_bHSL= 0;
            if(!CC_CTHL_First_CT_VAVLE)
            {
            if(CC_CTHL_HSLiao_VAVLE)
            {
                CC_CTHL_HSLiao_VAVLE = 0;//~CC_CTHL_HSLiao_VAVLE;
            }
            else if(!CC_CTHL_TLiao_VAVLE && !CC_CTHL_TLiao_Limit_IN && CC_CTHL_CTM_Origin_IN && !CC_CTHL_JLiao_Limit_IN &&
                    !CC_CTHL_JLTou_VAVLE && !CC_CTHL_CTXM_VAVLE && !CC_CTHL_CXDWZ_VAVLE && (!CC_CTHL_bMG || (CC_CTHL_bMG && CC_CTHL_LTou_Check)))
            {
             if(CC_CTHL_PARAM_LTJJ_MODE)
            {
            CC_CTHL_LTJJ_VAVLE=1;
            }
            else
            {
            CC_CTHL_LTJJ_VAVLE=0;
            }
               
                CC_CTHL_HSLiao_VAVLE = 1;
            }  
            else   //条件警告  最后一个括号条件为已经有拉头
            {
               CC_CTHL_SetAlarmCode(CC_CTHL_YCCT_ALARM,0); 
            }  
            }
        }           
        if(CC_CTHL_bJLT)                  //接拉头
        {
            CC_CTHL_bJLT = 0;
            if(CC_CTHL_JLTou_VAVLE)
                CC_CTHL_JLTou_VAVLE = 0;
            else if(!CC_CTHL_First_CT_VAVLE && !CC_CTHL_CTXM_VAVLE && CC_CTHL_CTM_Origin_IN && CC_CTHL_First_CT_Origin_IN)
            {
                CC_CTHL_MGuo_VAVLE = 0;
                CC_CTHL_JLTou_VAVLE = 1;
            } 
            else//条件警告
            {
                 CC_CTHL_SetAlarmCode(CC_CTHL_YCXM_Origin_ALARM,0); 
            }
        } 
        if(CC_CTHL_bMG)                   //码勾
        {
            CC_CTHL_bMG = 0;
            CC_CTHL_MGuo_VAVLE = !CC_CTHL_MGuo_VAVLE;
        } 
        if(CC_CTHL_bLTJJ)                   //码勾
        {
            CC_CTHL_bLTJJ = 0;
            CC_CTHL_LTJJ_VAVLE = !CC_CTHL_LTJJ_VAVLE;
        } 
        if(CC_CTHL_bFKJD)                 //方块夹带
        {
            CC_CTHL_bFKJD = 0;
            CC_CTHL_FKJD_VAVLE = !CC_CTHL_FKJD_VAVLE;
        } 
        if(CC_CTHL_bXKTD)                  //斜口推带
        {
            CC_CTHL_bXKTD = 0;
            if(CC_CTHL_XKTD_VAVLE)
                CC_CTHL_XKTD_VAVLE = 0;
            else if(!CC_CTHL_DXK_VAVLE && (!CC_CTHL_XKSC_Limit_IN  || !CC_CTHL_CTXM_VAVLE|| CC_CTHL_PARAM_NLSL_MODE))
                CC_CTHL_XKTD_VAVLE = 1;
            else//条件警告
            {
                CC_CTHL_SetAlarmCode(CC_CTHL_DXKCTXM_Origin_ALARM,0);          
            }
        } 
        if(CC_CTHL_bXKDW)                  //斜口定位
        {
            CC_CTHL_bXKDW = 0;
            CC_CTHL_XKDW_VAVLE = ~CC_CTHL_XKDW_VAVLE;
        } 
        if(CC_CTHL_bCTXM)                  //穿头下模
        {
            CC_CTHL_bCTXM = 0;
            if(CC_CTHL_CTXM_VAVLE)
            {
               if(CC_CTHL_PARAM_LTJJ_MODE)
                {
                CC_CTHL_LTJJ_VAVLE=1;
                }
                else
                {
                CC_CTHL_LTJJ_VAVLE=0;
                } 
                CC_CTHL_CTXM_VAVLE = 0;
                CC_CTHL_MGuo_VAVLE = 0;
                CC_CTHL_JLTou_VAVLE = 0;
                CC_CTHL_CXCC_VAVLE=0;
            }    
            else if(!CC_CTHL_HSLiao_VAVLE && CC_CTHL_HSLiao_Origin_IN && (!CC_CTHL_XKSC_Limit_IN || !CC_CTHL_XKTD_VAVLE))                
            {  
               if(CC_CTHL_PARAM_CXCC_MODE)
                    CC_CTHL_CXCC_VAVLE = 1;
               if(CC_CTHL_LTJJ_Origin_IN)
               {
                CC_CTHL_MGuo_VAVLE = 1;
                CC_CTHL_CTXM_VAVLE = 1;
                CC_CTHL_LTJJ_VAVLE=0;
               }
               else 
               {
               CC_CTHL_SetAlarmCode(CC_CTHL_XMKH_Origin_ALARM,0);   
                CC_CTHL_LTJJ_VAVLE=0;
               }
               
      
              
            }  
        } 
         if(CC_CTHL_bQianDXK)                  //前顶斜口
        {
            CC_CTHL_bQianDXK = 0;
            if(CC_CTHL_QDXK_VAVLE)
                CC_CTHL_QDXK_VAVLE = 0;
             else if(!CC_CTHL_XKTD_VAVLE)
                CC_CTHL_QDXK_VAVLE = 1;
             else  //条件警告
             {
                  CC_CTHL_SetAlarmCode(CC_CTHL_XKTD_ALARM,0);   
             } 
        } 
        
        if(CC_CTHL_bDXK)                  //顶斜口
        {
           CC_CTHL_bDXK = 0;
          if(!CC_CTHL_PARAM_NLSL_MODE)
          {
            if(CC_CTHL_DXK_VAVLE)
                CC_CTHL_DXK_VAVLE = 0;
             else if(!CC_CTHL_XKTD_VAVLE)
             {
               if(!CC_CTHL_PARAM_NLSL_MODE)
                CC_CTHL_DXK_VAVLE = 1;
             }
             else  //条件警告
             {
                  CC_CTHL_SetAlarmCode(CC_CTHL_XKTD_ALARM,0);   
             } 
          }
          else
          {
                if(CC_CTHL_XKTD_VAVLE)
                CC_CTHL_XKTD_VAVLE = 0;
            else if(!CC_CTHL_DXK_VAVLE )
            {
              if(!CC_CTHL_XKSC_Limit_IN  || !CC_CTHL_CTXM_VAVLE || CC_CTHL_PARAM_NLSL_MODE)
                CC_CTHL_XKTD_VAVLE = 1;
              else
              {
                CC_CTHL_SetAlarmCode(CC_CTHL_YCXM_Origin_ALARM,0);   
              }
            }
            else//条件警告
            {
                CC_CTHL_SetAlarmCode(CC_CTHL_DXKCTXM_Origin_ALARM,0);          
            }

          }
        } 
   //斜码插入
        if(CC_CTHL_bBanZiDong)
        {
           CC_CTHL_bBanZiDong=0;
           cBanAuTo=1;
           cCHULIANBAOJIN=0;
           CC_CTHL_PARAM_BanAuto_MODE=1;
 //          CC_CTHL_PARAM_BanAuto_MODE=1;
          CC_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
          CC_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
          CC_CTHL_ZhuangLiaoStep = 1; 
           bTuiLaTouOkFlg = 1;
           bZhuangLiaoOkFlg= 0;
           bCL_EN_FLG=0;
           CC_CTHL_AutoStep = 1;  
           bRunning=1;
        }
         //小插插入
         if(CC_CTHL_CXC)//穿小插
        {
           CC_CTHL_CXC=0;
           cCXCONE=1;
           cBanAuTo=0;
           CC_CTHL_PARAM_BanAuto_MODE=0;
              cCHULIANBAOJIN=0;
     //    CC_CTHL_PARAM_BanAuto_MODE=0;
           CC_CTHL_AutoStep = 11;  
           bRunning=1;
           if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                CC_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            } 
        }
        

        if(CC_CTHL_bFKGD)                 //方块固定
        {
            CC_CTHL_bFKGD = 0;
            CC_CTHL_FKGD_VAVLE = ~CC_CTHL_FKGD_VAVLE;
        } 
        if(CC_CTHL_bCXQJD)                 //插销前夹带
        {
            CC_CTHL_bCXQJD = 0;
            CC_CTHL_CXQJD_VAVLE = ~CC_CTHL_CXQJD_VAVLE;
        } 
        if(CC_CTHL_bCXSY)                 //插销下移电磁阀
        {
            CC_CTHL_bCXSY = 0;
            CC_CTHL_CXCC_VAVLE = !CC_CTHL_CXCC_VAVLE;
        } 
        if(CC_CTHL_bCXDWZ)                 //Y14 插销定位针电磁阀
        {
            CC_CTHL_bCXDWZ = 0;
            if(CC_CTHL_CXDWZ_VAVLE)
                CC_CTHL_CXDWZ_VAVLE = 0;
            else if(CC_CTHL_HSLiao_Origin_IN)
            {
                CC_CTHL_CXDWZ_VAVLE = 1;
            }
            else //条件警告
            {
            CC_CTHL_SetAlarmCode(CC_CTHL_HENSONGLIAO_ALARM,0);   
            }
                
        } 
        if(CC_CTHL_bCXHJD)                 //Y15 插销后夹带电磁阀
        {
            CC_CTHL_bCXHJD = 0;
            CC_CTHL_CXHJD_VAVLE =~CC_CTHL_CXHJD_VAVLE;
        } 
        if(CC_CTHL_bCXHDW)                 //Y16 插销后定位电磁阀
        {
            CC_CTHL_bCXHDW = 0;
            if(CC_CTHL_CXHDW_VAVLE)
                CC_CTHL_CXHDW_VAVLE = 0;
            else if(!CC_CTHL_CXQJD_VAVLE)
                CC_CTHL_CXHDW_VAVLE = 1;
            else//条件警告
            {
            CC_CTHL_SetAlarmCode(CC_CTHL_CXQJD_ALARM,0);  
            }
        } 
        if(CC_CTHL_bFirst_CT)              //Y20 一次穿头电磁阀
        {
            CC_CTHL_bFirst_CT = 0;
            CC_CTHL_First_CT_VAVLE = ~CC_CTHL_First_CT_VAVLE;

        } 
        if(CC_CTHL_bHLJJ)                  //Y21 合链夹具电磁阀
        {
            CC_CTHL_bHLJJ = 0;
            CC_CTHL_HLJJ_VAVLE = ~CC_CTHL_HLJJ_VAVLE;
        } 
        
       if( CC_CTHL_bKALATOU)
       {
       CC_CTHL_bKALATOU=0;
       CC_CTHL_KALATOU_VAVLE=~CC_CTHL_KALATOU_VAVLE;
       
       }
        if(CC_CTHL_bCXSCDW)               //Y23 插销上止定位电磁阀 
        {
            CC_CTHL_bCXSCDW = 0;
            CC_CTHL_SongDai_VAVLE = ~CC_CTHL_SongDai_VAVLE;
        } 
        //自动装料
        if(CC_CTHL_bAutoZhuangLiao)
        {
            CC_CTHL_bAutoZhuangLiao = 0;
            if(CC_CTHL_ZhuangLiaoStep == 0)
            {
               

                bTuiLaTouOkFlg = 1;
                bZhuangLiaoOkFlg = 0;
                CC_CTHL_ZhuangLiaoStep = 1;
                  CC_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                  CC_CTHL_LTJJ_VAVLE=0;
                CC_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
 
              
            }  
        }
        //测试电机
        if(CC_CTHL_bCLMotor_N)
        {           
            SetEn(Y_AXIS, MOTOR_EN);
            if(!CC_CTHL_SF_Origin_IN)
            {  
                if(!Y_DRV)
                  //                Y轴       运行速度                    启动速度        加速度  减速度
                        AxisContinueMoveAcc(Y_AXIS,2000,DIR_P,1000,1000,15,15);
            } 
            else
            {
                CC_CTHL_bCLMotor_N = 0;
            }
              
        }
        
        if(CC_CTHL_bCLMotor_P)  //后退限位已经取消
        {
            SetEn(Y_AXIS, MOTOR_EN);
           if(!CC_CTHL_SF_Origin_IN)
           {
           if(!Y_DRV)
              //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,1000,15,15);
           }
        }
        
        if(!CC_CTHL_bCLMotor_P && !CC_CTHL_bCLMotor_N && (CC_CTHL_CL_MotorStep == 0))
        {
              AxisEgmStop(Y_AXIS);//AxisDecStop(Y_AXIS); 
        }
        
              if(CC_CTHL_bTDMotor_P)  //后退限位已经取消
        {
            SetEn(X_AXIS, MOTOR_EN);
           if(!X_DRV)
              //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(X_AXIS,2000,DIR_N,1000,1000,15,15);
        }
                      if(CC_CTHL_bTDMotor_N)  //后退限位已经取消
        {
            SetEn(X_AXIS, MOTOR_EN);
           if(!X_DRV)
              //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(X_AXIS,2000,DIR_P,1000,1000,15,15);
        }
 
        
        if(!CC_CTHL_bTDMotor_P && !CC_CTHL_bTDMotor_N && (CC_CTHL_TD_MotorStep == 0))
        {
              AxisEgmStop(X_AXIS);//AxisDecStop(Y_AXIS); 
        }
        
        //合链电机返回原点
        if(CC_CTHL_bCLMotor_O)
        {
            CC_CTHL_bCLMotor_O = 0;
            if(CC_CTHL_CL_MotorStep == 0)
                CC_CTHL_CL_MotorStep = 40;
        } 
        //拖带方块定位 ,因这步为前拖带定位, 很多电磁阀要关掉       
        if(CC_CTHL_bFKTDDW)
        {
            CC_CTHL_bFKTDDW = 0;
            if(CC_CTHL_TD_MotorStep == 0)
            {
                CC_CTHL_XKDW_VAVLE = 0;     //斜口定位
                CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
           if(!CC_CTHL_PARAM_CXCC_MODE)     
                   CC_CTHL_CXCC_VAVLE = 0;     //插销下移
           
                CC_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                CC_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                CC_CTHL_bHLJJ = 0;          //合链夹具
                CC_CTHL_FKJD_VAVLE = 0;     //方块夹带
                if((GetEn(X_AXIS) == MOTOR_DISEN))
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    CC_CTHL_TD_MotorDelay = dwTickCount + 200;                    
                } 
                else
                    CC_CTHL_TD_MotorDelay = dwTickCount + 50;
                CC_CTHL_TD_MotorStep = 1;
            } 
        } 
        //拖带方块插销定位(斜口推带，斜口定位，顶斜口)
        if(CC_CTHL_bFKCXTDDW)
        {
            CC_CTHL_bFKCXTDDW = 0;
            if((CC_CTHL_bFKCXTDDW_Step == 0) && (CC_CTHL_CL_MotorStep == 0) && 
               !CC_CTHL_CTXM_VAVLE)
            {
                CC_CTHL_bFKCXTDDW_Step = 1;
                SetEn(X_AXIS, MOTOR_EN);
                CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                CC_CTHL_CXCC_VAVLE = 0;     //插销下移
                CC_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                CC_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                CC_CTHL_HLJJ_VAVLE = 0;          //合链夹具
            }  
        } 
        //插销穿入(包含电机前定位,插销下移,后夹,后定位)
        if(CC_CTHL_bCXCR) 
        {
            CC_CTHL_bCXCR = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(CC_CTHL_CTXM_VAVLE && CC_CTHL_MGuo_VAVLE && !CC_CTHL_CXQJD_VAVLE &&
               CC_CTHL_CTM_Limit_IN && !CC_CTHL_LTou_Check)
            {                
                if(CC_CTHL_CL_MotorStep == 0)
                {
                     CC_CTHL_bCXCR_Step = 11; 
                     SetEn(Y_AXIS, MOTOR_EN);
                     if(!CC_CTHL_SF_Origin_IN)
                        CC_CTHL_CL_MotorStep = 40;
                }
            }
            else   //警告不能自动穿插销
            {
            CC_CTHL_SetAlarmCode(CC_CTHL_WFZIDONGCX_ALARM,0);  
            }
        }
        //电机合链动作
        if(CC_CTHL_bMotorHL)
        {
            CC_CTHL_bMotorHL = 0;
            if(CC_CTHL_SF_Origin_IN)
            {
            if((CC_CTHL_CL_MotorStep == 0) && !CC_CTHL_CTXM_VAVLE && (!CC_CTHL_CTM_Limit_IN))
            {
                bCL_OK_FLG = 0;   
                CC_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                CC_CTHL_CL_MotorStep = 1;
                CC_CTHL_CL_MotorDelay = dwTickCount + CC_CTHL_PARAM_HLJJ_CL_DELAY + 130;
                if((GetEn(Y_AXIS) == MOTOR_DISEN))
                {
                    SetEn(Y_AXIS, MOTOR_EN);
                    CC_CTHL_CL_MotorDelay = dwTickCount + 250;                    
                } 
            }
            }
            else
            {
             CC_CTHL_bCLMotor_O =1;
             
            }
        } 
        //一次穿链动作
        if(CC_CTHL_bCL_First)
        {
            CC_CTHL_bCL_First = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(CC_CTHL_CTXM_VAVLE && CC_CTHL_MGuo_VAVLE && !CC_CTHL_CXQJD_VAVLE &&
               CC_CTHL_CTM_Limit_IN && !CC_CTHL_LTou_Check && (CC_CTHL_CL_MotorStep == 0))
            {  
                CC_CTHL_bCLFirst_Step = 19;
                CC_CTHL_CXHJD_VAVLE = 1;    //插销后夹带 
                CC_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                CC_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
            }
        }        
    }        
}

#endif