using Asa;
using log4net;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;

namespace OnlineStore.DeviceLibrary
{ 
    public partial class DUOStoreBean : EquipBase
    {          
        internal Dictionary<int, BOX_Config> BoxConfigMap { get; set; }
        public Dictionary<int, BoxBean> BoxMap = new Dictionary<int, BoxBean>();
     
        public Store_Config Config { get; set; }
        public bool UseBuzzer = ConfigAppSettings.GetIntValue(Setting_Init.UseBuzzer).Equals(1);
        /// <summary>
        /// 取料提升机构气缸
        /// </summary>
        public HoisterCylinder hoisterCylinder = new HoisterCylinder(0);
        public AxisBean T1_BatchAxis = null;
        public AxisBean T2_MiddleAxis = null;
        public AxisBean T3_UpdownAxis = null;


        #region  初始化

        internal bool canStart = false;
        public DUOStoreBean(Store_Config lineConfig, Dictionary<int, BOX_Config> configList)
        {
            BoxConfigMap = new Dictionary<int, BOX_Config>();
            BoxMap = new Dictionary<int, BoxBean>();
            if (lineConfig.IOSingle_TimerOut <= 0)
            {
                lineConfig.IOSingle_TimerOut = 5000;
            }
            Init();
            
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            serverConTimer.Elapsed += ServerConnectTimer_Elapsed;
            baseConfig = lineConfig;
            this.Config = lineConfig;
            this.ID = lineConfig.Id;

            Name = (" DUO料仓 ").ToUpper();
            MoveInfo = new StoreMoveInfo(ID, Name);
            List<string> ioList = new List<string>();
            AddDeviceName(ioList, Config.IOIPList);
           
            foreach (BOX_Config config in configList.Values)
            {
                BoxBean equip = new BoxBean(config);

                AddDeviceName(ioList, config.IOIPList);
                BoxMap.Add(config.Id, equip);
                BoxConfigMap.Add(config.Id, config);
            }
            Config.T3_Updown_Axis.BreakOnDO = IO_Type.MoveAxis_Break;
            Config.T1_Batch_Axis.BreakOnDO = IO_Type.MoveAxis_Break;
            T1_BatchAxis = new AxisBean(Config.T1_Batch_Axis, Name);
            T2_MiddleAxis = new AxisBean(Config.T2_Middle_Axis,Name);
            T3_UpdownAxis = new AxisBean(Config.T3_Updown_Axis,Name);
            IOManager.Init();

            CodeManager.LoadConfig();
            CurrShelfNum = ConfigAppSettings.GetIntValue(Setting_Init.CurrShelfNum);
            CurrShelfType = ConfigAppSettings.GetIntValue(Setting_Init.CurrShelfType);
            Task.Factory.StartNew(delegate
            {
                //   RFIDManager.RfidReader.Open(rfidList.ToArray());
                IOManager.instance.ConnectionIOList(ioList);

                IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                mainTimer.Enabled = true;
                canStart = true;
                int isAuto = ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun);
                if (isAuto == 1)
                {
                    mainTimer.Enabled = true;
                }
            });
        }
         
        private void AddDeviceName(List<string> targetList, List<string> list)
        {
            foreach (string str in list)
            {
                if (!targetList.Contains(str))
                {
                    targetList.Add(str);
                }
            }
        }
      

        #endregion

        #region 启动，复位，停止，方法
        public override bool StartRun(bool isDebug = false)
        {
            if (!canStart)
            {
                SetWarnMsg("启动失败：设备未初始化完成");
                return false;
            }
            if (BoxConfigMap == null)
            {
                SetWarnMsg("启动失败：未加载到料仓配置");
                return false;
            }
            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：急停未开");
            }
            else if (IOValue(IO_Type.Airpressure_Check).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：没有气压信号");
            }
            else
            {
                LogUtil.info(Name + "开始启动 ，启动时间：" + StartTime.ToString());
                runStatus = StoreRunStatus.HomeMoving;
                StartTime = DateTime.Now;
                StartResetMove();
                foreach (BoxBean box in this.BoxMap.Values)
                {
                    box.StartRun();
                }
                serverConTimer.Enabled = true;
                mainTimer.Enabled = true;
                return true;
            }
            return false;
        }

        public override void Reset(bool isNeedClearAuto = true)
        {
            mainTimer.Enabled = false;

            //停止运动
            MoveInfo.EndMove();
            runStatus = StoreRunStatus.Reset;
            StartResetMove();

            foreach (BoxBean equip in BoxMap.Values)
            {
                if (!equip.alarmType.Equals(AlarmType.None))
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                    equip.Reset();
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                }
            }
            mainTimer.Enabled = true;
        }
        private void StartResetMove()
        {
            mainTimer.Enabled = false;
            isInSuddenDown = false;
            isNoAirCheck = false;
            alarmType = AlarmType.None;
            WarnMsg = "";
            MoveInfo.NewMove(MoveType.Reset);

            MoveInfo.NextMoveStep(StoreMoveStep.LR_01_StopUp);
            LogUtil.info(Name + "开始复位 " + MoveInfo.MoveStep + " ：四个阻挡全部上升，取料提升机构需要在前进端");
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(600));
            IOMove(IO_Type.Line_Stop1_Wait, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Stop2_Work, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Stop3_Buffer, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Stop4_Out, IO_VALUE.LOW);
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Stop1_Wait, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Stop2_Work, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Stop3_Buffer, IO_VALUE.LOW));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Stop4_Out, IO_VALUE.LOW)); 
            hoisterCylinder.StartForward(MoveInfo); 
        }

        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait();
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }

            if (MoveInfo.IsStep(StoreMoveStep.LR_01_StopUp))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_02_LineRun);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：流水线转动3秒");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                LineRun(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_02_LineRun))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_03_BatchAxisHome);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：夹爪放松，提升轴回原点，上下轴回原点");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                CylinderMove(MoveInfo, IO_Type.ClampCylinder_Clamp, IO_Type.ClampCylinder_Relax);
                T1_BatchAxis.HomeMove(MoveInfo);
                T3_UpdownAxis.HomeMove(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_03_BatchAxisHome))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_04_BatchToP1);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：提升轴到P1点["+ Config.BatchAxis_P1 + "]，上下轴到待机点P2["+ Config.UpdownAxis_P2 + "]");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                T1_BatchAxis.AbsMove(MoveInfo, Config.BatchAxis_P1, Config.BatchAxis_P1Speed);
                T3_UpdownAxis.AbsMove(MoveInfo, Config.UpdownAxis_P2, Config.UpdownAxis_P2Speed);

            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_04_BatchToP1))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_05_Hoister_Back);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：取料电机后退，旋转轴回原点");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                hoisterCylinder.StartBack(MoveInfo);
                T2_MiddleAxis.HomeMove(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_05_Hoister_Back))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_06_TopDown);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：顶升气缸下降，旋转轴到待机点P1["+ Config.MiddleAxis_P1 + "]");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                CylinderMove(MoveInfo, IO_Type.TopCylinder_Up, IO_Type.TopCylinder_Down);
                T2_MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P1, Config.MiddleAxis_P1Speed);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_06_TopDown))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_07_WaitBox);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：等待料仓复位完成");
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_07_WaitBox))
            {
                bool isOk = true;
                //判断是否所有的已经返回完成
                string msg = "等待BOX复位完成超时";
                foreach (BoxBean box in this.BoxMap.Values)
                {
                    if ((box.runStatus.Equals(StoreRunStatus.HomeMoving) || box.runStatus.Equals(StoreRunStatus.Reset)))
                    //if ((box.storeRunStatus.Equals(StoreRunStatus.HomeMoving) || box.storeRunStatus.Equals(StoreRunStatus.Reset)) && box.IsDebug.Equals(false))
                    {
                        if (box.alarmType.Equals(AlarmType.None))
                        {
                            msg = "等待"+ box .Name+ "复位完成超时";
                            isOk = false;
                            break;
                        }
                        else
                        {
                            WarnMsg = box.Name + "在复位过程中报警，需要重新复位";
                        }
                    }
                }

                if (isOk)
                {
                    //所有原点重置完成
                    LogUtil.info(Name + "所有设备重置完成");
                    MoveEndP();

                }
                else if (MoveInfo.IsTimeOut(120))
                {
                    WarnMsg = Name + "[" + MoveInfo.MoveStep + "] "+msg+" [" + Math.Round(MoveInfo.StepSpan().TotalSeconds, 1) + "]秒";
                    LogUtil.error(WarnMsg, logType  + 21);
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
        }

        public override void StopMove()
        {
            foreach (BoxBean equip in this.BoxMap.Values)
            { 
                equip.StopMove(); 
            }
            MoveInfo.EndMove();
            hoisterCylinder.Stop();
            //轴运动停止
            T3_UpdownAxis.SuddenStop(true);
            T2_MiddleAxis.SuddenStop(true);
            T1_BatchAxis.SuddenStop(true);

            CloseAllAxis();
        }


        public override void StopRun()
        {
            mainTimer.Enabled = false;
         
            //停止运行时，把阻挡气缸上升
            StopMove();
            foreach (BoxBean equip in BoxMap.Values)
            {
                equip.StopRun();
            }
            runStatus = StoreRunStatus.Wait;
            // RFIDManager.Close();
            TimeSpan span = DateTime.Now - StartTime;
            LogUtil.info(Name + ",停止运行，关闭rfid，总运行时间：" + span.ToString());
        } 
        #endregion

        #region 灯光处理 
        private void LedProcess( )
        {
            try
            {
                DateTime time = DateTime.Now;
                bool isNeedAlarmLed = false;
                bool isInOut = false;
                bool isReset = false; 
              
                foreach (BoxBean box in BoxMap.Values)
                {
                    if (!box.alarmType.Equals(AlarmType.None))
                    {
                        isNeedAlarmLed = true;
                    }
                    if (box.MoveInfo.MoveType.Equals(MoveType.InStore) || box.MoveInfo.MoveType.Equals(MoveType.OutStore))
                    {
                        isInOut = true;
                    }
                    if (box.runStatus.Equals(StoreRunStatus.HomeMoving) || box.runStatus.Equals(StoreRunStatus.Reset))
                    {
                        isReset = true;
                    } 
                } 

                //复位过程中黄灯闪烁
                if (runStatus.Equals(StoreRunStatus.HomeMoving) || runStatus.Equals(StoreRunStatus.Reset)||isReset )
                {
                    //开机执行中时黄灯闪烁
                    if (IsDoValue(IO_Type.RunSign_HddLed, IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                    else
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
                    }
                } 
                else
                {
                    if (IsDoValue(IO_Type.RunSign_HddLed, IO_VALUE.HIGH))
                    {
                        IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                }

                //忙碌中，判断是否有移栽在出入库执行，绿灯闪烁
                if (isInOut)
                {
                    if (IsDoValue(IO_Type.AutoRun_HddLed, IO_VALUE.LOW))
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
                    }
                    else
                    {
                        IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                }
                else if (IsDoValue(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH))
                {
                    IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                }

                //报警中 ，红灯闪烁
                if (alarmType.Equals(AlarmType.None).Equals(false) || isNoAirCheck || isInSuddenDown )
                {
                    isNeedAlarmLed = true;
                }  
                if (isNeedAlarmLed)
                {
                    if (IsDoValue(IO_Type.Alarm_HddLed, IO_VALUE.LOW))
                    {
                        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
                    }
                    else
                    {
                        IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                    }
                }
                else if (IsDoValue(IO_Type.Alarm_HddLed, IO_VALUE.HIGH))
                {
                    IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                }

            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "灯处理定时器出错：" + ex.ToString());
            }
            Thread.Sleep(5);
        }

        #endregion

        #region 定时处理
        private IO_VALUE lastAutoRun = IO_VALUE.LOW; 
        private IO_VALUE preAirValue = IO_VALUE.HIGH;
        private void AirCheckProcess()
        {
            IO_VALUE currAirValue = IOValue(IO_Type.Airpressure_Check);
            if (isInSuddenDown)
            {
                return;
            }
            if (isNoAirCheck)
            {
                return;
            }
            if (currAirValue.Equals(IO_VALUE.LOW))
            {
                //判断是否持续了3秒
                if (preAirValue.Equals(IO_VALUE.LOW))
                {
                    TimeSpan span = DateTime.Now - lastAirCloseTime;
                    if (span.TotalSeconds > StoreManager.Config.AirCheckSeconds)
                    {
                        WarnMsg = "未检测到气压信号";
                        preAirValue = IO_VALUE.LOW;
                        LogUtil.info("已持续【" + FormUtil.GetSpanStr(span) + "】未检测到气压信号，报警");
                        Alarm(AlarmType.NoAirCheck, "2", WarnMsg, MoveType.None);
                        return;
                    }
                }
                else
                {
                    lastAirCloseTime = DateTime.Now;
                    isNoAirCheck = false;
                }
            }
            else
            {
                isNoAirCheck = false;
            }
            preAirValue = currAirValue;
        } 
      
        private void ServerConnectTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            LedProcess();
        }
        private void IoCheckTimerProcess(object sender, ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (runStatus.Equals(StoreRunStatus.Wait))
                {
                    //取新的Io状态
                    IO_VALUE autoSingle = IOValue(IO_Type.Reset_BTN);
                    if (ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun).Equals(1))
                    {
                        if (autoSingle.Equals(IO_VALUE.HIGH) && lastAutoRun.Equals(IO_VALUE.LOW))
                        {
                            //没有启动时收到复位按钮，相当于启动按钮
                            LogInfo("没有启动时收到复位按钮，相当于启动按钮，开始调用启动方法！");
                            bool result = StartRun();
                            if (result.Equals(false))
                            {
                                LogUtil.error(Name + "料仓启动失败，继续等待下次启动！");
                                mainTimer.Enabled = true;
                            }
                        }
                        lastAutoRun = autoSingle;
                        return;
                    }
                    lastAutoRun = autoSingle;
                }
                //判断急停 
                else if (runStatus >= StoreRunStatus.HomeMoving)
                { 
                    //急停按钮 
                    if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                    {
                        return;
                    }
                    else if (IOValue(IO_Type.Reset_BTN).Equals(IO_VALUE.HIGH))
                    {
                        //收到复位信号，若报警直接复位，若不报警且无操作，回到待机点
                        if (alarmType.Equals(AlarmType.None) && isInSuddenDown.Equals(false) && isNoAirCheck.Equals(false))
                        {
                            if (MoveInfo.MoveType.Equals(MoveType.None))
                            {
                                LogUtil.info(Name + "收到复位信号，当前无报警，且空闲中，暂不处理");
                            }
                            else
                            {
                                LogUtil.info(Name + "收到复位信号，当前无报警， 在" + MoveInfo.MoveType + "处理中，不处理复位");
                            }
                        }
                        else
                        {
                            //收到复位信号
                            LogUtil.info("收到复位信号，自动复位");
                            WarnMsg = "收到复位信号，自动复位";
                            Reset();
                        }
                    }
                    AirCheckProcess();
                }
            }
            catch(Exception ex)
            {
                LogUtil.error(Name + "IoCheckTimerProcess 出错：" + ex.ToString());
            }
        }


        internal override void TimerProcess()
        {
            try
            {
                DateTime time = DateTime.Now;
                if (MoveInfo.MoveType != MoveType.None)
                {
                    BusyMoveProcess();
                    ShowTimeLog("BusyMoveProcess");
                }
                else if (runStatus.Equals(StoreRunStatus.Runing))
                {
                    IOTimeOutProcess();
                    ShowTimeLog("IOTimeOutProcess");

                    //判断是否需要处理料架入库 
                    StartInStoreP();
                }

                //检查运动轴报警
                if (runStatus > StoreRunStatus.Wait && (!isInSuddenDown) && (!isNoAirCheck))
                {
                    CheckAxisAlarm(new AxisBean[] { T1_BatchAxis, T2_MiddleAxis, T3_UpdownAxis });
                    ShowTimeLog("轴报警检测完成");
                }

                if (runStatus.Equals(StoreRunStatus.Runing) || runStatus.Equals(StoreRunStatus.Busy))
                {
                    ShelfOutProcess();
                    ShowTimeLog("ShelfOutProcess");
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "定时处理出错" + ex.ToString());
            }
        }


        private bool  LowProcess=false;
        private Stopwatch lowWatch = new Stopwatch();
        private void ShelfOutProcess()
        {
            try
            {
                if (IOValue(IO_Type.Line_OutCheck).Equals(IO_VALUE.LOW) &&
                      IOValue(IO_Type.Line_BackRun).Equals(IO_VALUE.LOW) &&
                      IOValue(IO_Type.Line_Run).Equals(IO_VALUE.LOW) &&
                      IOValue(IO_Type.Line_BufferCheck).Equals(IO_VALUE.HIGH) &&
                      IOValue(IO_Type.Line_Stop3_Buffer).Equals(IO_VALUE.LOW) &&
                      IOValue(IO_Type.Line_Stop4_Out).Equals(IO_VALUE.LOW) &&
                      LowProcess.Equals(false))
                {
                    if (StoreManager.checkWatch(lowWatch, 3000))
                    {
                        //左侧下层需要放个料架
                        Task.Factory.StartNew(delegate
                        {
                            LowProcess = true;
                            LogUtil.info(Name + "从料架堆积处放一个料架到后端");
                            IOMove(IO_Type.Line_Run, IO_VALUE.HIGH, false, 30000);
                            IOMove(IO_Type.Line_Stop3_Buffer, IO_VALUE.HIGH, false, 2000);
                            if (WaitIo(IO_Type.Line_OutCheck, IO_VALUE.HIGH, 30000, "堆积处放料架到后端"))
                            {
                                LineStop();
                            }
                            LowProcess = false;
                        });
                    }
                }
                else
                {
                    lowWatch.Stop();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + " ShelfOutProcess 出错：" + ex.ToString());
            }
        }
        #endregion

        public int GetShelfNum()
        {
            int ShelfCheck1 = (int)IOValue(IO_Type.ShelfCheck1);
            int ShelfCheck2 = (int)IOValue(IO_Type.ShelfCheck2);
            int ShelfCheck3 = (int)IOValue(IO_Type.ShelfCheck3);
            int ShelfCheck4 = (int)IOValue(IO_Type.ShelfCheck4);

            string dStr = ShelfCheck4.ToString()+ShelfCheck3.ToString() + ShelfCheck2.ToString() + ShelfCheck1.ToString();
            int num = Convert.ToInt32(dStr, 2);
            return num;
        }

        public void LineRun(StoreMoveInfo move=null )
        {
            if (move != null)
            {
                move.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_BackRun, IO_VALUE.LOW));
                move.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Run, IO_VALUE.HIGH));
            }
            IOMove(IO_Type.Line_BackRun, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Run, IO_VALUE.HIGH);
        }

        public void LineStop(StoreMoveInfo move=null )
        {
            if (move != null)
            {
                move.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_BackRun, IO_VALUE.LOW));
                move.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.Line_Run, IO_VALUE.LOW));
            }
            IOMove(IO_Type.Line_BackRun, IO_VALUE.LOW);
            IOMove(IO_Type.Line_Run, IO_VALUE.LOW);
        }

        public bool OpenAllAxis(bool isCheck = true)
        {

            if (RunMultiAxis(isCheck, IO_Type.MoveAxis_Run, IO_Type.MoveAxis_Break, new AxisBean []{ T3_UpdownAxis,T2_MiddleAxis}))
            {
                if (RunAxis(isCheck, T1_BatchAxis)  )
                {
                    return true;
                }
            }
            return false;
        }

        public void CloseAllAxis()
        {
            IOMove(IO_Type.MoveAxis_Break, IO_VALUE.LOW);
            IOMove(IO_Type.BatchAxis_Break, IO_VALUE.LOW); 

            CloseMultiAxis(IO_Type.MoveAxis_Run, IO_Type.MoveAxis_Break, new AxisBean[] { T3_UpdownAxis, T2_MiddleAxis });
            CloseAxis(T1_BatchAxis); 
        }
    }
}