GC23005/Machine/FuXiaoWeiMachine/FXWChuantou_HeLian_D.c

#include "global.h"

#if FU_XIAO_WEI_MACHINE==1

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




//故障报警
void XY_CTHL_SetAlarmCode(unsigned short alarm_code,unsigned short cStopFlag)
{
    if(!cONERROR)
    {
        SetAlarmCode(XY_CTHL_ALARM_ADDR,alarm_code);
        cONERROR=1;
    }
    if(!cXiaoChaCNT)
        bAlarmStop = 1;
    
    
}
//视觉程序
void XY_CTHL_ShiJue_Action(void)
{
    
#if 1
    if(!XY_CTHL_ZDP_IN)
    {
        // if(dwTickCount >= XY_CTHL_ShiJue_Delay2)
        {
            XY_CTHL_PARAM_ShiJue = 1;
            //  XY_CTHL_ShiJue_Delay2 = dwTickCount + 500;//CTHL_PARAM_ZDP_Stop_TIME + 50;
        }
    }
    //    else
    //    {
    //        XY_CTHL_ShiJue_Delay2 = dwTickCount + 500;//CTHL_PARAM_ZDP_Start_TIME;
    //   }   
    
    if(XY_CTHL_ZDP_IN)
    {  
        ///   if(dwTickCount >= XY_CTHL_ShiJue_Delay2)
        {
            XY_CTHL_PARAM_ShiJue = 0;  
            //        XY_CTHL_ShiJue_Delay2 = dwTickCount + 500;//CTHL_PARAM_ZDP_Start_TIME
        }
    }
    // else
    //    XY_CTHL_ShiJue_Delay2 = dwTickCount + 500;//CTHL_PARAM_ZDP_Stop_TIME+ 50;
    
#endif
    
#if 1
    if(XY_CTHL_PARAM_ShiJue)
    {
        
        if(XY_CTHL_PARAM_SHIJUE_MODE)
        {
            
            switch(XY_CTHL_ShiJueStep)
            {
            case 0:
                // XY_CTHL_ShiJueStep=1;
                break;
            case 1:
                if(XY_CTHL_ShiJueStep1==0)
                {
                    cShiJue=1;
                    XY_CTHL_DINGCHU_VAVLE=0; 
                    XY_CTHL_ShiJue_Delay=dwTickCount+XY_CTHL_PARAM_JIANCHE_DEALY;
                    XY_CTHL_ShiJueStep=2;
                }
                break;
            case 2:
                if((dwTickCount>=XY_CTHL_ShiJue_Delay) && !XY_CTHL_DINGCHU_VAVLE)
                {
                    
                    XY_CTHL_JIANCHE_VAVLE=1;
                    XY_CTHL_ShiJue_Delay=dwTickCount+XY_CTHL_PARAM_GBXIANZZHI_DEALY;//延时关闭限制
                    XY_CTHL_ShiJueStep=3;
                } 
                break;
            case 3:
                if(dwTickCount>=XY_CTHL_ShiJue_Delay)
                {
                    
                    XY_CTHL_XIANZHI_VAVLE=0;
                    XY_CTHL_ShiJue_Delay=dwTickCount+XY_CTHL_PARAM_DKXIANZZHI_DEALY;//延时打开限制
                    XY_CTHL_ShiJueStep=4;
                }
                break;
            case 4:
                if(dwTickCount>=XY_CTHL_ShiJue_Delay)
                {
                    XY_CTHL_SHIJUEMODE_VAVLE=1;
                    XY_CTHL_XIANZHI_VAVLE=1;
                    XY_CTHL_ShiJue_Delay=dwTickCount+XY_CTHL_PARAM_DINGLTOU_DEALY;//视觉检测时间
                    XY_CTHL_ShiJueStep=5;
                }
                break;
            case 5:
                if(XY_CTHL_LMBJ_UP)
                {
                    XY_CTHL_SHIJUEMODE_VAVLE=0;
                    XY_CTHL_ShiJueStep1=1;
                    XY_CTHL_ShiJueStep=1;
                }
                else if(dwTickCount>=XY_CTHL_ShiJue_Delay)
                {
                    XY_CTHL_SHIJUEMODE_VAVLE=0;
                    XY_CTHL_JIANCHE_VAVLE=0; 
                    XY_CTHL_ShiJueStep=1; 
                    
                    
                }
                break;
                
                
            }
            switch(XY_CTHL_ShiJueStep1)
            {
            case 1:
                XY_CTHL_DINGCHU_VAVLE=1;
                XY_CTHL_ShiJue_Delay1=dwTickCount+XY_CTHL_PARAM_GBJIANCHE_DEALY;//延时退检测
                XY_CTHL_ShiJueStep1=2;
                break;
            case 2:
                if(dwTickCount>=XY_CTHL_ShiJue_Delay1)
                {
                    XY_CTHL_JIANCHE_VAVLE=0; 
                    XY_CTHL_ShiJue_Delay1=dwTickCount+XY_CTHL_PARAM_DingLT_time;
                    XY_CTHL_ShiJueStep1=3;
                }
                break;   
            case 3:
                if(dwTickCount>=XY_CTHL_ShiJue_Delay1)
                {
                    
                    XY_CTHL_DINGCHU_VAVLE=0; 
                    XY_CTHL_ShiJueStep=1; 
                    XY_CTHL_ShiJueStep1=0;
                }
                break;
            }
            
        }
        else
        {
            XY_CTHL_ShiJueStep1=0;
            XY_CTHL_ShiJueStep=1;
            
        }
    }
    else
    {
        if(cShiJue)
        {
            cShiJue=0;
            
            XY_CTHL_XIANZHI_VAVLE=1;
            XY_CTHL_DINGCHU_VAVLE=0;
        }
        // XY_CTHL_ShiJueStep=1;
        
        //   XY_CTHL_ShiJueStep1=0;
        ///XY_CTHL_ShiJueStep=0;
    }
#endif
    
}

//色标保护
void XY_CTHL_Color_Action(void)
{
    if(0)//XY_CTHL_PARAM_COLOR_CODE)
    {
        switch(XY_CTHL_ColorStep)
        {
            
        case 1:
            
            {
                bRunning=0;
                cXcxcrCnt=0;
                cXCXQXQD=0;
                bSingOneFlg=0;
                bCL_EN_FLG = 0;
                cBAOHUCNT=0; 
                cBanAuTo=0;  
                cXiaoChaTest=0;
                cCHULIANBAOJIN=0;

                cWULATOUCnt=0;
                AxisEgmStop(X_AXIS);
                AxisEgmStop(Y_AXIS);
                cStopMode=0;
                if(!XY_CTHL_SF_ALR_IN )
                {
                    XY_CTHL_SF_ALR_CLR=1;
                    XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 500;
                }
                XY_CTHL_TLiao_VAVLE=0;             
                XY_CTHL_HSLiao_VAVLE  =0;    
                XY_CTHL_JLTou_VAVLE  =0; 
                XY_CTHL_QDXK_VAVLE=0;
                XY_CTHL_XKTD_VAVLE  =0;        
                XY_CTHL_XKDW_VAVLE  =0;       
                XY_CTHL_DXK_VAVLE  =0;         
                XY_CTHL_CXXY_VAVLE  =0;         
                XY_CTHL_CTXM_VAVLE =0;         
                XY_CTHL_First_CT_VAVLE =0;     
                XY_CTHL_FKGD_VAVLE =0;         
                XY_CTHL_CXQJD_VAVLE =0;        
                XY_CTHL_CXDWZ_VAVLE  =0;       
                XY_CTHL_CXHJD_VAVLE =0;        
                XY_CTHL_CXHDW_VAVLE =0;        
                XY_CTHL_FKJD_VAVLE  =0;        
                XY_CTHL_HLJJ_VAVLE  =0;                       
                XY_CTHL_CXSCDW_VAVLE =0;
                if(XY_CTHL_CTM_Origin_IN || !XY_CTHL_CXSC_Limit_IN || cBanAuTo || bRunning)
                    XY_CTHL_MGuo_VAVLE =0;        
                XY_CTHL_AutoStep = 0;
                XY_CTHL_ZhuangLiaoStep=0;
                XY_CTHL_TLiaoStep=0;
                XY_CTHL_TD_MotorStep=0;
                XY_CTHL_JiaLianStep  =0;     
                XY_CTHL_SongLiaoStep   =0;     
                XY_CTHL_CL_MotorStep =0;      
                XY_CTHL_AutoStep1  =0;
                XY_CTHL_bFKCXTDDW_Step=0;
                XY_CTHL_bCXCR_Step=0;
                XY_CTHL_bCLFirst_Step=0;
                if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
                    SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
                SetPos(X_AXIS, 0); 
                XY_CTHL_TLiaoStep = 0; 
                XY_CTHL_AutoStep = 0;
            }
            XY_CTHL_ColorStep=2; 
            XY_CTHL_bColor_Delay=dwTickCount+500;
            
            break;
        case 2:
            if(dwTickCount >=  XY_CTHL_bColor_Delay)
            {
                if(XY_CTHL_AUTO_run_LENGTH)
                {
                    AxisMovePosAccDec(X_AXIS,3000,XY_CTHL_AUTO_run_LENGTH,800,600,6,6,0);  
                    XY_CTHL_ColorStep=3;
                }
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_COLOR_IN_ALARM,bRunning);
                }
                
            }
            break;
        case 3:
            if(!X_DRV)
            {
                XY_CTHL_bFKTDDW=1;
                XY_CTHL_ColorStep=4;
                XY_CTHL_bColor_Delay=dwTickCount+20;
                
            } 
            break;
        case 4:
            if(dwTickCount >=  XY_CTHL_bColor_Delay)
            {
                if(XY_CTHL_TD_MotorStep==0)
                {
                    bStart=1;
                    XY_CTHL_ColorStep=0;
                }
            }
            break;
            
        }
        
    }
    else
    {
        XY_CTHL_ColorStep=0;
    }
    
}
//初始化动作
void XY_CTHL_InitAction(void)
{
    float buff_pulse,buff_dist;
    
    buff_pulse  = XY_CTHL_PARAM_CYCLE_PULSE;
    buff_dist   = XY_CTHL_PARAM_CYCLE_LENGTH; 
    XGearRatio  =  buff_pulse/buff_dist; 
    
    
    buff_pulse  = XY_CTHL_PARAM_CYCLE_PULSE;
    buff_dist   = XY_CTHL_PARAM_SFCYCLE_LENGTH;
    YGearRatio  =  buff_pulse/buff_dist;
    //视觉启动   
    XY_CTHL_ShiJueStep=1;
    bYFirstDingWeiFlg = 1;
    user_datas[121] = 0;
    user_datas[122] = 0;
    user_datas[123] = 0;
    
//    if(!XY_CTHL_MotorChose_MODE)
//        SetEnReverse(X_AXIS, 0);
//    else
        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);
    
    if(!XY_CTHL_SF_Origin_IN)
    {
        XY_CTHL_bCLMotor_O=1;
    }
    //    QDCT_SZ_OUT   = QDCT_MOTOR_DISEN;
}

void XY_CTHL_Action(void)
{     
    //    user_datas[122] =XY_CTHL_TLiaoStep; 
    dwXRealPos = GetPos(X_AXIS);
    dwYRealPos = GetPos(Y_AXIS);
    dwZRealPos = GetPos(Z_AXIS);  
    user_datas[124] = dwXRealPos;
    user_datas[125] = dwYRealPos;
    user_datas[126] = XY_CTHL_LianLengthAutoCheck;
    user_datas[127] = XY_CTHL_LianLengSave;
    user_datas[128] = GetCurSpeed(X_AXIS);//XY_CTHL_PARAM_ShiJue;//、、XY_CTHL_AutoStep;    
    XY_CTHL_ZhenDongAction();
    XY_CTHL_AlarmProtect();
    XY_CTHL_CheckStart();    
    XY_CTHL_ZLT_Step();
    XY_CTHL_TLiao_Step();
    XY_CTHL_TD_Motor();
    XY_CTHL_CL_Motor();
    XY_CTHL_bFKCXTDDWStep();
    XY_CTHL_bCXCRStep();
    XY_CTHL_bCLFirstStep();
    XY_CTHL_ShiJue_Action();
    XY_CTHL_ManualAction();
    XY_CTHL_Color_Action();
    XY_CTHL_AutoStepAction();  
}

void XY_CTHL_AlarmProtect(void)
{ 
    
    
    
}



//自动动作
void XY_CTHL_AutoStepAction(void)
{  
    if(0)//XY_CTHL_PARAM_COLOR_CODE)
    {
        if(bRunning && XY_CTHL_Colorcode_IN_UP)
        {
            XY_CTHL_ColorStep=1; 
        }
    }
    
    if(bRunning)
    {
        switch(XY_CTHL_AutoStep)
        {
        case 1:
            if(((XY_CTHL_SF_Origin_IN ) && (dwTickCount >= XY_CTHL_AutoDelay)) || cBanAuTo) 
            {
                /*   XY_CTHL_AutoStep = 10;       //测试拖带定位
                XY_CTHL_AutoDelay = dwTickCount + 1000;
                break; 
                */
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_XKTD_VAVLE = 1;   //斜口推带气缸输出    
                    XY_CTHL_FKGD_VAVLE = 0;     //方块固定关
                    //    XY_CTHL_XKDW_VAVLE = 1;
                    XY_CTHL_AutoStep = 2;
                    XY_CTHL_AutoDelay = dwTickCount + 150;
                    if(XY_CTHL_ZhuangLiaoStep == 0)
                    { 
                        XY_CTHL_First_CT_VAVLE=0;
                        XY_CTHL_ZhuangLiaoStep = 1;
                        XY_CTHL_TryCnt = 0;
                    }   
                }
            }
            else if(dwTickCount >= (XY_CTHL_AutoDelay +10000))
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_SF_Origin_ALARM,bRunning);
            }
            
            break;
        case 2: 
            if(!XY_CTHL_XKTD_Origin_IN && (dwTickCount >= XY_CTHL_AutoDelay))  //斜口推带原位离开
            {
                XY_CTHL_First_CT_VAVLE=0;
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 3;
                    XY_CTHL_XKDW_VAVLE = 1;
                    XY_CTHL_AutoDelay = dwTickCount + 20;
                }
            }
            else if(dwTickCount >= (XY_CTHL_AutoDelay+2000))
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_Origin_ALARM,bRunning);
            }
            break;
        case 3://斜口定位
            if(dwTickCount >= XY_CTHL_AutoDelay)
            {                   
                XY_CTHL_AutoStep = 4;
                //         XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XKDW_TD_DELAY;
            }  
            break;
        case 4:
            if(!cBanAuTo)
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    //          AxisContinueMoveAcc(X_AXIS,1000,DIR_P,800,600,10,10);//拖带电机    
                    AxisMovePosAccDecNotStop(X_AXIS,1600,150,600,1000,5,3,00);       
                    XY_CTHL_AutoStep = 5;
                    if(XY_CTHL_cZipCnt < 1)
                        XY_CTHL_AutoDelay = dwTickCount +350;
                    else
                        XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_FKJD_DELAY;
                    XY_CTHL_XSavePosBuff = dwXRealPos;
                    //        SetPos(X_AXIS, 0);  //启动位置设为0点
                    
                    dwXRealPos = 0;
                }
                
            }
            else //半自动
            {
                XY_CTHL_AutoStep = 5;
                XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_FKJD_DELAY;
                XY_CTHL_XSavePosBuff = dwXRealPos;
                // SetPos(X_AXIS, 0);  //启动位置设为0点
                
            }
            break;
        case 5:
            if(dwTickCount >= XY_CTHL_AutoDelay)
            {
                XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                
            }
            
            if(bCL_EN_FLG && (dwXRealPos >= 350) && XY_CTHL_XKSC_Limit_IN  && !cStopGN)
            {                    
                XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
            }
            
            if(XY_CTHL_XKSC_Limit_IN)   //方块上止到位
            {
                AxisEgmStop(X_AXIS);
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    //     user_datas[128] = dwXRealPos;
                    
                    XY_CTHL_QDXK_VAVLE = 1;
                    //   AxisMovePosAccDec(X_AXIS,1200,10,1200,1200,6,6,0);  
                    if(XY_CTHL_cZipCnt < 1 )
                        XY_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭 
                    
                    XY_CTHL_AutoStep = 6;
                    XY_CTHL_AutoDelay = dwTickCount + 5000;//斜口推带回原位报警时间
                    XY_CTHL_bLTCHECK_Delay = dwTickCount + 20;
                    //电机穿入可以启动
                    bCL_OK_FLG = 1;   //不用穿合链的话认为已经完成
                    if(cStopGN)
                    {
                        XY_CTHL_HLJJ_VAVLE=0;
                    }
                    if(bCL_EN_FLG && XY_CTHL_XKSC_Limit_IN && !cStopGN )
                    {
                        bCL_OK_FLG = 0;
                        XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                        XY_CTHL_CL_MotorStep = 1;
                        XY_CTHL_CL_MotorDelay = dwTickCount + XY_CTHL_PARAM_HLJJ_CL_DELAY;
                    }          
                }
            }
            else if(dwXRealPos >= (XY_CTHL_XSavePosBuff + 1500))
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_FKCXDW_ALARM,bRunning);  //方块插销定位异常警告                
            }  
            break;
            
        case 6:
            if(XY_CTHL_CL_MotorStep==0 )
            {
                XY_CTHL_XKTD_VAVLE = 0;   //斜口推带气缸关闭  
            }
            if(cStopGN)
            {
                XY_CTHL_XKTD_VAVLE=0;
                //    cStopGN=0;
            }
            if(XY_CTHL_XKTD_Origin_IN)      //斜口推带回到原位
            {
                if(bZhuangLiaoOkFlg && (XY_CTHL_ZhuangLiaoStep == 0))
                {
                    if(dwTickCount >= XY_CTHL_bLTCHECK_Delay )
                    {
                        if(XY_CTHL_HSLiao_Origin_IN)
                        {
                            if(!XY_CTHL_LTou_Check)
                            {
                                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                                {
                                    if(XY_CTHL_PARAM_TDFZ_LENTH && !X_DRV)  //拖带电机反转
                                    {
                                        AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_DXKFZ_LENTH,800,600,6,6,0); 
                                        if(!XY_CTHL_PARAM_NLSL_MODE)
                                            XY_CTHL_FKJD_VAVLE= 0;   //方块夹带气缸关
                                    }
                                    XY_CTHL_CTXM_VAVLE = 1; //穿头下模上升
                                    if(XY_CTHL_PARAM_CXXY_MODE)
                                        XY_CTHL_CXXY_VAVLE = 1;
                                    XY_CTHL_AutoStep = 7;
                                    

                                    XY_CTHL_bXiaMoSJ_Delay = dwTickCount +20;
                                    
                                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
                                }
                            }
                            else 
                            {
                                cWULATOUCnt=1;
                                XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);  // 没有拉头                               
                            }
                            
                        }
                        else if(dwTickCount >= XY_CTHL_AutoDelay )
                        {
                            XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Origin_ALARM,bRunning);        
                        }
                    }
                    
                }  
            }
            else if(dwTickCount >= XY_CTHL_AutoDelay && !cBanAuTo)
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_Origin_ALARM,bRunning); //斜口推带回到异常
            }
            break;
        case 7: 
            
                         
            
            if(XY_CTHL_CTM_Limit_IN) 
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    if(XY_CTHL_PARAM_NLSL_MODE)
                    {
                        XY_CTHL_XKTD_VAVLE=1;
                    }
                    XY_CTHL_FKJD_VAVLE=0;
                    XY_CTHL_JLTou_VAVLE = 0;
                    
                    XY_CTHL_AutoStep = 8;
                    XY_CTHL_AutoDelay = dwTickCount + 10;
                }
            }  
            else if(dwTickCount >= XY_CTHL_AutoDelay )
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Limit_ALARM,bRunning);  //穿头下模上升异常
            }
            break;
        case 8:
            if(!X_DRV)  
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    if(!XY_CTHL_PARAM_NLSL_MODE)
                        XY_CTHL_DXK_VAVLE=1;
                    else
                        XY_CTHL_XKTD_VAVLE=1;
                    
                    if(cQDXK_DXK)
                    {
                        XY_CTHL_AutoStep = 0;
                        bRunning = 0;
                        //  SetEn(X_AXIS, MOTOR_DISEN);
                    }
                    else
                    {
                        //    if(!XY_CTHL_PARAM_NLSL_MODE)
                        if(cBanAuTo)
                            XY_CTHL_AutoDelay = dwTickCount + 500;
                        else      
                            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_DXK_XKDW_Off_DELAY;
                        if(XY_CTHL_PARAM_NLSL_MODE)
                        {
                            if(XY_CTHL_XKTD_VAVLE)
                                XY_CTHL_AutoStep = 9;
                            else
                                XY_CTHL_XKTD_VAVLE=1;
                            
                        }
                        else
                            XY_CTHL_AutoStep = 9;
                    }
                }
            }
            break; 
        case 9: 
            if((dwTickCount >= XY_CTHL_AutoDelay) && (bCL_OK_FLG || cStopGN))  //顶斜口延时退斜口上止定位
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    //                   AxisMovePosAccDec(X_AXIS,2000,-150,1200,1200,3,6,0);  //反转1.5CM
                    XY_CTHL_XKDW_VAVLE = 0;    //斜口定位
                    XY_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸关
                    
                    XY_CTHL_AutoStep = 10;    
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XK_CR_DELAY;
                }
            }              
            break;
        case 10:          
            if(!cBanAuTo)
            {
                
                if((dwTickCount >= XY_CTHL_AutoDelay) && !X_DRV)
                {
                    if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                    {
                        
                        XY_CTHL_TD_MotorStep = 10;   //启动拖带穿入   
                        // XY_CTHL_FKJD_VAVLE= 0;
                        XY_CTHL_TD_MotorDelay = dwTickCount + 0;
                        XY_CTHL_AutoStep = 11;  
                    }
                    
                }
                
            }
            else
            {
                XY_CTHL_AutoStep = 801; 
                XY_CTHL_AutoDelay = dwTickCount + 2000;
                
            }
            break;
        case 801:
            if(dwTickCount >= XY_CTHL_AutoDelay)
            {
                
                bRunning=0;
                XY_CTHL_QDXK_VAVLE=0;
                XY_CTHL_XKTD_VAVLE = 0;
                XY_CTHL_DXK_VAVLE=0;
                XY_CTHL_AutoStep = 0; 
                
            }
            break;
        case 11:
            
            if(XY_CTHL_TD_MotorStep == 0)  //穿入定位完成
            {      
                //测试拖带定位  
                /*       XY_CTHL_AutoStep = 1;       
                XY_CTHL_AutoDelay = dwTickCount + 1000;
                if(cZipCnt<3)
                cZipCnt++;
                break;  */
                
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_XKDW_VAVLE = 0;    //斜口上止定位关
                    XY_CTHL_XKTD_VAVLE = 1;     //斜口推带气缸输出 
                    XY_CTHL_CXSCDW_VAVLE = 1;   //Y21 插销上止定位电磁阀
                    //    XY_CTHL_FKJD_VAVLE= 0;
                    if((XY_CTHL_CL_MotorStep == 0) && XY_CTHL_PARAM_CR_MODE)
                    {                          
                        XY_CTHL_CXQJD_VAVLE = 1;
                    }                 
                    XY_CTHL_AutoStep = 12; 
                }
                
                
            }  
            break;
            
        case 12: 
            if(!XY_CTHL_SF_Origin_IN  && XY_CTHL_PARAM_CR_MODE)
            {
                XY_CTHL_CXQJD_VAVLE = 0;
                if(XY_CTHL_CL_MotorStep==0)
                    XY_CTHL_CL_MotorStep = 40; 
                
                // SetEn(Y_AXIS, MOTOR_DISEN);
                
            }
            if((XY_CTHL_CL_MotorStep == 0)&& (XY_CTHL_SF_Origin_IN) )  //插销前夹带回到原位
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 14; 
                    XY_CTHL_CXQJD_VAVLE = 1;                    
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XCQJD_XCDW_DELAY;
                    if(cXcxcrCnt>0)
                        XY_CTHL_AutoDelay = dwTickCount + 300;
                }
            }
            break;
        case 14:
            if(dwTickCount >= XY_CTHL_AutoDelay)
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 15; 
                    XY_CTHL_XKDW_VAVLE = 1; //斜口定位 
                    XY_CTHL_FKGD_VAVLE = 1;     //方块固定
                    //Y轴启动插销
                    XY_CTHL_CL_MotorStep = 20;  //插销定位          
                }
            }
            break;
        case 15:   
            if(XY_CTHL_CL_MotorStep == 0)   //插销定位完成
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 16; 
                    if(!XY_CTHL_PARAM_XCDWGY_MODE)
                        XY_CTHL_CXDWZ_VAVLE = 1;    //插销定位针(到位)电磁阀
                    
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_XCCR_DEALY;  //延时插销下移
                }
            }  
            break;
        case 16: 
            if(dwTickCount >= XY_CTHL_AutoDelay)
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 17; 
                    if(XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE = 0;
                    else
                        XY_CTHL_CXXY_VAVLE = 1;     //Y06 插销下移电磁阀
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;  //插销下移异常时间
                    XY_CTHL_SQJD_Delay= dwTickCount + XY_CTHL_PARAM_TQJD_DELAY;
                }
            }
            break;
        case 17:   
            if(dwTickCount >= XY_CTHL_SQJD_Delay) 
            { 
                if(XY_CTHL_PARAM_CXXY_MODE)
                {
                    if(XY_CTHL_CXXY_Origin_IN)
                    {
                        if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                        {
                            XY_CTHL_AutoStep = 18; 
                            if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
                            {
                                AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_TDFZ_LENTH,800,600,6,6,0);               
                            }
                            //    XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                            if(XY_CTHL_PARAM_CR_MODE == 0) 
                                //                   XY_CTHL_CXHT_VAVLE = 0;
                                XY_CTHL_SQJD_Delay= dwTickCount + XY_CTHL_PARAM_TQJD_DELAY;
                            XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                            XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关                    
                            XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_SCDWOff_CXDW_DELAY;
                        }
                        
                    }  
                    else if(dwTickCount >= XY_CTHL_AutoDelay)  
                    {
                        XY_CTHL_SetAlarmCode(XY_CTHL_CXXY_Limit_ALARM,bRunning); //插销下移异常
                        
                    }
                }
                else
                {
                    if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                    {
                        
                        XY_CTHL_AutoStep = 18; 
                        if( cXcxcrCnt==0 && !X_DRV && !cCXCONE)  //拖带电机反转
                        {
                            AxisMovePosAccDec(X_AXIS,8000,-XY_CTHL_PARAM_TDFZ_LENTH,800,600,15,15,0);               
                        }
                        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                        if(XY_CTHL_PARAM_CR_MODE == 0) 
                            //                   XY_CTHL_CXHT_VAVLE = 0;
                            
                            XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关   
                        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                        XY_CTHL_CXHJD_VAVLE = 1;         //Y14 插销后夹带输出
                        XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_SCDWOff_CXDW_DELAY;
                        
                    }
                    
                }
            }
            break;
        case 18:   
            
            //              if(START_IN_UP)
            {
                if(dwTickCount >= XY_CTHL_AutoDelay) 
                {
                    if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                    {
                        XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带电磁阀
                        XY_CTHL_AutoStep = 19; 
                        
                        XY_CTHL_CXHDW_VAVLE = 1;     //插销后定位(插销穿入)
                        XY_CTHL_AutoDelay = dwTickCount + 500;  //插销穿入到位异常时间
                        XY_CTHL_CL_MotorStep = 50;  //合链电机回原点
                    }
                }
            }
            break;
        case 19:                 
            if((XY_CTHL_CX_Limit_IN || XY_CTHL_PARAM_XCDWGY_MODE) && (cXcxcrCnt<4 || XY_CTHL_PARAM_CXTHREE_MODE))
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    if(!XY_CTHL_PARAM_XCDWGY_MODE || XY_CTHL_PARAM_XCDWGY_MODE==1)
                    {
                        cXcxcrCnt=0;
                        cXiaoChaCNT=0;
                        user_datas[100]=0;
                        XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关   
                        bZhuangLiaoOkFlg = 0;
                        XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀
                        XY_CTHL_AutoStep = 901;
                        if(XY_CTHL_PARAM_XCDWGY_MODE==1)
                            XY_CTHL_bTFKGD_Delay = dwTickCount + XY_CTHL_PARAM_FKGD_DELAY+70; //退方块固定时间
                        else
                            XY_CTHL_bTFKGD_Delay = dwTickCount + XY_CTHL_PARAM_FKGD_DELAY; //退方块固定时间
                        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                    }
                    else if(XY_CTHL_PARAM_XCDWGY_MODE==2)
                    {
                        XY_CTHL_AutoStep = 901;
                        XY_CTHL_bTFKGD_Delay = dwTickCount + XY_CTHL_PARAM_FKGD_DELAY; //退方块固定时间
                        
                    }
                }
            }
            
            
            else if ((dwTickCount >= XY_CTHL_AutoDelay) && (cXcxcrCnt<3)  && !XY_CTHL_PARAM_CXTHREE_MODE)
            {
                cXcxcrCnt++;
                XY_CTHL_CXHJD_VAVLE=0;
                //   XY_CTHL_FKJD_VAVLE=0;
                XY_CTHL_CXHDW_VAVLE=0;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1;
                
                if(cXcxcrCnt<3)
                {
                    //  XY_CTHL_CXDWZ_VAVLE = 0;
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                }
            }
            else if((dwTickCount >= (XY_CTHL_AutoDelay +1500)) && XY_CTHL_PARAM_CXTHREE_MODE && !XY_CTHL_CX_Limit_IN && !XY_CTHL_PARAM_XCDWGY_MODE )
            {
                cXiaoChaCNT=1;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1; 
                
                XY_CTHL_CXHJD_VAVLE =0;
                
                cBAOHUCNT=1;
                XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                if(XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_SetAlarmCode(0,bRunning); 
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                    cXiaoChaCNT=0;
                    cBAOHUCNT=0;
                    cXcxcrCnt=0;
                    XY_CTHL_CXHJD_VAVLE=0;
                    XY_CTHL_CXHDW_VAVLE=0;
                    if(!XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE=0;
                    else
                        XY_CTHL_CXXY_VAVLE=1;
                    
                }
            }
            
            if(( cXcxcrCnt > 2) &&  !XY_CTHL_PARAM_CXTHREE_MODE)
            {
                cXiaoChaCNT=1;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1; 
                
                XY_CTHL_CXHJD_VAVLE =0;
                cBAOHUCNT=1;
                XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                if(XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_SetAlarmCode(0,bRunning); 
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                    XY_CTHL_CXHJD_VAVLE=0;
                    cXiaoChaCNT=0;
                    cBAOHUCNT=0;
                    cXcxcrCnt=0;
                    XY_CTHL_CXHDW_VAVLE=0;
                    if(!XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE=0;
                    else
                        XY_CTHL_CXXY_VAVLE=1;
                    
                }
            }
            
            break;
        case 901:
            if(dwTickCount >= XY_CTHL_bTFKGD_Delay)
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    if(XY_CTHL_PARAM_XCDWGY_MODE==2)
                    {
                        XY_CTHL_AutoDelay = dwTickCount + 1000;//插销穿入异常时间
                        XY_CTHL_CXSCDW_VAVLE = 0;   //Y21 插销上止定位关   
                        bZhuangLiaoOkFlg = 0;
                        XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀
                        
                        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀 
                        XY_CTHL_AutoStep = 902;
                    }
                    else
                    {   
                        XY_CTHL_AutoStep = 20;
                        if(!cBAOHUCNT)
                            XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
                        else
                        {
                            XY_CTHL_AutoDelay = dwTickCount + 1000;//手动插销保护时间
                            cBAOHUCNT=0;
                        }
                    }
                    
                }
                
            }
            break;
        case 902:
            if((XY_CTHL_CX_Limit_IN ) && (cXcxcrCnt<4 || XY_CTHL_PARAM_CXTHREE_MODE))
            {
                XY_CTHL_AutoStep = 20;
                cXcxcrCnt=0;
                cXiaoChaCNT=0;
                user_datas[100]=0;
                if(!cBAOHUCNT)
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
                else
                {
                    XY_CTHL_AutoDelay = dwTickCount + 1000;//手动插销保护时间
                    cBAOHUCNT=0;
                }
                
            }
            else if ((dwTickCount >= XY_CTHL_AutoDelay) && (cXcxcrCnt<3)  && !XY_CTHL_PARAM_CXTHREE_MODE)
            {
                cXcxcrCnt++;
                XY_CTHL_CXHJD_VAVLE=0;
                //   XY_CTHL_FKJD_VAVLE=0;
                XY_CTHL_CXHDW_VAVLE=0;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1;
                
                if(cXcxcrCnt<3)
                {
                    //  XY_CTHL_CXDWZ_VAVLE = 0;
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                }
            }
            else if((dwTickCount >= (XY_CTHL_AutoDelay +3000)) && XY_CTHL_PARAM_CXTHREE_MODE && !XY_CTHL_CX_Limit_IN )
            {
                cXiaoChaCNT=1;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1; 
                
                XY_CTHL_CXHJD_VAVLE =0;
                
                cBAOHUCNT=1;
                XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                if(XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_SetAlarmCode(0,bRunning); 
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                    cXiaoChaCNT=0;
                    cBAOHUCNT=0;
                    cXcxcrCnt=0;
                    XY_CTHL_CXHJD_VAVLE=0;
                    XY_CTHL_CXHDW_VAVLE=0;
                    if(!XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE=0;
                    else
                        XY_CTHL_CXXY_VAVLE=1;
                    
                }
            }
            
            if(( cXcxcrCnt > 2) &&  !XY_CTHL_PARAM_CXTHREE_MODE)
            {
                cXiaoChaCNT=1;
                if(!XY_CTHL_PARAM_CXXY_MODE)
                    XY_CTHL_CXXY_VAVLE=0;
                else
                    XY_CTHL_CXXY_VAVLE=1; 
                
                XY_CTHL_CXHJD_VAVLE =0;
                cBAOHUCNT=1;
                XY_CTHL_SetAlarmCode(XY_CTHL_CX_Limit_ALARM ,bRunning);//插销穿入到位异常  
                if(XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_SetAlarmCode(0,bRunning); 
                    XY_CTHL_CXSCDW_VAVLE=1;
                    XY_CTHL_AutoStep = 12;
                    XY_CTHL_CXHJD_VAVLE=0;
                    cXiaoChaCNT=0;
                    cBAOHUCNT=0;
                    cXcxcrCnt=0;
                    XY_CTHL_CXHDW_VAVLE=0;
                    if(!XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE=0;
                    else
                        XY_CTHL_CXXY_VAVLE=1;
                    
                }
            }
            
            
            break;
        case 20:  
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 21;
                    XY_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
                    
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
                }
                
            }
            break;
        case 21:   
            
            if(!XY_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 22;
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
                }
            }
            else if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
            }
            break;
        case 22:
            if(dwTickCount >= XY_CTHL_bTFKGD_Delay)
            {
                XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
            }
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 23;
                    XY_CTHL_MGuo_VAVLE = 0;     //码勾退
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_PARAM_MGOff_XiaMo_DELAY;
                    XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
                    XY_CTHL_FKJD_VAVLE=0;
                    XY_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
                    XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀关
                }
            } 
            break;
        case 23:  
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_AutoStep = 24;
                    XY_CTHL_CTXM_VAVLE = 0; //穿头下模下降  
                    

                    XY_CTHL_bXiaMoSJ_Delay = dwTickCount +150;
                    
                    
                    XY_CTHL_AutoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
                }
            } 
            break;
        case 24: 
            
            if(!XY_CTHL_CTM_Limit_IN)
            {
                
                XY_CTHL_AutoStep = 25;
                XY_CTHL_AutoDelay = dwTickCount + 20;  //一次穿入延时返回
            }
            else if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);//穿头下模下降异常
            }
            break;
        case 25:
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                
            }
            if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
            {
                XY_CTHL_AutoStep = 26;
                XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                XY_CTHL_AutoDelay = dwTickCount + 5;
                XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
                //退下出错警告
                XY_CTHL_AutoDelay1 = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
                XY_CTHL_AutoStep1 = 1;
            }
            
            break;
        case 26: 
            cONERROR=0;
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
                
            }
            if(dwTickCount >= XY_CTHL_AutoDelay) 
            {
                //     XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
                if(!XY_CTHL_DANBU_MODE || XY_CTHL_START_IN_UP)
                {
                    XY_CTHL_FKGD_VAVLE = 0;     //方块固定关 
                    if(!cCXCONE)
                    {
                        XY_CTHL_AutoStep = 4;
                        bCL_EN_FLG = 1;
                        
                        AddToTal(XY_CTHL_TOTAL_ADDR); 
                        AddToTal(XY_CTHL_TRUST_ALARM_ADDR ); 
                        AddToTal( XY_CTHL_TEST_ALARM_ADDR);
                        CalProSP(XY_CTHL_SPEED_ADDR);
                        if(XY_CTHL_cZipCnt<3)
                            XY_CTHL_cZipCnt++;
                    }
                    else
                    {
                        bRunning=0;
                        cCXCONE=0;
                        XY_CTHL_AutoStep = 0;
                    }
                }
                
                
            }
            break;
            
        }   
    }       
    //退下模后启动送拉头
    switch(XY_CTHL_AutoStep1)
    {   
    case 1:
        if(cStopMode==1 || bSingOneFlg)
        {
            //  cStopMode=2;
            if(cStopGN)
                bCL_EN_FLG=0;
            else
                bCL_EN_FLG = 1;
            cZhouWanone=1;
            cZhouWantwo =1;
            cStopGN=0;
            
        }
        if(XY_CTHL_CTM_Origin_IN && XY_CTHL_First_CT_Origin_IN)
        {
            XY_CTHL_ZhuangLiaoStep = 1;
            XY_CTHL_TryCnt = 0;
            XY_CTHL_AutoStep1 = 0;
            XY_CTHL_MGuo_VAVLE = 0;
            XY_CTHL_JLTou_VAVLE = 0;
        }
        else if(dwTickCount >= XY_CTHL_AutoDelay1) 
        {
            //穿头模和一次穿入回位异常
            if(!XY_CTHL_CTM_Origin_IN)
                XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);
            else if(!XY_CTHL_First_CT_Origin_IN)
                XY_CTHL_SetAlarmCode(XY_CTHL_First_CT_Origin_ALARM,bRunning);                    
        } 
        break;
        
    }  
    
}





void XY_CTHL_CheckStart(void)
{
    if(cXCXQXQD)
    {
        if(XY_CTHL_START_IN_UP || bStart)
        {
            cONERROR=0;
            bStart=0;
            if(!bRunning)
            {
                if(XY_CTHL_SafeDoor_IN || !XY_CTHL_ANQUANMEN_MODE)
                {
                    bRunning=1;             
                    cXCXQXQD =0;  
                    cStopGN=0;
                    XY_CTHL_TD_MotorStep = 0;   
                    XY_CTHL_AutoStep=11;
                }
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                }
            }
        }
        
        
    }
    if(cBanAuTo)
    {
        if(XY_CTHL_START_IN_UP || bStart)
        {
            cONERROR=0;
            bStart=0;
            if(XY_CTHL_SafeDoor_IN || !XY_CTHL_ANQUANMEN_MODE)
            {  
                if(!bRunning)
                {
                    bRunning=1;
                    XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
                    XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                    cBanAuTo=0;  
                    cStopGN=0;
                    XY_CTHL_PARAM_BanAuto_MODE=0;
                    XY_CTHL_PARAM_ZDP_AUTO= 0;
                    XY_CTHL_ZhuangLiaoStep = 1; 
                    bTuiLaTouOkFlg = 1;
                    bZhuangLiaoOkFlg= 0;
                    
                    
                    
                    
                    if(GetEn(Y_AXIS) == MOTOR_DISEN) 
                    {
                        SetEn(Y_AXIS, MOTOR_EN);
                        XY_CTHL_AutoDelay = dwTickCount + 260;   //锁轴时间
                        
                    }
                    
                    if(GetEn(X_AXIS) == MOTOR_DISEN) 
                    {
                        SetEn(X_AXIS, MOTOR_EN);
                        XY_CTHL_AutoDelay = dwTickCount + 300; //步进电机锁轴时间
                        
                    }
                    else  //已经锁轴
                        XY_CTHL_AutoDelay = dwTickCount + 5;  
                    XY_CTHL_AutoStep=10;
                }
            }
            else
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                
            }
        }
    }
    
    if(cWULATOUCnt) // 无拉头警告后按
    {
        if(XY_CTHL_START_IN_UP | bStart)
        {
            cONERROR=0;
            bStart=0;
            if(!bRunning)
            {
                if(XY_CTHL_SafeDoor_IN || !XY_CTHL_ANQUANMEN_MODE)
                {  
                    bRunning=1;
                    XY_CTHL_TryCnt=0;
                    XY_CTHL_First_CT_VAVLE=0;
                    cWULATOUCnt=0;
                    cStopGN=0;
                    XY_CTHL_ZhuangLiaoStep = 1; 
                    XY_CTHL_AutoStep=6;
                    XY_CTHL_PARAM_ZDP_AUTO= 0;
                    bTuiLaTouOkFlg = 1;
                    bZhuangLiaoOkFlg= 0;
                    XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                    XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
                }
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
                }
                
            }
        }
    }
    if(XY_CTHL_SafeDoor_IN_DW && bRunning && XY_CTHL_ANQUANMEN_MODE && !cBanAuTo && !cCXCONE)
    {
        bStop=1;
        cStopGN=1;
        bCL_EN_FLG=0;
        XY_CTHL_HLJJ_VAVLE=0;
        XY_CTHL_CL_MotorStep=0;
        AxisEgmStop(Y_AXIS);
        // XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
    }
    
    //启动    自动启动 单一自动	 			
    if((XY_CTHL_START_IN_UP || bStart || XY_CTHL_bSingleone) && !cWULATOUCnt && !cBanAuTo && !cXCXQXQD)
    {
        
        
        if(cCHULIANBAOJIN) //无链停机启动
        {
            bRunning=1;
            cCHULIANBAOJIN=0;
            SetEn(X_AXIS, MOTOR_EN);
            //      dwXRealPos=0;
            XY_CTHL_TD_MotorStep=10;
            XY_CTHL_AutoStep = 11;  
            XY_CTHL_ColorStep=0;
            XY_CTHL_cZipCnt=0;
            cStopGN=0;
            if(GetAlarm(Y_AXIS)==0 || (GetAlarm(X_AXIS)==0 && XY_CTHL_MotorChose_MODE))
            {
                SetClr(Y_AXIS, MOTOR_NOALARM);
                SetClr(X_AXIS, MOTOR_NOALARM);
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 500;
            }
            
            XY_CTHL_TD_MotorDelay = dwTickCount + 500;
            XY_CTHL_AutoDelay = dwTickCount + 150;
            if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
                SetAlarmCode(XY_CTHL_ALARM_ADDR,0);   
            
        }
        
        
        if(!bRunning )
            
        {
            if(XY_CTHL_SafeDoor_IN || !XY_CTHL_ANQUANMEN_MODE)
            {  
                if(XY_CTHL_bSingleone)
                {
                    bSingOneFlg=1;
                }
                if(cStopMode>1)
                    bCL_EN_FLG = 0;
                cStopMode=0;
                bRunning = 1;
                cSTOPLENGTH=0;
                cHeLian=0;
                cStopGN=0;
                //  cONERROR=0;
                cCXCONE=0;
                //  XY_CTHL_DANBU_MODE=0;
                cXiaoChaTest=0;
                cWULATOUCnt=0;
                XY_CTHL_SD_VAVLE=0;
                XY_CTHL_PARAM_BanAuto_MODE=0;
                SetEn(X_AXIS, MOTOR_EN);
                SetEn(Y_AXIS, MOTOR_EN);        
                XY_CTHL_CL_MotorStep = 40;
                if(GetEn(X_AXIS) == MOTOR_DISEN) 
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    XY_CTHL_AutoDelay = dwTickCount + 300; //步进电机锁轴时间
                }
                else  //已经锁轴
                    XY_CTHL_AutoDelay = dwTickCount + 5;  
                
                XY_CTHL_AutoStep = 1;
                bTuiLaTouOkFlg = 1;
                XY_CTHL_PARAM_ZDP_AUTO= 0;
                bZhuangLiaoOkFlg= 0;
                XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
                XY_CTHL_First_CT_VAVLE=0;
                XY_CTHL_cZipCnt = 0;
                cQDXK_DXK=0;
                XY_CTHL_LianLengthCheck = 0;
                cStopInCnt = 0;
            }
            else
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_SafeDoor_ALARM,0);  // 安全门关上才能启动
            }      
            
        }  
        cONERROR=0;
        bStart = 0;
        XY_CTHL_bSingleone=0;
    } 
    if(cZhouWantwo)
    {
        cZhouWantwo=0;
        if(cZhouWanone)
        {
            bRunning=0;
            cZhouWanone=0;
            //       cStopMode=0;
            bSingOneFlg=0;
            cXiaoChaTest=0;
            cXcxcrCnt=0;
            cStopGN=0;
            cCHULIANBAOJIN=0;
            cBanAuTo=0;
            cONERROR=0;
            XY_CTHL_cZipCnt=0;
            cBAOHUCNT=0;
            //   bCL_EN_FLG = 0;
            cWULATOUCnt=0;
            AxisEgmStop(X_AXIS);
            if(XY_CTHL_SF_Origin_IN)
            {
                XY_CTHL_CL_MotorStep =0;      
                AxisEgmStop(Y_AXIS);
                SetPos(Y_AXIS, 0); 
            }
            SetPos(X_AXIS, 0); 
            dwYRealPos=0;
            SetEn(X_AXIS, MOTOR_DISEN);
            //    XY_CTHL_AutoDelay = dwTickCount;
            XY_CTHL_AutoStep = 0; 
            
            XY_CTHL_bCLFirst_Step=0;  
            //   XY_CTHL_ZhuangLiaoStep=0;
            //     XY_CTHL_AutoDelay = dwTickCount;
            //  XY_CTHL_XKTD_VAVLE = 0; 
            cQDXK_DXK=0;
            //  XY_CTHL_XKDW_VAVLE =0;
            
            if(!XY_CTHL_SF_ALR_IN )
            {
                XY_CTHL_SF_ALR_CLR=1;
                
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
            }
            
            if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
                SetAlarmCode(XY_CTHL_ALARM_ADDR,0);    
        }
    }
    /*
    if(XY_CTHL_STOP_IN_UP || XY_CTHL_STOPone)
    {
    if(bRunning)
    {   
    bRunning=0;
    XY_CTHL_AutoDelay = dwTickCount;
    cXcxcrCnt=0;
    if(cStopMode<3)
    cStopMode=0;
    cXCXQXQD=0;
    bSingOneFlg=0;
    bCL_EN_FLG = 0;
    cBAOHUCNT=0;
    cBanAuTo=0;
    cXiaoChaTest=0;
    cCHULIANBAOJIN=0;
    XY_CTHL_XiaJiangXM_VAVLE=1;
    cWULATOUCnt=0;
    AxisEgmStop(X_AXIS);
    AxisEgmStop(Y_AXIS);
    SetEn(X_AXIS, MOTOR_DISEN);
    //     SetEn(Y_AXIS, MOTOR_DISEN);
    cStopMode=0;
    cQDXK_DXK=0;
    if(!XY_CTHL_SF_ALR_IN )
    {
    XY_CTHL_SF_ALR_CLR=1;
    XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
}
    if(GetAlarm(Y_AXIS)==0)
    {
    SetClr(Y_AXIS, MOTOR_NOALARM);
    XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
}
    XY_CTHL_TLiao_VAVLE=0;             
    XY_CTHL_HSLiao_VAVLE  =0;    
    XY_CTHL_JLTou_VAVLE  =0; 
    XY_CTHL_QDXK_VAVLE=0;
    XY_CTHL_XKTD_VAVLE  =0;        
    XY_CTHL_XKDW_VAVLE  =0;       
    XY_CTHL_DXK_VAVLE  =0;         
    XY_CTHL_CXXY_VAVLE  =0;         
    XY_CTHL_CTXM_VAVLE =0;         
    XY_CTHL_First_CT_VAVLE =0;     
    XY_CTHL_FKGD_VAVLE =0;         
    XY_CTHL_CXQJD_VAVLE =0;        
    XY_CTHL_CXDWZ_VAVLE  =0;       
    XY_CTHL_CXHJD_VAVLE =0;        
    XY_CTHL_CXHDW_VAVLE =0;        
    XY_CTHL_FKJD_VAVLE  =0;        
    XY_CTHL_HLJJ_VAVLE  =0;                       
    XY_CTHL_CXSCDW_VAVLE =0;
    XY_CTHL_DLP_VAVLE=0;
    if(XY_CTHL_CTM_Origin_IN || !XY_CTHL_CXSC_Limit_IN || (cBanAuTo && !XY_CTHL_CXSC_Limit_IN)  || bRunning)
    XY_CTHL_MGuo_VAVLE =0;
    XY_CTHL_AutoDelay = dwTickCount;             
    XY_CTHL_AutoStep = 0;
    XY_CTHL_ZhuangLiaoStep=0;
    XY_CTHL_TLiaoStep=0;
    XY_CTHL_TD_MotorStep=0;
    XY_CTHL_JiaLianStep  =0;     
    //   XY_CTHL_ZhenDongStep =0;       
    XY_CTHL_SongLiaoStep   =0; 
    XY_CTHL_ColorStep=0;
    XY_CTHL_CL_MotorStep =0;      
    XY_CTHL_AutoStep1  =0;
    XY_CTHL_bFKCXTDDW_Step=0;
    XY_CTHL_bCXCR_Step=0;
    XY_CTHL_bCLFirst_Step=0;
    if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
    SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
    SetPos(X_AXIS, 0); 
    
    XY_CTHL_TLiaoStep = 0; 
    XY_CTHL_AutoStep = 0;
    
    
}
    else if(!bRunning)
    {
    bRunning=0;
    cXcxcrCnt=0;
    if(cStopMode<3)
    cStopMode=0;
    bSingOneFlg=0;
    bCL_EN_FLG = 0;
    cBanAuTo=0;
    cXCXQXQD=0;
    cXiaoChaTest=0;
    cBAOHUCNT=0;
    cCHULIANBAOJIN=0;
    cWULATOUCnt=0;
    cDLPONE=0;
    
    
    XY_CTHL_XiaJiangXM_VAVLE=1;
    
    XY_CTHL_AutoDelay = dwTickCount;  
    AxisEgmStop(X_AXIS);
    AxisEgmStop(Y_AXIS);
    SetEn(X_AXIS, MOTOR_DISEN);
    SetEn(Y_AXIS, MOTOR_DISEN);
    cStopMode=0;
    cQDXK_DXK=0;
    if(!XY_CTHL_SF_ALR_IN )
    {
    XY_CTHL_SF_ALR_CLR=1;
    XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
}
    if(GetAlarm(Y_AXIS)==1)
    {
    SetClr(Y_AXIS, MOTOR_NOALARM);
    XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
}
    XY_CTHL_TLiao_VAVLE=0;             
    XY_CTHL_HSLiao_VAVLE  =0;    
    XY_CTHL_JLTou_VAVLE  =0; 
    XY_CTHL_QDXK_VAVLE=0;
    XY_CTHL_XKTD_VAVLE  =0;        
    XY_CTHL_XKDW_VAVLE  =0;       
    XY_CTHL_DXK_VAVLE  =0;         
    XY_CTHL_CXXY_VAVLE  =0;         
    XY_CTHL_CTXM_VAVLE =0;
    XY_CTHL_DLP_VAVLE=0;         
    XY_CTHL_SD_VAVLE=0;
    XY_CTHL_First_CT_VAVLE =0;     
    XY_CTHL_FKGD_VAVLE =0;         
    XY_CTHL_CXQJD_VAVLE =0;        
    XY_CTHL_CXDWZ_VAVLE  =0;       
    XY_CTHL_CXHJD_VAVLE =0;        
    XY_CTHL_CXHDW_VAVLE =0;        
    XY_CTHL_FKJD_VAVLE  =0;        
    XY_CTHL_HLJJ_VAVLE  =0;                       
    XY_CTHL_CXSCDW_VAVLE =0;
    if(XY_CTHL_CTM_Origin_IN || !XY_CTHL_CXSC_Limit_IN || (cBanAuTo && !XY_CTHL_CXSC_Limit_IN) || bRunning)
    XY_CTHL_MGuo_VAVLE =0;
    XY_CTHL_AutoDelay = dwTickCount;
    XY_CTHL_ColorStep=0;
    XY_CTHL_AutoStep = 0;
    XY_CTHL_ZhuangLiaoStep=0;
    XY_CTHL_TLiaoStep=0;
    XY_CTHL_TD_MotorStep=0;
    XY_CTHL_JiaLianStep  =0;     
    //   XY_CTHL_ZhenDongStep =0;       
    XY_CTHL_SongLiaoStep   =0;     
    XY_CTHL_CL_MotorStep =0;      
    XY_CTHL_AutoStep1  =0;
    XY_CTHL_bFKCXTDDW_Step=0;
    XY_CTHL_bCXCR_Step=0;
    XY_CTHL_bCLFirst_Step=0;
    if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
    SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
    SetPos(X_AXIS, 0); 
    
    XY_CTHL_TLiaoStep = 0; 
    XY_CTHL_AutoStep = 0;
    
    //穿合链电机是往零点方向时可以停止
    if(GetDir(Y_AXIS) == DIR_N)
    AxisEgmStop(Y_AXIS);
    
}
    XY_CTHL_STOPone=0;
}
    */
    //停止
    if(XY_CTHL_STOP_IN_UP || bStop)
    {	
        XY_CTHL_PARAM_BanAuto_MODE=0;
        if(cStopMode < 2)
            cStopMode++;
        if(cStopMode==1 && bRunning)
            cZhouWanone=1;
        if(bRunning && cStopMode==2)
        {   
            bRunning=0;
            XY_CTHL_AutoDelay = dwTickCount;
            cXcxcrCnt=0;
            XY_CTHL_PARAM_BanAuto_MODE=0;
            if(cStopMode<3)
                cStopMode=0;
            cXCXQXQD=0;
            bSingOneFlg=0;
            bCL_EN_FLG = 0;
            cBAOHUCNT=0;
            cONERROR=0;
            cBanAuTo=0;
            XY_CTHL_DANBU_MODE=0;
            cXiaoChaTest=0;
            cCHULIANBAOJIN=0;
            cWULATOUCnt=0;
            AxisEgmStop(X_AXIS);
            AxisEgmStop(Y_AXIS);
            SetEn(X_AXIS, MOTOR_DISEN);
            //     SetEn(Y_AXIS, MOTOR_DISEN);
            cStopMode=0;
            cQDXK_DXK=0;
            if(!XY_CTHL_SF_ALR_IN )
            {
                XY_CTHL_SF_ALR_CLR=1;
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
            }
            if(GetAlarm(Y_AXIS)==0 || (GetAlarm(X_AXIS)==0 && XY_CTHL_MotorChose_MODE))
            {
                SetClr(Y_AXIS, MOTOR_NOALARM);
                SetClr(X_AXIS, MOTOR_NOALARM);
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
            }
            XY_CTHL_TLiao_VAVLE=0;             
            XY_CTHL_HSLiao_VAVLE  =0;    
            XY_CTHL_JLTou_VAVLE  =0; 
            XY_CTHL_QDXK_VAVLE=0;
            XY_CTHL_XKTD_VAVLE  =0;        
            XY_CTHL_XKDW_VAVLE  =0;       
            XY_CTHL_DXK_VAVLE  =0;         
            XY_CTHL_CXXY_VAVLE  =0;  
            XY_CTHL_MGuo_VAVLE =0;
            XY_CTHL_CTXM_VAVLE =0;        
            XY_CTHL_First_CT_VAVLE =0;     
            XY_CTHL_FKGD_VAVLE =0;         
            XY_CTHL_CXQJD_VAVLE =0;        
            XY_CTHL_CXDWZ_VAVLE  =0;       
            XY_CTHL_CXHJD_VAVLE =0;        
            XY_CTHL_CXHDW_VAVLE =0;        
            XY_CTHL_FKJD_VAVLE  =0;        
            XY_CTHL_HLJJ_VAVLE  =0;                       
            XY_CTHL_CXSCDW_VAVLE =0;
            XY_CTHL_DLP_VAVLE=0;
            if(XY_CTHL_CTM_Origin_IN || !XY_CTHL_CXSC_Limit_IN || (cBanAuTo && !XY_CTHL_CXSC_Limit_IN)  || bRunning)
                XY_CTHL_MGuo_VAVLE =0;
            XY_CTHL_AutoDelay = dwTickCount;             
            XY_CTHL_AutoStep = 0;
            XY_CTHL_ZhuangLiaoStep=0;
            XY_CTHL_TLiaoStep=0;
            XY_CTHL_TD_MotorStep=0;
            XY_CTHL_JiaLianStep  =0;     
            //   XY_CTHL_ZhenDongStep =0;       
            XY_CTHL_SongLiaoStep   =0; 
            XY_CTHL_ColorStep=0;
            XY_CTHL_CL_MotorStep =0;      
            XY_CTHL_AutoStep1  =0;
            XY_CTHL_bFKCXTDDW_Step=0;
            XY_CTHL_bCXCR_Step=0;
            XY_CTHL_bCLFirst_Step=0;
            if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
                SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
            SetPos(X_AXIS, 0); 
            
            XY_CTHL_TLiaoStep = 0; 
            XY_CTHL_AutoStep = 0;
            
            
        }
        else if(!bRunning)
        {
            bRunning=0;
            cXcxcrCnt=0;
            if(cStopMode<3)
                cStopMode=0;
            bSingOneFlg=0;
            bCL_EN_FLG = 0;
            cBanAuTo=0;
            cSTOPLENGTH=0;
            if(!XY_CTHL_PARAM_ShiJue)
            {
                XY_CTHL_JIANCHE_VAVLE=0;
                XY_CTHL_XIANZHI_VAVLE=0;
                XY_CTHL_DINGCHU_VAVLE=0;
            }
            cXCXQXQD=0;
            cONERROR=0;
            cXiaoChaTest=0;
            cBAOHUCNT=0;
            cCHULIANBAOJIN=0;
            cWULATOUCnt=0;
            cDLPONE=0;
            cCXCONE=0;
            XY_CTHL_DANBU_MODE=0;
            
            XY_CTHL_PARAM_BanAuto_MODE=0;

            
            XY_CTHL_AutoDelay = dwTickCount;  
            AxisEgmStop(X_AXIS);
            AxisEgmStop(Y_AXIS);
            SetEn(X_AXIS, MOTOR_DISEN);
            SetEn(Y_AXIS, MOTOR_DISEN);
            cStopMode=0;
            cQDXK_DXK=0;
            if(!XY_CTHL_SF_ALR_IN )
            {
                XY_CTHL_SF_ALR_CLR=1;
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
            }
            if(GetAlarm(Y_AXIS)==0 ||  (GetAlarm(X_AXIS)==0 && XY_CTHL_MotorChose_MODE))
            {
                SetClr(Y_AXIS, MOTOR_NOALARM);
                SetClr(X_AXIS, MOTOR_NOALARM);
                XY_CTHL_bSFBBAOJIN_Delay= dwTickCount + 2000;
            }
            XY_CTHL_TLiao_VAVLE=0;             
            XY_CTHL_HSLiao_VAVLE  =0;    
            XY_CTHL_JLTou_VAVLE  =0; 
            XY_CTHL_QDXK_VAVLE=0;
            XY_CTHL_XKTD_VAVLE  =0;        
            XY_CTHL_XKDW_VAVLE  =0;       
            XY_CTHL_DXK_VAVLE  =0;         
            XY_CTHL_CXXY_VAVLE  =0;    
            XY_CTHL_CTXM_VAVLE =0;
            XY_CTHL_DLP_VAVLE=0;         
            XY_CTHL_First_CT_VAVLE =0;     
            XY_CTHL_FKGD_VAVLE =0;         
            XY_CTHL_CXQJD_VAVLE =0;        
            XY_CTHL_CXDWZ_VAVLE  =0;       
            XY_CTHL_CXHJD_VAVLE =0;        
            XY_CTHL_CXHDW_VAVLE =0;        
            XY_CTHL_FKJD_VAVLE  =0;        
            XY_CTHL_HLJJ_VAVLE  =0;                       
            XY_CTHL_CXSCDW_VAVLE =0;
            if(XY_CTHL_CTM_Origin_IN || !XY_CTHL_CXSC_Limit_IN || (cBanAuTo && !XY_CTHL_CXSC_Limit_IN) || bRunning)
                XY_CTHL_MGuo_VAVLE =0;
            XY_CTHL_AutoDelay = dwTickCount;
            XY_CTHL_ColorStep=0;
            XY_CTHL_AutoStep = 0;
            XY_CTHL_ZhuangLiaoStep=0;
            XY_CTHL_TLiaoStep=0;
            XY_CTHL_TD_MotorStep=0;
            XY_CTHL_JiaLianStep  =0;     
            //   XY_CTHL_ZhenDongStep =0;       
            XY_CTHL_SongLiaoStep   =0;     
            XY_CTHL_CL_MotorStep =0;      
            XY_CTHL_AutoStep1  =0;
            XY_CTHL_bFKCXTDDW_Step=0;
            XY_CTHL_bCXCR_Step=0;
            XY_CTHL_bCLFirst_Step=0;
            if(GetAlarmCode(XY_CTHL_ALARM_ADDR) != 0)
                SetAlarmCode(XY_CTHL_ALARM_ADDR,0);  
            SetPos(X_AXIS, 0); 
            
            XY_CTHL_TLiaoStep = 0; 
            XY_CTHL_AutoStep = 0;
            
            //穿合链电机是往零点方向时可以停止
            if(GetDir(Y_AXIS) == DIR_N)
                AxisEgmStop(Y_AXIS);
            
        }
        bStop=0;
    }
    
    if(bAlarmStop)
    {   
        bRunning   = 0;
        bAlarmStop=0;
        cStopMode=0;
        cXcxcrCnt=0;
        AxisEgmStop(X_AXIS);
        AxisEgmStop(Y_AXIS);
        XY_CTHL_AutoStep = 0; 
        XY_CTHL_CL_MotorStep =0;      
        XY_CTHL_bCLFirst_Step=0;  
        //  XY_CTHL_SongLiaoStep =0;
        //  XY_CTHL_ZhuangLiaoStep=0;
        //  XY_CTHL_TLiaoStep=0;
        //    XY_CTHL_TD_MotorStep=0;
        XY_CTHL_JiaLianStep  =0;             
        XY_CTHL_AutoStep1  =0;
        
        
    }
}   

//拖带电机控制动作  X轴
void XY_CTHL_TD_Motor(void)	 //
{   
#if 1
    switch(XY_CTHL_TD_MotorStep)
    {
        //1步开始，纯定位, 没有穿入
    case 1:
        if(dwTickCount >= XY_CTHL_TD_MotorDelay)  //给锁轴时间
        {
            bCheckEN_FLG = 1;
            XY_CTHL_SD_VAVLE=0;
            XY_CTHL_X_CXPosBuff=0;
            XY_CTHL_CheckInX02PosBuff= 0;
            XY_CTHL_TD_MotorStep = 2;   
            SetPos(X_AXIS, 0);  //启动位置设为0点
            AxisContinueMoveAcc(X_AXIS,XY_CTHL_PARAM_first_SPEED,DIR_P,3000,600,20,50);
        }  
        if(XY_CTHL_CXSC_Limit_IN_UP )
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            
        }  
        break;
    case 2://检测到过链
        
        
        if(dwXRealPos > 350)    //穿入2CM后退
        {
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关  
            XY_CTHL_QDXK_VAVLE=0;
            if(XY_CTHL_PARAM_NLSL_MODE)
            {
                XY_CTHL_XKTD_VAVLE=0;
            }
            
        }    
        if(dwXRealPos >= XY_CTHL_PARAM_DYTLL_LENTH)
        {
            if(bRunning)
            {
                cCHULIANBAOJIN=1;
                SetEn(X_AXIS, MOTOR_DISEN);
                AxisEgmStop(X_AXIS);
                SetPos(X_AXIS, 0);  //启动位置设为0点
                //    dwXRealPos=0;
            }
            SetEn(X_AXIS, MOTOR_DISEN);
            XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机              
        }
        if(XY_CTHL_FK_Check_UP)
        {
            XY_CTHL_SD_VAVLE=1;
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            XY_CTHL_QDXK_VAVLE=0;
            XY_CTHL_TD_MotorStep = 3; 
            //            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            //        XY_CTHL_TD_MotorStep = 3;  
            //    user_datas[123] = dwXRealPos - XY_CTHL_CheckInX02PosBuff;
            if((dwXRealPos >= XY_CTHL_CheckInX02PosBuff) && XY_CTHL_CheckInX02PosBuff)
                AxisMovePosAccDec(X_AXIS,XY_CTHL_GYHKSD_SPEED,XY_CTHL_PARAM_first_LENGTH,
                                  XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,300,XY_CTHL_StopSlow_LENGTH); 
            else
                AxisMovePosAccDec(X_AXIS,XY_CTHL_GYHKSD_SPEED,XY_CTHL_PARAM_first_LENGTH,
                                  XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,300,XY_CTHL_StopSlow_LENGTH); 
        }
        else if(XY_CTHL_CXSC_Limit_IN_DW && !XY_CTHL_PARAM_XCGY_MODE)
        {
            XY_CTHL_SetAlarmCode(XY_CTHL_FKGYYC_Limit_ALARM,bRunning);
        }
        else if(XY_CTHL_CXSC_Limit_IN_UP && !XY_CTHL_PARAM_XCGY_MODE)
        {
            AxisMovePosAccDec(X_AXIS,XY_CTHL_PARAM_first_SPEED * 7/10,XY_CTHL_PARAM_FKDW_Length,
                              XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,10,150,XY_CTHL_StopSlow_LENGTH); 
        }
        if(XY_CTHL_FK_Check_DW)
        {
            
            XY_CTHL_XSavePosBuff = dwXRealPos;
            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            
            
        }
        if(XY_CTHL_CXSC_Limit_IN_UP )
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            
        }  
        break;
    case 3:  
        
        if(XY_CTHL_FK_Check_DW)
        {
            
            XY_CTHL_XSavePosBuff = dwXRealPos;
            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            
            
        }
        if(XY_CTHL_CXSC_Limit_IN_UP )
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            
        }  
        
        if(!X_DRV)// || (dwXRealPos >= (XY_CTHL_XSavePosBuff + XY_CTHL_PARAM_FKDW_Length)))
        {
            AxisEgmStop(X_AXIS);
            if(!bRunning)
                XY_CTHL_FKJD_VAVLE = 0;   //方块夹带气缸输出
            XY_CTHL_TD_MotorStep =4 ;             
            //    user_datas[122] = dwXRealPos-XY_CTHL_XSavePosBuff;
            XY_CTHL_LianLengthAutoCheckOLD = XY_CTHL_LianLengthAutoCheck;
            XY_CTHL_LianLengthAutoCheck = dwXRealPos;
        }
        break;
    case 4:
        if(XY_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
        {
            
            if ((dwXRealPos - XY_CTHL_X_CXPosBuff) > (XY_CTHL_PARAM_XCX_LENTH + XY_CTHL_PARAM_XCXWC_LENTH)) 
            {
                user_datas[121] = 1;
                XY_CTHL_TD_MotorStep = 0;
                XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                
            }         
            
            else if(XY_CTHL_X_CXPosBuff == 0)
            {
                user_datas[121] = 3;
                XY_CTHL_TD_MotorStep = 0;
                XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }   
            else
            {
                XY_CTHL_TD_MotorStep = 0;
                XY_CTHL_X_CXPosBuff=dwXRealPos;
                
            }
            
        }
        else
        {
            XY_CTHL_TD_MotorStep = 0;
            //     XY_CTHL_X_CXPosBuff=dwXRealPos;
        }
        break;
        
        //穿拉头定位
    case 10:   
        if(dwTickCount >= XY_CTHL_TD_MotorDelay)
        {
            SetPos(X_AXIS, 0);  //启动位置设为0点
            dwXRealPos = 0;
            XY_CTHL_SD_VAVLE=0;
            XY_CTHL_TD_MotorStep = 11;              
            XY_CTHL_X_CXPosBuff=0;          
            AxisContinueMoveAcc(X_AXIS,XY_CTHL_XCCR_SPEED,DIR_P,1200,1200,15,15);   
            XY_CTHL_CheckInX02PosBuff= 0;
            bCheckEN_FLG = 1;
        }
        break;
    case 11:   
        ctwoone=0;
        if(dwXRealPos > 350)    //穿入2CM后退
        {
            if(XY_CTHL_PARAM_NLSL_MODE)
            {
                XY_CTHL_XKTD_VAVLE=0;
            }
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            //  XY_CTHL_QDXK_VAVLE =0;
        }
        if(dwXRealPos > 350)    //穿入2CM后退
        {
            if(XY_CTHL_PARAM_NLSL_MODE)
            {
                XY_CTHL_XKTD_VAVLE=0;
            }
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            XY_CTHL_QDXK_VAVLE =0;
        }
        if(dwXRealPos > XY_CTHL_XCCR_LENGTH)    //穿入2CM后退
        {
            XY_CTHL_CheckInX02PosBuff= 0;
            
            
            
            XY_CTHL_TD_MotorStep = 12;
            if(((XY_CTHL_cZipCnt < 2) || (XY_CTHL_LianLengthCheck < XY_CTHL_XCCR_LENGTH)) || XY_CTHL_DANBU_MODE)
                AxisContinueMoveAcc(X_AXIS,XY_CTHL_PARAM_first_SPEED,DIR_P,3000,600,20,50); 
            else ////两段速度移动距离                
                AxisMovePosAccDecNotStop(X_AXIS,XY_CTHL_PARAM_TD_RunSpeed,XY_CTHL_LianLengthCheck-XY_CTHL_XCCR_LENGTH,1500,7000,25,300,250); 
            
        }
        if(XY_CTHL_CXSC_Limit_IN_UP)
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            
        }  
        break;
    case 12://检测到过链
        if(dwXRealPos > 350)    //穿入2CM后退
        {
            if(XY_CTHL_PARAM_NLSL_MODE)
            {
                XY_CTHL_XKTD_VAVLE=0;
            }
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            //  XY_CTHL_QDXK_VAVLE =0;
        }
        if(dwXRealPos > 350)    //穿入2CM后退
        {
            if(XY_CTHL_PARAM_NLSL_MODE)
            {
                XY_CTHL_XKTD_VAVLE=0;
            }
            XY_CTHL_DXK_VAVLE = 0;   //顶斜口气缸关
            XY_CTHL_QDXK_VAVLE =0;
        }
        if(XY_CTHL_PARAM_SD_MODE)
        {
            if(XY_CTHL_cZipCnt>1)
            {
                if(dwXRealPos> XY_CTHL_LianLengthCheck-XY_CTHL_PARAM_SD_LENGTH)
                    XY_CTHL_SD_VAVLE=1;
            }
        }
        if(XY_CTHL_cZipCnt>1)
        {
            if(dwXRealPos >= (XY_CTHL_PARAM_WLCDSHEZHI_LENTH+ XY_CTHL_LianLengthAutoCheckERROR))
            {
                if(bRunning)
                {
                    cCHULIANBAOJIN=1;
                    SetEn(X_AXIS, MOTOR_DISEN);
                    AxisEgmStop(X_AXIS);
                    SetPos(X_AXIS, 0);  //启动位置设为0点
                    //     dwXRealPos=0;
                }
                XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机
                SetEn(X_AXIS, MOTOR_DISEN);
                XY_CTHL_TD_MotorStep = 0; 
                XY_CTHL_AutoStep=0;
            }
        }
        else if(XY_CTHL_cZipCnt < 2 )
        {
            
            if(dwXRealPos >= XY_CTHL_PARAM_DYTLL_LENTH)
            {
                if(bRunning)
                {
                    cCHULIANBAOJIN=1;
                    SetEn(X_AXIS, MOTOR_DISEN);
                    AxisEgmStop(X_AXIS);
                    SetPos(X_AXIS, 0);  //启动位置设为0点
                    //     dwXRealPos=0;
                }
                XY_CTHL_SetAlarmCode(XY_CTHL_WLZDTJ_ALARM,bRunning);   //无拉链自动停机
                SetEn(X_AXIS, MOTOR_DISEN);
                XY_CTHL_TD_MotorStep = 0;
                XY_CTHL_AutoStep=0;
            }
        }
        
        
        if(XY_CTHL_FK_Check_UP)
        {
            XY_CTHL_SD_VAVLE=1;
            XY_CTHL_TD_MotorDelay= dwTickCount + XY_CTHL_PARAM_FKJDSECONG_DEALY;
            if( dwXRealPos<(XY_CTHL_LianLengthCheck*0.8) && XY_CTHL_cZipCnt > 1)
            {
                cSTOPLENGTH=1; 
                XY_CTHL_cZipCnt=0;
            }
            if(XY_CTHL_cZipCnt == 1)
                XY_CTHL_LianLengthCheck = dwXRealPos;
            
            
            
            
            //变短重新量尺寸   
            XY_CTHL_LianLengthCheckOLD=XY_CTHL_LianLengthNEWCheck;
            XY_CTHL_LianLengthNEWCheck  = dwXRealPos; 
            //     XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            //break;
            XY_CTHL_XSavePosBuff = dwXRealPos;
            XY_CTHL_TD_MotorStep = 13;  
            //     user_datas[122] = XY_CTHL_PARAM_FKDW_Length - (dwXRealPos- XY_CTHL_CheckInX02PosBuff);
            if(!cSTOPLENGTH || XY_CTHL_MotorChose_MODE)
            {
                if(XY_CTHL_cZipCnt > 1 && !XY_CTHL_DANBU_MODE)
                {
                    if((dwXRealPos >= XY_CTHL_CheckInX02PosBuff) && XY_CTHL_CheckInX02PosBuff)
                        AxisMovePosAccDec(X_AXIS,XY_CTHL_GYHKSD_SPEED,XY_CTHL_PARAM_FKDW_Length- (dwXRealPos- XY_CTHL_CheckInX02PosBuff),
                                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,250,XY_CTHL_StopSlow_LENGTH); 
                    else
                        AxisMovePosAccDec(X_AXIS,XY_CTHL_GYHKSD_SPEED,XY_CTHL_PARAM_FKDW_Length,
                                          XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,250,XY_CTHL_StopSlow_LENGTH); 
                }
                else
                {
                    AxisMovePosAccDec(X_AXIS, XY_CTHL_GYHKSD_SPEED, XY_CTHL_PARAM_first_LENGTH,
                                      XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,250,XY_CTHL_StopSlow_LENGTH); 
                    
                }
            }
            else if(cSTOPLENGTH && !XY_CTHL_MotorChose_MODE)
            {
                AxisMovePosAccDec(X_AXIS, XY_CTHL_GYHKSD_SPEED*7/10, XY_CTHL_PARAM_first_LENGTH-XY_CTHL_PARAM_STOP_length,
                                  XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,250,XY_CTHL_StopSlow_LENGTH); 
                XY_CTHL_cZipCnt=0;
                cSTOPLENGTH=0;
            }
            
            //XY_CTHL_TD_MotorStep = 0;  
        }
        else if(XY_CTHL_CXSC_Limit_IN_DW && !XY_CTHL_PARAM_XCGY_MODE)
        {
            XY_CTHL_SetAlarmCode(XY_CTHL_FKGYYC_Limit_ALARM,bRunning);
            SetEn(X_AXIS, MOTOR_DISEN);
            XY_CTHL_TD_MotorStep = 0; 
            XY_CTHL_AutoStep=0;
        }
        else if(XY_CTHL_CXSC_Limit_IN_UP && !XY_CTHL_PARAM_XCGY_MODE)
        {
            
            AxisMovePosAccDec(X_AXIS,XY_CTHL_GYHKSD_SPEED,XY_CTHL_PARAM_first_LENGTH,
                              XY_CTHL_PARAM_FKDW_Speed,XY_CTHL_PARAM_FKDW_Speed,20,300,XY_CTHL_StopSlow_LENGTH); 
            ctwoone=1;
        }
        if(ctwoone)
        {
            if(!X_DRV)
            {
                
                XY_CTHL_SetAlarmCode(XY_CTHL_FKGYYC_Limit_ALARM,bRunning);
                SetEn(X_AXIS, MOTOR_DISEN);
                XY_CTHL_TD_MotorStep = 0; 
                XY_CTHL_AutoStep=0;
                ctwoone=0;
            }
        }
        if(XY_CTHL_FK_Check_DW)
        {
            //   XY_CTHL_XSavePosBuff = dwXRealPos;
            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            
            
        }
        if(XY_CTHL_CXSC_Limit_IN_UP)
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            
        }  
        break;   
    case 13:
        
        if(dwTickCount >= XY_CTHL_TD_MotorDelay)
        {
            XY_CTHL_FKJD_VAVLE = 1;   //方块夹带气缸输出
            
        }
        
        if(XY_CTHL_CXSC_Limit_IN_UP)
        {
            
            XY_CTHL_X_CXPosBuff = dwXRealPos;
            user_datas[121] = dwXRealPos;
            
        }    
        
        if((!X_DRV ) || (dwXRealPos >= (XY_CTHL_XSavePosBuff + XY_CTHL_PARAM_FKDW_Length) && (XY_CTHL_cZipCnt > 1))  || (dwXRealPos >= (XY_CTHL_XSavePosBuff + XY_CTHL_PARAM_first_LENGTH) && (XY_CTHL_cZipCnt < 2)))
        {
            //    user_datas[123] = dwXRealPos-XY_CTHL_CheckInX02PosBuff;
            AxisEgmStop(X_AXIS);
            XY_CTHL_QDXK_VAVLE =0;
            XY_CTHL_TD_MotorStep = 14; 
            /*     if(XY_CTHL_cZipCnt>2)
            {
            if(((XY_CTHL_LianLengthNEWCheck+XY_CTHL_LianLengthCheckOLD)*0.5) < (XY_CTHL_LianLengthCheck*0.95))
            {
            XY_CTHL_cZipCnt=0;  
            cHeLian=1;
        }
        }   */
            user_datas[122] = dwXRealPos-XY_CTHL_X_CXPosBuff;
            if(XY_CTHL_cZipCnt==1)
                XY_CTHL_LianLengthAutoCheckERROR = dwXRealPos;
            XY_CTHL_LianLengthAutoCheckOLD = XY_CTHL_LianLengthAutoCheck;
            XY_CTHL_LianLengthAutoCheck = dwXRealPos;
            if(XY_CTHL_cZipCnt==1 )
                XY_CTHL_LianLengSave=dwXRealPos;
        }
        break;
    case 14:
        if(XY_CTHL_PARAM_XCX_LENTH)   //0的话不判断位置
        {
            
            if ((dwXRealPos - XY_CTHL_X_CXPosBuff) > (XY_CTHL_PARAM_XCX_LENTH + XY_CTHL_PARAM_XCXWC_LENTH)) 
            {
                //  user_datas[121] = 1;
                XY_CTHL_TD_MotorStep = 0;
                cXCXQXQD=1;
                XY_CTHL_CXQJD_VAVLE=0;
                XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
                
            }         
            else if((dwXRealPos - XY_CTHL_X_CXPosBuff) < (XY_CTHL_PARAM_XCX_LENTH - XY_CTHL_PARAM_XCXWC_LENTH))
            {
                //   user_datas[121] = 2;
                XY_CTHL_TD_MotorStep = 0;
                cXCXQXQD=1;
                XY_CTHL_CXQJD_VAVLE=0;
                XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }    
            else if(XY_CTHL_X_CXPosBuff == 0)
            {
                //    user_datas[121] = 3;
                XY_CTHL_TD_MotorStep = 0;
                cXCXQXQD=1;
                XY_CTHL_CXQJD_VAVLE=0;
                XY_CTHL_SetAlarmCode(XY_CTHL_XCXXCYC_ALARM,bRunning);        // 小插销行程异常
            }   
            else
            {
                
                XY_CTHL_TD_MotorStep = 0;
            }
            
        }
        else
        {
            
            XY_CTHL_TD_MotorStep = 0;
        }
        break;
        
        
        
    }   
#endif    
}
//穿入电机动作，Y轴
void XY_CTHL_CL_Motor(void)	 //
{   
#if 1
    //1步开始,  穿链长度开始
    //20步开始  插销定位开始
    //40步,回原点为
    switch(XY_CTHL_CL_MotorStep)
    {
        //穿入长度位置
    case 1:
        
        if(dwTickCount >= XY_CTHL_CL_MotorDelay)
        {
            
            //     if(!cHeLian)
            //    {
            if(!XY_CTHL_PARAM_AUTO_MODE) 
            {
                //穿入长度要根据检测长度减动一次穿入的3CM,反转的2CM
                if(XY_CTHL_LianLengthAutoCheck <=700)
                {
                    XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-500;
                    if(XY_CTHL_Y_CL_Length<=0)
                        XY_CTHL_Y_CL_Length=200;
                    if(XY_CTHL_Y_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
                        XY_CTHL_Y_CL_Length = XY_CTHL_PARAM_CL_MAX_Length-40;  
                    AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,XY_CTHL_Y_CL_Length,2000,2000,50,50,50);
                }
                else if(XY_CTHL_LianLengthAutoCheck>700)
                {
                    
                    user_datas[123] =XY_CTHL_LianLengthAutoCheck;
                    if(XY_CTHL_cZipCnt<2)
                        XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-XY_CTHL_PARAM_HLTSY_LENTH; 
                    else
                        XY_CTHL_Y_CL_Length=XY_CTHL_LianLengSave-XY_CTHL_PARAM_HLTSY_LENTH;
                    if(XY_CTHL_Y_CL_Length<=0)
                        XY_CTHL_Y_CL_Length=300;
                    if(XY_CTHL_Y_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
                        XY_CTHL_Y_CL_Length = XY_CTHL_PARAM_CL_MAX_Length-40;  
                    AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,XY_CTHL_Y_CL_Length,2000,2000,50,50,50);
                } 
                
                /*            else
                {
                XY_CTHL_Y_CL_Length=XY_CTHL_LianLengthAutoCheck-XY_CTHL_PARAM_HLTSY_LENTH -500;
                cHeLian=0;
                if(XY_CTHL_Y_CL_Length<0)
                XY_CTHL_Y_CL_Length=200;
                AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,XY_CTHL_Y_CL_Length,2000,2000,50,50,50);
                
            }*/
                
            }
            else
            {
                
                if(XY_CTHL_PARAM_CL_Length >= XY_CTHL_PARAM_CL_MAX_Length)
                    XY_CTHL_PARAM_CL_Length = XY_CTHL_PARAM_CL_MAX_Length;
                //穿入长度要根据检测长度减动一次穿入的1CM,反转的2CM
                if((XY_CTHL_LianLengthAutoCheck < (XY_CTHL_PARAM_CL_Length + 500 )) && bRunning) 
                    AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_LianLengthAutoCheck-500),800,600,6,6,50);       
                else
                    AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_CL_Speed,(XY_CTHL_PARAM_CL_Length-100),800,600,6,6,50); 
                
                
                
            }
            XY_CTHL_CL_MotorStep = 2; 
            cHeLianone=0;
        }
        break;
    case 2:
        if(XY_CTHL_cZipCnt>0)
        {
            if(dwYRealPos>700)
            {
                if(!cHeLianone )
                {
                    XY_CTHL_XKTD_VAVLE=0;//斜口推带退
                    cHeLianone=1;
                }
                
            }
            
            if(XY_CTHL_LianLengSave<3000)
            {
                if(dwYRealPos>100)
                {
                    if(!cHeLianone )
                    {
                        XY_CTHL_XKTD_VAVLE=0;//斜口推带退
                        cHeLianone=1;
                    }
                    
                }
            }
        }
        if(cStopGN)
        {
            XY_CTHL_XKTD_VAVLE=0;
        }
        
        if(XY_CTHL_PARAM_AUTO_MODE)
        {
            if((dwYRealPos + 120) > XY_CTHL_PARAM_CL_Length)
                XY_CTHL_HLJJ_VAVLE = 0;
            if(!Y_DRV || dwYRealPos >= XY_CTHL_PARAM_CL_Length)  
            {
                XY_CTHL_HLJJ_VAVLE = 0;
                XY_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
                XY_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
            }
        }
        else
        {
            if((dwYRealPos + 120) > XY_CTHL_Y_CL_Length)
                XY_CTHL_HLJJ_VAVLE = 0;
            if(!Y_DRV || dwYRealPos >= XY_CTHL_Y_CL_Length)  
            {
                XY_CTHL_HLJJ_VAVLE = 0;
                XY_CTHL_CL_MotorStep = 3;  
                bCL_OK_FLG = 1;
                XY_CTHL_CL_MotorDelay = dwTickCount + 30;  //延时数控回零点
            }
            
        }
        break; 
    case 3: 
        if(cStopGN)
        {
            XY_CTHL_XKTD_VAVLE=0;
        }
        if(dwTickCount >= XY_CTHL_CL_MotorDelay)
        {
            
            XY_CTHL_CL_MotorStep = 50; 
            //       SetDir(Y_AXIS, DIR_N);
        }
        break;
    case 10:    
        if(dwTickCount >= XY_CTHL_CL_MotorDelay)
        {
            XY_CTHL_CL_MotorStep = 11;
            bCL_OK_FLG = 1;               
            XY_CTHL_HLJJ_VAVLE = 0;
            //                XY_CTHL_HL_VAVLE = 0;
        }
        break;
    case 11:          
        XY_CTHL_CL_MotorStep = 0; 
        break;  
        //夹带插销到穿入位置  
    case 20: //此处最好算好定位长度相减
        if(XY_CTHL_PARAM_CR_MODE != 0)
        {
            if(cXcxcrCnt > 0)
            {
                if(cXcxcrCnt==1)
                    XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length+XY_CTHL_PARAM_TDFZ_LENTH + 50; 
                if(cXcxcrCnt>1)
                    XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length +XY_CTHL_PARAM_TDFZ_LENTH + 120;
                XY_CTHL_CL_MotorStep = 21;
            }
            else
            {
                XY_CTHL_LENTH = XY_CTHL_PARAM_CXDW_Length ;
                XY_CTHL_CL_MotorStep = 21;
            }    
        }
        else
        {
            XY_CTHL_CL_MotorStep = 21;
        }
        break;
    case 21:
        
        if(cXiaoChaTest)
        {
            if(XY_CTHL_PARAM_CR_MODE != 0)
            {
                if(dwTickCount >= XY_CTHL_CL_MotorDelay)
                {
                    XY_CTHL_CL_MotorDelay = dwTickCount + 2000;  //延时数控回零点
                    AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_LXC_SPEED,XY_CTHL_LENTH,800,500,6,6,50);            
                    XY_CTHL_CL_MotorStep = 22; 
                }
                else
                {
                    
                    //                XY_CTHL_CXHT_VAVLE = 1;
                    XY_CTHL_CL_MotorDelay = dwTickCount +2000;
                    XY_CTHL_CL_MotorStep = 22; 
                }
            }
        }
        else
        {
            if(XY_CTHL_PARAM_CR_MODE != 0)
            {
                AxisMovePosAccDec(Y_AXIS,XY_CTHL_PARAM_LXC_SPEED,XY_CTHL_LENTH,800,500,6,6,50);            
                XY_CTHL_CL_MotorStep = 22; 
            }
            else       
            {
                //                    XY_CTHL_CXHT_VAVLE = 1;
                XY_CTHL_CL_MotorDelay = dwTickCount + 500;//XY_CTHL_PARAM_XXHT_Time;
                XY_CTHL_CL_MotorStep = 22; 
                
            }
        }
        
        
        break;
    case 22: 
        
        if(cXiaoChaTest)
        {
            if(XY_CTHL_PARAM_CR_MODE != 0)
            {
                if(dwTickCount >= (XY_CTHL_CL_MotorDelay-1000))
                {
                    XY_CTHL_CXQJD_VAVLE = 0;
                }
                
                if(dwTickCount >= XY_CTHL_CL_MotorDelay)
                {
                    XY_CTHL_CL_MotorStep = 40;  
                    
                    cXiaoChaTest=0;
                }
            }
            else
            {
                if(dwTickCount >= XY_CTHL_CL_MotorDelay)
                {
                    //      XY_CTHL_CXHT_VAVLE = 0;
                    XY_CTHL_CL_MotorStep = 0;   
                }
            }        
        }
        else
        {
            if(XY_CTHL_PARAM_CR_MODE != 0)   
            {
                if(!Y_DRV || (dwYRealPos >= XY_CTHL_LENTH)) //插销定位已经结束
                {
                    AxisEgmStop(Y_AXIS);
                    XY_CTHL_YsaveCXDWPosBuff = 0;
                    XY_CTHL_CL_MotorStep = 0;                       
                } 
            }
            else
            {
                if(dwTickCount >= XY_CTHL_CL_MotorDelay)
                {
                    //         XY_CTHL_CXHT_VAVLE = 0;
                    XY_CTHL_CL_MotorStep = 0;   
                }
                
            }
            
        } 
        break;
        //回原点开始
    case 40: 
        //要先离开    
        if(XY_CTHL_SF_Origin_IN && (GetEn(Y_AXIS) == MOTOR_DISEN))  
        {
            XY_CTHL_CL_MotorStep = 41; 
            SetDir(Y_AXIS, DIR_P);
        }    
        else 
        {
            SetDir(Y_AXIS, DIR_N);
            XY_CTHL_CL_MotorStep = 46;
            
        }   
        
        if(GetEn(Y_AXIS) == MOTOR_DISEN) 
        {
            SetEn(Y_AXIS, MOTOR_EN);
            XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
            
        }
        else  //已经锁轴
            XY_CTHL_CL_MotorDelay = dwTickCount + 5;            
        break;
    case 41:
        if(dwTickCount >= XY_CTHL_CL_MotorDelay)
        {
            XY_CTHL_CL_MotorStep = 42; 
            AxisContinueMoveAcc(Y_AXIS,5000,DIR_P,1000,800,15,15);
        }
        break;
    case 42:
        if(!XY_CTHL_SF_Origin_IN)
        {
            XY_CTHL_CL_MotorStep = 43; 
            XY_CTHL_YSavePosBuff = dwYRealPos;
        }
        break;
    case 43:    
        //离开原点5CM停止
        if((dwYRealPos - XY_CTHL_YSavePosBuff) >= 800)
        {
            AxisEgmStop(Y_AXIS);
            XY_CTHL_CL_MotorStep = 46; //留空几步备用
            XY_CTHL_CL_MotorDelay = dwTickCount + 50;  
        }
        break;
    case 46:  
        if(dwTickCount >= XY_CTHL_CL_MotorDelay)
        {
            XY_CTHL_CL_MotorStep = 47; //检测回到原位
            if(!XY_CTHL_SF_Origin_IN)
                AxisContinueMoveAcc(Y_AXIS,1500,DIR_N,1000,800,15,35);
        }
        break;
    case 47: 
        if(XY_CTHL_SF_Origin_IN)
        {
            XY_CTHL_CL_MotorStep = 0;       
            AxisEgmStop(Y_AXIS); 
            SetPos(Y_AXIS, 0);
        }    
        break;
        //数控回原位 (条件为自动工作，SON一直没有松开)  
    case 50: 
        if(dwYRealPos > 150)
        {  //回零速度
            SetDir(Y_AXIS, DIR_N);
            AxisMovePosAccDecNotStop(Y_AXIS,XY_CTHL_PARAM_CL_Back_O_Speed,-dwYRealPos + 150,5000,2000,10,70,50);
            
            
        } 
        else
            AxisContinueMoveAcc(Y_AXIS,1000,DIR_N,1000,1000,15,35);
        XY_CTHL_CL_MotorStep = 51; 
        break;
    case 51: 
        if(XY_CTHL_SF_Origin_IN)
        {
            XY_CTHL_CL_MotorStep = 0;       
            AxisEgmStop(Y_AXIS); 
            SetPos(Y_AXIS, 0);
        } 
        break;
        
    }
#endif    
}



//装拉头动作
void XY_CTHL_ZLT_Step(void)
{
    
    switch(XY_CTHL_ZhuangLiaoStep)
    {
    case 1:   
        if(bZhuangLiaoOkFlg)
        {
            XY_CTHL_ZhuangLiaoStep = 0;
        }
        
        if(((XY_CTHL_MGuo_VAVLE && XY_CTHL_LTou_Check) || !XY_CTHL_MGuo_VAVLE)   )//说明没有拉头
        {       
            if(!XY_CTHL_JLiao_Limit_IN)
            {
                //穿头模和一次穿入必须在原位,接料不能有输出
                if(XY_CTHL_CTM_Origin_IN && !XY_CTHL_CTXM_VAVLE)
                {  
                    XY_CTHL_First_CT_VAVLE = 0;
                    // XY_CTHL_JLTou_VAVLE = 0;
                    XY_CTHL_MGuo_VAVLE = 0;                     
                    if(XY_CTHL_TLiaoStep == 0)
                    {
                        XY_CTHL_TLiaoStep = 1;        
                        XY_CTHL_ZhuangLiaoStep = 2; 
                    }
                }
                
                else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay + 500)  //警告横送拉必须保证穿头模和一次穿入在原位,接料不能有输出
                {
                    cWULATOUCnt=1;
                    XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning);
                    
                }  
            }
            else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay + 500)
            {
                cWULATOUCnt=1;
                XY_CTHL_SetAlarmCode(XY_CTHL_JLiao_Limit_ALARM,bRunning);
            }
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)  //已经有拉头直接跳到结束
        {
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + 40;
            XY_CTHL_ZhuangLiaoStep = 9;
        }  
        break;            
    case 2:        
        if(XY_CTHL_TLiaoStep == 0)  //推料已经完成
        {
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME ;
            XY_CTHL_JLTou_VAVLE = 0;
            XY_CTHL_MGuo_VAVLE = 0;   
            if(!XY_CTHL_JLiao_Limit_IN && XY_CTHL_First_CT_Origin_IN)
            {
                XY_CTHL_ZhuangLiaoStep = 3;
                XY_CTHL_HSLiao_VAVLE = 1;   
            }
            else
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_YCCRYWYC_ALARM,bRunning); 
            }
        }
        break;
    case 3:
        //横送到位
        if(XY_CTHL_HSLiao_Limit_IN && !XY_CTHL_HSLiao_Origin_IN)
        {
            XY_CTHL_ZhuangLiaoStep = 4;

            XY_CTHL_ZhuangLiaoDelay = dwTickCount + 5;
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            cWULATOUCnt=1;
            XY_CTHL_HSLiao_VAVLE=0;
            XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Limit_ALARM,bRunning);
            if(bRunning)
            {
                XY_CTHL_ZhuangLiaoStep = 0 ;
            }  
        }
        break;
    case 4:
        if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            XY_CTHL_ZhuangLiaoStep = 5;
            XY_CTHL_JLTou_VAVLE = 1;    //接拉头输出,不需要时间
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME ;
        }  
        break;
    case 5:    
        if(XY_CTHL_JLiao_Limit_IN)
        {
            XY_CTHL_ZhuangLiaoStep = 6;
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_MaGou_DELAY;
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)  //接拉头(接料)到们信号异常
        {
            cWULATOUCnt=1;
            XY_CTHL_SetAlarmCode(XY_CTHL_JLiao_Limit_ALARM,bRunning);
        }
        break;
    case 6:       
        if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)  //延时码勾
        {
            XY_CTHL_MGuo_VAVLE = 1; //码勾输出
            XY_CTHL_ZhuangLiaoStep = 7;
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_HSLiaoOff_DELAY;
            bTuiLaTouOkFlg = 0;   //认为拉头没法带出
        }
        break;
    case 7:  
        if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            XY_CTHL_HSLiao_VAVLE = 0; 
            XY_CTHL_ZhuangLiaoStep = 8;
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME ;
        }
        break;
    case 8:  
        if(!XY_CTHL_HSLiao_Limit_IN)  //
        {
            XY_CTHL_ZhuangLiaoStep = 9;
            XY_CTHL_TLiaoStep = 1; //推拉头
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_PARAM_CheckLT_DELAY;   //也是给下模能上升的时间
        }          
        else if (XY_CTHL_LTou_Check)  //时间内信号这说明没有拉头
        {
            //重送3次
            XY_CTHL_TryCnt++;
            XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
            XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
            if(XY_CTHL_TryCnt >= 3)
            {
                XY_CTHL_TryCnt = 0;
                bZhuangLiaoOkFlg = 0;
                XY_CTHL_ZhuangLiaoStep = 0;
                XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);
                cWULATOUCnt=1;
            }
            else
            {
                XY_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME ;
            }  
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            cWULATOUCnt=1;
            XY_CTHL_HSLiao_VAVLE=0;
            XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Limit_ALARM,bRunning);
            if(bRunning)
            {
                XY_CTHL_ZhuangLiaoStep = 0 ;
            }  
        }  
        break;
    case 9:   
        if(XY_CTHL_LTou_Check)  //时间内信号这说明没有拉头
        {
            XY_CTHL_TryCnt++;
            XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
            XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
            if(XY_CTHL_TryCnt >= 3)
            {
                XY_CTHL_TryCnt=0;
                bZhuangLiaoOkFlg = 0;
                XY_CTHL_ZhuangLiaoStep = 0;
                XY_CTHL_SetAlarmCode(XY_CTHL_ZLT_ALARM,bRunning);
                cWULATOUCnt=1;
            }
            else
            {
                XY_CTHL_ZhuangLiaoStep = 20;    //重新送3次   
                XY_CTHL_ZhuangLiaoDelay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME ;
            }  
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            bZhuangLiaoOkFlg = 1;
            if(XY_CTHL_AutoStep==6)
            {
                XY_CTHL_bLTCHECK_Delay=dwTickCount+30;
                XY_CTHL_AutoDelay = dwTickCount + 3000;//斜口推带回原位报警时间
            }
            XY_CTHL_ZhuangLiaoStep = 0;
        }
        break;
        //装拉头不成攻重新送拉头
    case 20: 
        if(XY_CTHL_HSLiao_Origin_IN)
        {
            XY_CTHL_JLTou_VAVLE = 0;    //接拉头关
            XY_CTHL_MGuo_VAVLE = 0;     //码勾打开
            XY_CTHL_ZhuangLiaoStep = 1;
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + 10;
        }
        else if(dwTickCount >= XY_CTHL_ZhuangLiaoDelay)
        {
            cWULATOUCnt=1;
            XY_CTHL_HSLiao_VAVLE=0;
            XY_CTHL_JLTou_VAVLE=0;
            XY_CTHL_SetAlarmCode(XY_CTHL_HSLiao_Origin_ALARM,bRunning);
        }  
        break;
    }  
}

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

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

void XY_CTHL_bCLFirstStep(void)
{
    switch(XY_CTHL_bCLFirst_Step)
    {
    case 19:   
        XY_CTHL_JLTou_VAVLE = 0;        //接拉头
        bZhuangLiaoOkFlg = 0;
        XY_CTHL_bCLFirst_Step = 20;
        XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
        XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_First_CL_DELAY;//延时一次穿入
        break;
    case 20:  
        if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            XY_CTHL_bCLFirst_Step = 21;
            XY_CTHL_First_CT_VAVLE = 1;   //一次穿入电磁阀输出
            XY_CTHL_bTFKGD_Delay = dwTickCount + XY_CTHL_PARAM_FKGD_DELAY; //退方块固定时间
            XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
        }
        break;
    case 21: 
        if(dwTickCount >= XY_CTHL_bTFKGD_Delay)
        {
            XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
        }
        if(!XY_CTHL_First_CT_Origin_IN)  //原点离开后才开始时间
        {
            XY_CTHL_bCLFirst_Step = 22;
            XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_First_CL_Timer;  //一次穿入时间
        }
        else if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            XY_CTHL_SetAlarmCode(XY_CTHL_YCCRYWYC_ALARM,bRunning); //一次穿入原位异常
        }
        break;
    case 22:
        if(dwTickCount >= XY_CTHL_bTFKGD_Delay)
        {
            XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
        }
        if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            XY_CTHL_bCLFirst_Step = 23;                                     
            XY_CTHL_MGuo_VAVLE = 0;     //码勾退
            XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_PARAM_MGOff_XiaMo_DELAY;
            XY_CTHL_FKGD_VAVLE = 0;     //方块固定退
            XY_CTHL_CXHJD_VAVLE = 0;    //Y14 插销后夹带打开 
            XY_CTHL_CXXY_VAVLE = 0;     //Y06 插销下移电磁阀关
        } 
        break;
    case 23:  
        if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            XY_CTHL_bCLFirst_Step = 24;
            XY_CTHL_CTXM_VAVLE = 0; //穿头下模下降
            XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
            XY_CTHL_bCLFirst_Delay = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
        } 
        break;
    case 24: 
        if(!XY_CTHL_CTM_Limit_IN)
        {
            XY_CTHL_bCLFirst_Step= 25;
            XY_CTHL_bCLFirst_Delay = dwTickCount + 25;  //一次穿入延时返回
        }
        else if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            XY_CTHL_SetAlarmCode(XY_CTHL_CTM_Origin_ALARM,bRunning); //穿头下模下降异常
        }
        break;
    case 25:
        if(dwTickCount >= XY_CTHL_bCLFirst_Delay) 
        {
            
            XY_CTHL_bCLFirst_Step= 0;
            XY_CTHL_First_CT_VAVLE = 0;   //一次穿入电磁阀关
            XY_CTHL_CXHDW_VAVLE = 0;     //插销后定位(插销穿入)关闭
            
            
            //退下出错警告
            XY_CTHL_AutoDelay1 = dwTickCount + XY_CTHL_VAVLE_ERROR_TIME;
            XY_CTHL_AutoStep1 = 1;
            bTuiLaTouOkFlg = 1;
        }
        break;
    }
}

//手动动作
void XY_CTHL_ManualAction(void)
{ 
    if(cBanAuTo)
    {
        XY_CTHL_PARAM_BanZiDong=1;
    }
    else  
    {
        XY_CTHL_PARAM_BanZiDong=0;
    }
    
    if(XY_CTHL_PARAM_CL_Length > XY_CTHL_PARAM_CL_MAX_Length)
    {
        XY_CTHL_PARAM_CL_Length = XY_CTHL_PARAM_CL_MAX_Length;
    }
    
    if(!XY_CTHL_SF_ALR_IN && ((GetAlarm(Y_AXIS)==0) || XY_CTHL_PARAM_DB_MODE)) // 伺服报警
    {
        XY_CTHL_SetAlarmCode(XY_CTHL_SF_ALR_ALARM,0);
    }
    
    if(dwTickCount >= XY_CTHL_bSFBBAOJIN_Delay)  
    {
        XY_CTHL_SF_ALR_CLR=0;
        SetClr(Y_AXIS,MOTOR_ALARM);
        SetClr(X_AXIS,MOTOR_ALARM);
    }
    
    if(bRunning == 0)  
    {   
        if(bClearTotal) //切断计数清零
        {
            bClearTotal       = 0;
            ClrcToTal(QDCT_TOTAL_ADDR);
        }
        if(XY_CTHL_bTLiao)                 //手动推料(推拉头)
        {
            XY_CTHL_bTLiao = 0;           
            if(XY_CTHL_TLiao_VAVLE)
                XY_CTHL_TLiao_VAVLE = 0;//XY_CTHL_TLiao_VAVLE; 
            else if(!XY_CTHL_HSLiao_VAVLE && XY_CTHL_HSLiao_Origin_IN)
            {
                XY_CTHL_TLiao_VAVLE = 1;
            } 
            else//条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_HENSONGLIAO_ALARM,0); // 横送料不能输出
            }            
        } 
      
        if(XY_CTHL_bHSL)     //手动横送料   
        {
            XY_CTHL_bHSL= 0;
            if(!XY_CTHL_First_CT_VAVLE)
            {
                if(XY_CTHL_HSLiao_VAVLE)
                {
                    XY_CTHL_HSLiao_VAVLE = 0;//~XY_CTHL_HSLiao_VAVLE;
                }
                else if(XY_CTHL_First_CT_Origin_IN &&
                        !XY_CTHL_JLTou_VAVLE && !XY_CTHL_CTXM_VAVLE && !XY_CTHL_CXDWZ_VAVLE && (!XY_CTHL_bMG || (XY_CTHL_bMG && XY_CTHL_LTou_Check)))
                {
                    if(!XY_CTHL_TLiao_VAVLE && XY_CTHL_TLiao_Origin_IN)
                    {
                        if(!XY_CTHL_JLiao_Limit_IN)
                        {
                            if(XY_CTHL_CTM_Origin_IN)
                                XY_CTHL_HSLiao_VAVLE = 1;
                            else
                                XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0);
                        }
                        else
                        {
                            XY_CTHL_SetAlarmCode(XY_CTHL_JLiao_Limit_ALARM,0);
                        }
                    }
                    else
                    {
                        XY_CTHL_SetAlarmCode(XY_CTHL_TLiao_Limit_ALARM,0);
                    }
                }  
                else   //条件警告  最后一个括号条件为已经有拉头
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_YCCT_ALARM,0); 
                }  
            }
        }           
        if(XY_CTHL_bJLT)                  //接拉头
        {
            XY_CTHL_bJLT = 0;
            if(XY_CTHL_JLTou_VAVLE)
                XY_CTHL_JLTou_VAVLE = 0;
            else if(!XY_CTHL_First_CT_VAVLE && !XY_CTHL_CTXM_VAVLE && XY_CTHL_CTM_Origin_IN )
            {
                if(XY_CTHL_First_CT_Origin_IN)
                {
                    XY_CTHL_MGuo_VAVLE = 0;
                    XY_CTHL_JLTou_VAVLE = 1;
                }
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_YCCT_ALARM,0);
                }
            } 
            else//条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0); 
            }
        } 
        if(XY_CTHL_bMG)                   //码勾
        {
            XY_CTHL_bMG = 0;
            XY_CTHL_MGuo_VAVLE = !XY_CTHL_MGuo_VAVLE;
        } 
        if(XY_CTHL_bFKJD)                 //方块夹带
        {
            XY_CTHL_bFKJD = 0;
            XY_CTHL_FKJD_VAVLE = !XY_CTHL_FKJD_VAVLE;
        } 
        if(XY_CTHL_bXKTD)                  //斜口推带
        {
            XY_CTHL_bXKTD = 0;
            if(XY_CTHL_XKTD_VAVLE)
                XY_CTHL_XKTD_VAVLE = 0;
            else if(!XY_CTHL_DXK_VAVLE )
            {
                if(!XY_CTHL_XKSC_Limit_IN  || !XY_CTHL_CTXM_VAVLE || XY_CTHL_PARAM_NLSL_MODE)
                    XY_CTHL_XKTD_VAVLE = 1;
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0);   
                }
            }
            else//条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_DXKCTXM_Origin_ALARM,0);          
            }
        } 
        if(XY_CTHL_bXKDW)                  //斜口定位
        {
            XY_CTHL_bXKDW = 0;
            XY_CTHL_XKDW_VAVLE = ~XY_CTHL_XKDW_VAVLE;
        } 
        if(XY_CTHL_bCTXM)                  //穿头下模
        {
            XY_CTHL_bCTXM = 0;
            if(XY_CTHL_CTXM_VAVLE)
            {
                

                cXMdelay=1;
                XY_CTHL_bXiaMoSJ_Delay = dwTickCount +250;
                
                XY_CTHL_CTXM_VAVLE = 0;
                XY_CTHL_JLTou_VAVLE = 0;
                
            }    
            else if(!XY_CTHL_HSLiao_VAVLE  && (!XY_CTHL_XKSC_Limit_IN || !XY_CTHL_XKTD_VAVLE))                
            { 
                if(XY_CTHL_HSLiao_Origin_IN)
                {
                    if(XY_CTHL_PARAM_CXXY_MODE)
                        XY_CTHL_CXXY_VAVLE = 1;
                    //  XY_CTHL_MGuo_VAVLE = 1;
                    XY_CTHL_CTXM_VAVLE = 1;
                    

                    cXMdelay=1;
                    XY_CTHL_bXiaMoSJ_Delay = dwTickCount + 30;
                }
                else
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_HENSONGLIAO_ALARM,0);  
                }
                
            }  
        }     
        if(cXMdelay)
        {
            if(dwTickCount >= XY_CTHL_bXiaMoSJ_Delay )
            {

                cXMdelay=0;
            }
        }
        
        if(XY_CTHL_bQianDXK)                  //前顶斜口
        {
            XY_CTHL_bQianDXK = 0;
            if(XY_CTHL_QDXK_VAVLE)
                XY_CTHL_QDXK_VAVLE = 0;
            else if(!XY_CTHL_XKTD_VAVLE)
                XY_CTHL_QDXK_VAVLE = 1;
            else  //条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_ALARM,0);   
            } 
        } 
        
        
        if(XY_CTHL_bDXK)                  //顶斜口
        {
            XY_CTHL_bDXK = 0;
            if(!XY_CTHL_PARAM_NLSL_MODE)
            {
                if(XY_CTHL_DXK_VAVLE)
                    XY_CTHL_DXK_VAVLE = 0;
                else if(!XY_CTHL_XKTD_VAVLE)
                {
                    if(!XY_CTHL_PARAM_NLSL_MODE)
                        XY_CTHL_DXK_VAVLE = 1;
                }
                else  //条件警告
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_XKTD_ALARM,0);   
                } 
            }
            else
            {
                if(XY_CTHL_XKTD_VAVLE)
                    XY_CTHL_XKTD_VAVLE = 0;
                else if(!XY_CTHL_DXK_VAVLE )
                {
                    if(!XY_CTHL_XKSC_Limit_IN  || !XY_CTHL_CTXM_VAVLE || XY_CTHL_PARAM_NLSL_MODE)
                        XY_CTHL_XKTD_VAVLE = 1;
                    else
                    {
                        XY_CTHL_SetAlarmCode(XY_CTHL_YCXM_Origin_ALARM,0);   
                    }
                }
                else//条件警告
                {
                    XY_CTHL_SetAlarmCode(XY_CTHL_DXKCTXM_Origin_ALARM,0);          
                }
                
                
                
            }
        } 
        
        if(XY_CTHL_bQianDXK_DXK)
        {
            XY_CTHL_bQianDXK_DXK = 0;
            if(!XY_CTHL_XKTD_VAVLE && XY_CTHL_AutoStep==0)
            {
                cQDXK_DXK=1;
                XY_CTHL_AutoStep = 8;
                
                if((GetEn(X_AXIS) == MOTOR_EN))          
                    XY_CTHL_AutoDelay = dwTickCount + 10;
                else
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    XY_CTHL_AutoDelay = dwTickCount + 1000;
                }
                bRunning=1;
            }
            
        }
        
        if(XY_CTHL_bFKGD)                 //方块固定
        {
            XY_CTHL_bFKGD = 0;
            XY_CTHL_FKGD_VAVLE = ~XY_CTHL_FKGD_VAVLE;
        } 
        if(XY_CTHL_bCXQJD)                 //插销前夹带
        {
            XY_CTHL_bCXQJD = 0;
            XY_CTHL_CXQJD_VAVLE = ~XY_CTHL_CXQJD_VAVLE;
        } 
        if(XY_CTHL_bCXSY)                 //插销下移电磁阀
        {
            XY_CTHL_bCXSY = 0;
            XY_CTHL_CXXY_VAVLE = !XY_CTHL_CXXY_VAVLE;
        } 
        if(XY_CTHL_bCXDWZ)                 //Y14 插销定位针电磁阀
        {
            XY_CTHL_bCXDWZ = 0;
            if(XY_CTHL_CXDWZ_VAVLE)
                XY_CTHL_CXDWZ_VAVLE = 0;
            else if(XY_CTHL_HSLiao_Origin_IN)
            {
                XY_CTHL_CXDWZ_VAVLE = 1;
            }
            else //条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_HENSONGLIAO_ALARM,0);   
            }           
        } 
       
        if(XY_CTHL_bCXHJD)                 //Y15 插销后夹带电磁阀
        {
            XY_CTHL_bCXHJD = 0;
            XY_CTHL_CXHJD_VAVLE = ~XY_CTHL_CXHJD_VAVLE;

        } 
        if(XY_CTHL_bCXHDW)                 //Y16 插销后定位电磁阀
        {
            XY_CTHL_bCXHDW = 0;
            if(XY_CTHL_CXHDW_VAVLE)
                XY_CTHL_CXHDW_VAVLE = 0;
            else if(!XY_CTHL_CXQJD_VAVLE)
                XY_CTHL_CXHDW_VAVLE = 1;
            else//条件警告
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_CXQJD_ALARM,0);  
            }
        } 
        
        if(XY_CTHL_bFirst_CT)              //Y20 一次穿头电磁阀
        {
            XY_CTHL_bFirst_CT = 0;
            XY_CTHL_First_CT_VAVLE = ~XY_CTHL_First_CT_VAVLE;
        } 
        if(XY_CTHL_DLP)              //Y20 一次穿头电磁阀
        {
            XY_CTHL_DLP = 0;
            if(!XY_CTHL_DLP_VAVLE)
            {
                cDLPONE=1;
                XY_CTHL_DLP_VAVLE=1;
            }
            else
            {
                cDLPONE=0;
                XY_CTHL_DLP_VAVLE=0;
                
            }
        } 
        if(XY_CTHL_bCXHT)
        {
            XY_CTHL_bCXHT = 0;
            //            XY_CTHL_CXHT_VAVLE = ~XY_CTHL_CXHT_VAVLE;
        }  
        //视觉功能模式
        if(XY_CTHL_bJianChe)
        {
            XY_CTHL_bJianChe = 0;
            XY_CTHL_JIANCHE_VAVLE = ~XY_CTHL_JIANCHE_VAVLE;
        }  
        if(XY_CTHL_bDingChu)
        {
            XY_CTHL_bDingChu = 0;
            XY_CTHL_DINGCHU_VAVLE = ~XY_CTHL_DINGCHU_VAVLE;
        }  
        if(XY_CTHL_bXianZhi)
        {
            XY_CTHL_bXianZhi = 0;
            XY_CTHL_XIANZHI_VAVLE = ~XY_CTHL_XIANZHI_VAVLE;
        }  
        
        
        if(XY_CTHL_SD)
        {
            XY_CTHL_SD = 0;
            XY_CTHL_SD_VAVLE = ~XY_CTHL_SD_VAVLE;
        }  
        //气缸合链已经不用
        if(XY_CTHL_bHL)
        {
            XY_CTHL_bHL = 0;
            //            XY_CTHL_HL_VAVLE = ~XY_CTHL_HL_VAVLE;
        }  
        if(XY_CTHL_bHLJJ)                  //Y21 合链夹具电磁阀
        {
            XY_CTHL_bHLJJ = 0;
            XY_CTHL_HLJJ_VAVLE = ~XY_CTHL_HLJJ_VAVLE;
        } 
        if(XY_CTHL_bCXSCDW)               //Y23 插销上止定位电磁阀 
        {
            XY_CTHL_bCXSCDW = 0;
            XY_CTHL_CXSCDW_VAVLE = ~XY_CTHL_CXSCDW_VAVLE;
        } 
        //自动装料
        if(XY_CTHL_bAutoZhuangLiao)
        {
            XY_CTHL_bAutoZhuangLiao = 0;
            if(XY_CTHL_ZhuangLiaoStep == 0)
            {
                bTuiLaTouOkFlg = 1;
                bZhuangLiaoOkFlg = 0;
                XY_CTHL_ZhuangLiaoStep = 1;
                XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
                XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
            }  
        }
        //测试电机
        if(XY_CTHL_bCLMotor_N)
        {           
            SetEn(Y_AXIS, MOTOR_EN);
            if(!XY_CTHL_SF_Origin_IN)
            {  
                if(!Y_DRV)
                    //                Y轴       运行速度                    启动速度        加速度  减速度
                    AxisContinueMoveAcc(Y_AXIS,2000,DIR_N,1000,1000,15,15);
            } 
            else
            {
                XY_CTHL_bCLMotor_N = 0;
            }
            
        }
        
        
        if(XY_CTHL_bCLMotor_P)  //后退限位已经取消
        {
            SetEn(Y_AXIS, MOTOR_EN);
            if(!Y_DRV)
                //                Y轴       运行速度                    启动速度        加速度  减速度
                AxisContinueMoveAcc(Y_AXIS,2000,DIR_P,1000,1000,15,15);
        }
        
        if(!XY_CTHL_bCLMotor_P && !XY_CTHL_bCLMotor_N && (XY_CTHL_CL_MotorStep == 0))
        {
            AxisEgmStop(Y_AXIS);//AxisDecStop(Y_AXIS); 
        }
        //测试电机
        if(XY_CTHL_MotorTEST)
        {           
            SetEn(X_AXIS, MOTOR_EN);
            if(!X_DRV)
                //              X轴       运行速度                    启动速度        加速度  减速度
                AxisContinueMoveAcc(X_AXIS,2000,DIR_P,1000,1000,15,15);
            
            
            
        }
        if(!XY_CTHL_MotorTEST_N && !XY_CTHL_MotorTEST && (XY_CTHL_TD_MotorStep == 0) && XY_CTHL_ColorStep==0 && (XY_CTHL_bFKCXTDDW_Step==0))
        {
            AxisEgmStop(X_AXIS);//AxisDecStop(Y_AXIS); 
        }
        if(XY_CTHL_MotorTEST_N)
        {           
            SetEn(X_AXIS, MOTOR_EN);
            if(!X_DRV)
                //              X轴       运行速度                    启动速度        加速度  减速度
                AxisContinueMoveAcc(X_AXIS,2000,DIR_N,1000,1000,15,15);
            
            
            
        }
        if(!XY_CTHL_MotorTEST_N && !XY_CTHL_MotorTEST && (XY_CTHL_TD_MotorStep == 0) && XY_CTHL_ColorStep==0 && (XY_CTHL_bFKCXTDDW_Step==0))
        {
            AxisEgmStop(X_AXIS);//AxisDecStop(Y_AXIS); 
        }
        //合链电机返回原点
        if(XY_CTHL_bCLMotor_O)
        {
            XY_CTHL_bCLMotor_O = 0;
            if(XY_CTHL_CL_MotorStep == 0)
                XY_CTHL_CL_MotorStep = 40;
        } 
        //拖带方块定位 ,因这步为前拖带定位, 很多电磁阀要关掉       
        if(XY_CTHL_bFKTDDW)
        {
            XY_CTHL_bFKTDDW = 0;
            if(XY_CTHL_TD_MotorStep == 0)
            {
                XY_CTHL_XKDW_VAVLE = 0;     //斜口定位
                XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                if(!XY_CTHL_PARAM_CXXY_MODE)     
                    XY_CTHL_CXXY_VAVLE = 0;     //插销下移
                XY_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                XY_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                XY_CTHL_bHLJJ = 0;          //合链夹具
                XY_CTHL_FKJD_VAVLE = 0;     //方块夹带
                if((GetEn(X_AXIS) == MOTOR_DISEN))
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    XY_CTHL_TD_MotorDelay = dwTickCount + 200;                    
                } 
                else
                    XY_CTHL_TD_MotorDelay = dwTickCount + 50;
                XY_CTHL_TD_MotorStep = 1;
            } 
        } 
        //拖带方块插销定位(斜口推带，斜口定位，顶斜口)
        if(XY_CTHL_bFKCXTDDW)
        {
            XY_CTHL_bFKCXTDDW = 0;
            if((XY_CTHL_bFKCXTDDW_Step == 0) && (XY_CTHL_CL_MotorStep == 0) && 
               !XY_CTHL_CTXM_VAVLE)
            {
                XY_CTHL_bFKCXTDDW_Step = 1;
                //  SetEn(X_AXIS, MOTOR_EN);
                if((GetEn(X_AXIS) == MOTOR_EN))     
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    XY_CTHL_bFKCXTDDW_Delay = dwTickCount + 10;
                }
                else
                {
                    SetEn(X_AXIS, MOTOR_EN);
                    XY_CTHL_bFKCXTDDW_Delay = dwTickCount + 1000;
                }
                XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
                XY_CTHL_CXXY_VAVLE = 0;     //插销下移
                XY_CTHL_CXHJD_VAVLE = 0;    //插销后夹带 
                XY_CTHL_CXHDW_VAVLE = 0;    //插销后定位
                XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针
                XY_CTHL_HLJJ_VAVLE = 0;          //合链夹具
            }  
        } 
        //插销穿入(包含电机前定位,插销下移,后夹,后定位)
        if(XY_CTHL_bCXCR) 
        {
            XY_CTHL_bCXCR = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(XY_CTHL_CTXM_VAVLE && XY_CTHL_MGuo_VAVLE && !XY_CTHL_CXQJD_VAVLE &&
               XY_CTHL_CTM_Limit_IN && !XY_CTHL_LTou_Check)
            {                
                if(XY_CTHL_CL_MotorStep == 0)
                {
                    XY_CTHL_bCXCR_Step = 11; 
                    SetEn(Y_AXIS, MOTOR_EN);
                    if(!XY_CTHL_SF_Origin_IN)
                        XY_CTHL_CL_MotorStep = 40;
                }
            }
            else   //警告不能自动穿插销
            {
                XY_CTHL_SetAlarmCode(XY_CTHL_WFZIDONGCX_ALARM,0);  
            }
        }
        
        
        //半自动
        if(XY_CTHL_bBanZiDong)
        {
            XY_CTHL_bBanZiDong=0;
            cBanAuTo=1;
            XY_CTHL_PARAM_BanAuto_MODE=1;
            XY_CTHL_ZhuangLiaoDelay = dwTickCount + 150;
            XY_CTHL_MGuo_VAVLE = 1;   //判断是否已经有料
            XY_CTHL_ZhuangLiaoStep = 1; 
            bTuiLaTouOkFlg = 1;
            bZhuangLiaoOkFlg= 0;
            bCL_EN_FLG=0;
            XY_CTHL_AutoStep = 1;  
            bRunning=1;
        }
        
        if(XY_CTHL_CXC)//穿小插
        {
            XY_CTHL_CXC=0;
            cCXCONE=1;
            cBanAuTo=0;
            XY_CTHL_PARAM_BanAuto_MODE=0;
            XY_CTHL_AutoStep = 11;  
            bRunning=1;
            if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            } 
        }
        //小插销测试
        if(XY_CTHL_bXiaoChaTest)
        {
            XY_CTHL_bXiaoChaTest=0;
            cXiaoChaTest=1;
            if(GetEn(Y_AXIS) == MOTOR_DISEN) 
            {
                SetEn(Y_AXIS, MOTOR_EN);
                XY_CTHL_CL_MotorDelay = dwTickCount + 260;   //锁轴时间
                
            } 
            if(XY_CTHL_CL_MotorStep==0)
                XY_CTHL_CL_MotorStep = 20;  
        }
        //电机合链动作
        if(XY_CTHL_bMotorHL)
        {
            XY_CTHL_bMotorHL = 0;
            if(XY_CTHL_PARAM_CR_MODE != 0)
                if(XY_CTHL_SF_Origin_IN)
                {
                    if((XY_CTHL_CL_MotorStep == 0) && !XY_CTHL_CTXM_VAVLE && (!XY_CTHL_CTM_Limit_IN))
                    {
                        bCL_OK_FLG = 0;   
                        XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                        XY_CTHL_CL_MotorStep = 1;
                        XY_CTHL_CL_MotorDelay = dwTickCount + XY_CTHL_PARAM_HLJJ_CL_DELAY + 130;
                        if((GetEn(Y_AXIS) == MOTOR_DISEN))
                        {
                            SetEn(Y_AXIS, MOTOR_EN);
                            XY_CTHL_CL_MotorDelay = dwTickCount + 250;                    
                        } 
                    }
                }
                else
                {
                    XY_CTHL_bCLMotor_O =1;
                    
                }
            else
            {
                bCL_OK_FLG = 0; 
                XY_CTHL_CL_MotorStep = 1;
                XY_CTHL_HLJJ_VAVLE = 1; //Y20 合链夹具电磁阀输出后,电机穿入
                XY_CTHL_CL_MotorDelay = dwTickCount + XY_CTHL_PARAM_HLJJ_CL_DELAY + 130;
                
            }
        } 
        //一次穿链动作
        if(XY_CTHL_bCL_First)
        {
            XY_CTHL_bCL_First = 0;
            //拉头模在上面到们并且码勾输出,判断有拉头
            if(XY_CTHL_CTXM_VAVLE && XY_CTHL_MGuo_VAVLE && !XY_CTHL_CXQJD_VAVLE &&
               XY_CTHL_CTM_Limit_IN && !XY_CTHL_LTou_Check && (XY_CTHL_CL_MotorStep == 0))
            {  
                XY_CTHL_bCLFirst_Step = 19;
                XY_CTHL_CXHJD_VAVLE = 1;    //插销后夹带 
                XY_CTHL_CXDWZ_VAVLE = 0;    //插销定位针(到位)电磁阀  
                XY_CTHL_CXQJD_VAVLE = 0;    //插销前夹带 
            }
        }  
       
    }        
}

#endif