using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    public partial class BoxEquip : EquipBase
    {
        /// <summary>
        /// 自动出入库
        /// </summary>
        public AutoInoutInfo AutoInout = new AutoInoutInfo();
        /// <summary>
        /// 配置文件
        /// </summary>
        public BoxEquip_Config Config;
        /// <summary>
        /// 行走机构
        /// </summary>
        public AxisBean MoveAxis = null;
        /// <summary>
        /// 料屉拉取进出轴
        /// </summary>
        public AxisBean PullAxis_Inout = null;
        /// <summary>
        /// 移栽升降轴
        /// </summary>
        public AxisBean UpdownAxis = null;
        /// <summary>
        /// A面移栽X轴
        /// </summary>
        public AxisBean XAxis_A = null;
        /// <summary>
        /// A面移栽旋转轴
        /// </summary>
        public AxisBean MiddleAxis_A = null;
        /// <summary>
        /// A面移栽压紧轴
        /// </summary>
        public AxisBean ComAxis_A = null;
        /// <summary>
        /// 料屉拉取升降轴
        /// </summary>
        public AxisBean PullAxis_Updown = null;
        /// <summary>
        /// B面移栽X轴
        /// </summary>
        public AxisBean XAxis_B = null;
        /// <summary>
        /// B面移栽旋转轴
        /// </summary>
        public AxisBean MiddleAxis_B = null;
        /// <summary>
        /// B面移栽压紧轴
        /// </summary>
        public AxisBean ComAxis_B = null;
        /// <summary>
        /// 是否需要回零
        /// </summary>
        public AxisBean[] moveAxisArray;
        //温湿度
        public HumitureBean humBean = null;
        public string lastPosId = "";
        public DeviceStatus deviceStatus = DeviceStatus.ResetMove;
        public string CID = "";
        /// <summary>
        /// 抽屉层信号
        /// </summary>
        public string[] trayRows;
        /// <summary>
        /// A面列抽屉列信号
        /// </summary>
        public string[] trayAColumns;
        /// <summary>
        /// B面列抽屉列信号
        /// </summary>
        public string[] trayBColumns;
        /// <summary>
        /// A面列信号屏蔽
        /// </summary>
        public string[] sheidAColmns;
        /// <summary>
        /// B面列信号屏蔽
        /// </summary>
        public string[] sheidBColmns;
        /// <summary>
        /// A面等待出库的队列
        /// </summary>
        public ConcurrentQueue<InOutParam> waitAOutStoreList = new ConcurrentQueue<InOutParam>();
        /// <summary>
        /// B面等待出库的队列
        /// </summary>
        public ConcurrentQueue<InOutParam> waitBOutStoreList = new ConcurrentQueue<InOutParam>();
        //库位表
        public List<string> PositionNumList;
        public bool IgnoreCamDect = false;
        public bool CamDetectError = false;
        public BoxEquip(string cid, BoxEquip_Config config)
        {
            baseConfig = config;
            this.Config = config;
            this.DeviceID = config.Id;
            CID = config.CID;
            IsDebug = config.IsDebug.Equals(1);
            Name = (" " + "存储机构" + " ").ToUpper();
            Init();
            InitConnectServerTimer();
            ledProcessTimer.Elapsed += LedProcess;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            MoveInfo = new DeviceMoveInfo(" 存储机构 ");
            //温湿度
            humBean = new HumitureBean(config.Humiture_Port, Name);
            InitRowColumnSig();
            InitAllAxis();
            InitPosititionNumList();
            InitDrawInfos();
            LoadCameraConfig();
        }
        void InitRowColumnSig()
        {
            trayRows = new string[] { IO_Type.SuddenStop_BTN,
                IO_Type.Row_Check_1,
                IO_Type.Row_Check_2,
                IO_Type.Row_Check_3,
                IO_Type.Row_Check_4,
                IO_Type.Row_Check_5,
                IO_Type.Row_Check_6,
                IO_Type.Row_Check_7,
                IO_Type.Row_Check_8,
                IO_Type.Row_Check_9,
                IO_Type.Row_Check_10,
                IO_Type.Row_Check_11,
                IO_Type.Row_Check_12,
                IO_Type.Row_Check_13,
                IO_Type.Row_Check_14,
                IO_Type.Row_Check_15
            };
            trayAColumns = new string[] { IO_Type.SuddenStop_BTN,
            IO_Type.Column_Check_A1,
            IO_Type.Column_Check_A2,
            IO_Type.Column_Check_A3,
            IO_Type.Column_Check_A4,
            IO_Type.Column_Check_A5,
            IO_Type.Column_Check_A6
            };
            trayBColumns = new string[] { IO_Type.SuddenStop_BTN,
            IO_Type.Column_Check_B1,
            IO_Type.Column_Check_B2,
            IO_Type.Column_Check_B3,
            IO_Type.Column_Check_B4,
            IO_Type.Column_Check_B5,
            IO_Type.Column_Check_B6
            };
            sheidAColmns = new string[]
            {
            "Col_Sig_Shield",
            "A_Col1_Sig_Shield",
            "A_Col2_Sig_Shield",
            "A_Col3_Sig_Shield",
            "A_Col4_Sig_Shield",
            "A_Col5_Sig_Shield",
            "A_Col6_Sig_Shield"
            };
            sheidBColmns = new string[]
            {
            "Col_Sig_Shield",
            "B_Col1_Sig_Shield",
            "B_Col2_Sig_Shield",
            "B_Col3_Sig_Shield",
            "B_Col4_Sig_Shield",
            "B_Col5_Sig_Shield",
            "B_Col6_Sig_Shield"
            };
        }
        internal void InitAllAxis()
        {
            MoveAxis = new AxisBean(Config.MoveAxis, Name);
            PullAxis_Inout = new AxisBean(Config.PullAxis_Inout, Name);
            UpdownAxis = new AxisBean(Config.UpdownAxis, Name);
            XAxis_A = new AxisBean(Config.XAxis_A, Name);
            MiddleAxis_A = new AxisBean(Config.MiddleAxis_A, Name);
            ComAxis_A = new AxisBean(Config.ComAxis_A, Name);
            PullAxis_Updown = new AxisBean(Config.PullAxis_Updown, Name);
            XAxis_B = new AxisBean(Config.XAxis_B, Name);
            MiddleAxis_B = new AxisBean(Config.MiddleAxis_B, Name);
            ComAxis_B = new AxisBean(Config.ComAxis_B, Name);
            moveAxisArray = new AxisBean[] {
                MoveAxis,PullAxis_Inout,UpdownAxis,PullAxis_Updown,
                XAxis_A,MiddleAxis_A,ComAxis_A,
                XAxis_B,MiddleAxis_B,ComAxis_B
            };
        }
        internal void InitPosititionNumList()
        {
            List<BoxPosition> positionList = CSVPositionReader<BoxPosition>.getPositionList();
            PositionNumList = new List<string>();
            foreach (BoxPosition position in positionList)
            {
                if (position.StoreId.Equals(DeviceID) && BoxPosition.CheckPosition(position, Config))
                {
                    PositionNumList.Add(position.PositionNum);
                }
            }
        }
        public override bool StartRun()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            bool rtn = false;
            Task task = Task.Factory.StartNew(new Action(() => { rtn = OpenAllAxis(); }));
            task.Wait();
            if (!rtn)
            {
                CloseAllAxis();
                return false;
            }
            SetAllTimer(false);
            SetConnectServerTimer(false);
            MoveInfo.EndMove();
            SetBoxStatus(DeviceStatus.ResetMove, RunStatus.HomeMoving);
            MoveInfo.NewMove(MoveType.RHome);
            LogInfo("开始 原点返回：    ");
            StartReset();

            //SetConnectServerTimer(true);
            SetAllTimer(true);
            return true;
        }

        public override bool Reset()
        {
            StopMove();
            bool rtn = false;
            Task task = Task.Factory.StartNew(new Action(() => { rtn = OpenAllAxis(); }));
            task.Wait();
            if (!rtn)
            {
                CloseAllAxis();
                return false;
            }
            mainTimer.Enabled = false;
            SetBoxStatus(DeviceStatus.ResetMove, RunStatus.Reset);
            MoveInfo.NewMove(MoveType.Reset);

            LogInfo("开始重置：  ");
            StartReset();
            mainTimer.Enabled = true;
            return true;
        }


        #region 复位处理

        private void StartReset()
        {
            SetWarnMsg("");
            alarmType = AlarmType.None;
            isInSuddenDown = false;
            isNoAirpressure_Check = false;
            MoveInfo.NextMoveStep(StepEnum.BOX_H001_Wait);
            AutoInout.StopAuto();
            LogInfo($"复位 {MoveInfo.SLog} ：存储机构轴开始复位");

            isInPro = false;
        }

        protected override void ResetProcess()
        {
            if (MoveInfo.MoveType.Equals(MoveType.Reset) || MoveInfo.MoveType.Equals(MoveType.RHome))
            {
                MoveResetPro();
            }
            //else if(MoveInfo.MoveType.Equals(MoveType.RHome))
            //{
            //    MoveHomePro();
            //}
        }

        private void MoveResetPro()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            switch (MoveInfo.MoveStep)
            {
                //回零
                case StepEnum.BOX_H001_Wait:
                    if(GetCurLocation(out string posid))
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H002_PullAxis_UpdownToP3);
                        MoveInfo.MoveParam = new InOutParam(new InOutPosInfo("Reset", posid));
                        MoveInfo.MoveParam.MoveP = new LineMoveP(Config, MoveInfo.MoveParam.PosInfo.PosId);
                        UpdownAxisTo_P6_P12();
                        PullAxis_UpdownToHighP3();
                        LogInfo($"复位 {MoveInfo.SLog}：抽屉在料屉轴上,移栽升降轴到料屉上方过度点，料屉升降轴到高点P3");
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H01_CheckCurPullDownPos);
                        MoveInfo.MoveParam = new InOutParam(new InOutPosInfo("Reset", posid));
                        MoveInfo.MoveParam.MoveP = new LineMoveP(Config, MoveInfo.MoveParam.PosInfo.PosId);
                        LogInfo($"复位 {MoveInfo.SLog}：抽屉未在料屉轴上");
                    }
                    break;
                case StepEnum.BOX_H002_PullAxis_UpdownToP3:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H003_PullAxis_InoutToP2P4);
                    LogInfo($"复位 {MoveInfo.SLog}：推到抽屉提取点，料斗拉取进出轴到料屉提取点P2");
                    PullAxis_Inout_To_P2_P4();
                    break;
                case StepEnum.BOX_H003_PullAxis_InoutToP2P4:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H004_PullAxis_UpdownToMiddle);
                    PullAxis_UpdownToMiddleP2();
                    if (CheckASide())
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：料斗拉取升降轴到料屉水平点P2,同时检测{trayAColumns[GetPosColumn()]}=1");
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(trayAColumns[GetPosColumn()], IO_VALUE.HIGH));
                    }
                    else
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：料斗拉取升降轴到料屉水平点P2,同时检测{trayBColumns[GetPosColumn()]} = 1");
                        MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(trayBColumns[GetPosColumn()], IO_VALUE.HIGH));
                    }
                    break;
                case StepEnum.BOX_H004_PullAxis_UpdownToMiddle:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H005_PullAxis_UpdownToLow);
                    LogInfo($"入库 {MoveInfo.SLog}：放下料屉，料斗拉取升降轴到料屉提取低点P4");
                    PullAxis_UpdownToLowP4();
                    break;
                case StepEnum.BOX_H005_PullAxis_UpdownToLow:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H01_CheckCurPullDownPos);
                    PullAxis_Inout_To_P1();
                    LogInfo($"复位 {MoveInfo.SLog}：料斗拉取拉取轴到待机点P1");
                    break;
                case StepEnum.BOX_H01_CheckCurPullDownPos:
                    if (!PullAxis_Updown.IsInPosition(Config.PullAxis_Updown_P1) && !PullAxis_Updown.IsInPosition(MoveInfo.MoveParam.MoveP.PullAxis_Updown_P2))
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H02_PullAxis_UpDownToP1);
                        LogInfo($"复位 {MoveInfo.SLog}：当前料屉拉取升降轴不在在料屉待机点/提取低点，先到低点,移栽升降轴到料屉上方过渡点");
                        PullAxis_UpdownToLowP4();
                        UpdownAxisTo_P6_P12();
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H03_PullAxis_InoutHome);
                        LogInfo($"复位 {MoveInfo.SLog}：料屉拉取进出轴回原点");
                        PullAxis_Inout.HomeMove(MoveInfo);
                    }
                    break;
                case StepEnum.BOX_H02_PullAxis_UpDownToP1:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H03_PullAxis_InoutHome);
                    LogInfo($"复位 {MoveInfo.SLog}：料屉拉取进出轴回原点");
                    PullAxis_Inout.HomeMove(MoveInfo);
                    break;
                case StepEnum.BOX_H03_PullAxis_InoutHome:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H04_PullAxis_Updown_ABComAxis_Home);
                    LogInfo($"复位 {MoveInfo.SLog}：料屉拉取升降轴、AB面压紧轴回原点");
                    if (!IsMoveAxisInSafePos())
                        MoveAxis.AbsMove(MoveInfo, Config.MoveAxis_SafePos, Config.MoveAxis_P1_Speed);
                    PullAxis_Inout.HomeMove(MoveInfo);
                    ComAxis_A.HomeMove(MoveInfo);
                    ComAxis_B.HomeMove(MoveInfo);
                    break;
                case StepEnum.BOX_H04_PullAxis_Updown_ABComAxis_Home:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H05_XAxis_AB_UpDown_Home);
                    LogInfo($"复位 {MoveInfo.SLog}：AB面移栽X轴回原点、移栽升降轴");
                    PullAxis_Inout.HomeMove(MoveInfo);
                    XAxis_A.HomeMove(MoveInfo);
                    XAxis_B.HomeMove(MoveInfo);
                    UpdownAxis.HomeMove(MoveInfo);
                    break;

                case StepEnum.BOX_H05_XAxis_AB_UpDown_Home:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H06_OtherAxis_Home);
                    LogInfo($"复位 {MoveInfo.SLog}：行走机构、AB面移栽旋转轴回原点");
                    MoveAxis.HomeMove(MoveInfo);
                    MiddleAxis_A.HomeMove(MoveInfo);
                    MiddleAxis_B.HomeMove(MoveInfo);
                    break;

                case StepEnum.BOX_H06_OtherAxis_Home:
                    LogInfo($"复位 {MoveInfo.SLog}：所有轴回零完成");
                    AllAxisStartMoveToP1();
                    break;

                //回待机位
                case StepEnum.BOX_R01_PullAxis_UpDownToP1:
                    MoveInfo.NextMoveStep(StepEnum.BOX_R02_PullAxis_InOut_ABComAxis_ToP1);
                    LogInfo($"复位 {MoveInfo.SLog}：料屉拉取进出轴、AB面压紧轴返回待机位P1");
                    PullAxis_Inout.AbsMove(MoveInfo, Config.PullAxis_Inout_P1, Config.PullAxis_Inout_P1_Speed);
                    ComAxis_A.AbsMove(MoveInfo, Config.ComAxis_A_P1, Config.ComAxis_A_P1_Speed);
                    ComAxis_B.AbsMove(MoveInfo, Config.ComAxis_B_P1, Config.ComAxis_B_P1_Speed);
                    break;

                case StepEnum.BOX_R02_PullAxis_InOut_ABComAxis_ToP1:
                    MoveInfo.NextMoveStep(StepEnum.BOX_R03_XAxis_AB_ToP1);
                    LogInfo($"复位 {MoveInfo.SLog}：AB面移栽X轴返回待机位P1");
                    XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P1, Config.XAxis_A_P1_Speed);
                    XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P1, Config.XAxis_B_P1_Speed);
                    break;

                case StepEnum.BOX_R03_XAxis_AB_ToP1:
                    MoveInfo.NextMoveStep(StepEnum.BOX_R04_OtherAxisToP1);
                    LogInfo($"复位 {MoveInfo.SLog}：行走机构、移栽升降轴、AB面移栽旋转轴返回待机位P1");
                    MoveAxis.AbsMove(MoveInfo, Config.MoveAxis_P1, Config.MoveAxis_P1_Speed);
                    UpdownAxis.AbsMove(MoveInfo, Config.Updown_P1, Config.Updown_P1_Speed);
                    MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P1, Config.MiddleAxis_A_P1_Speed);
                    MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P1, Config.MiddleAxis_B_P1_Speed);

                    break;

                case StepEnum.BOX_R04_OtherAxisToP1:
                    LogInfo($"复位 {MoveInfo.SLog}：所有轴到达待机位完成");
                    SetBoxStatus(DeviceStatus.None, RunStatus.Runing);
                    MoveInfo.EndMove();
                    break;
            }
        }
        private void AllAxisStartMoveToP1()
        {
            SetBoxStatus(DeviceStatus.ResetMove, RunStatus.Reset);
            MoveInfo.NextMoveStep(StepEnum.BOX_R01_PullAxis_UpDownToP1);
            LogInfo($"复位 {MoveInfo.SLog}：料屉拉取升降轴返回待机位P1");
            PullAxis_Updown.AbsMove(MoveInfo, Config.PullAxis_Updown_P1, Config.PullAxis_Updown_P1_Speed);
        }


        #endregion

        private DateTime dtUpperA = DateTime.Now;
        private DateTime dtUpperB = DateTime.Now;
        int SigLastTime = 5;//5秒
        protected override void OnTimerProcess()
        {
            TimeSpan timeSpanA = DateTime.Now - dtUpperA;
            //检测A上暂存区是否有料盘
            if (IOValue(IO_Type.UpperArea_Check_A).Equals(IO_VALUE.HIGH))
            {
                if (timeSpanA.TotalSeconds >= SigLastTime)
                    StartInstore(new InOutParam(BufferDataManager.AInStoreInfo));
            }
            else
            {
                dtUpperA = DateTime.Now;
            }
            TimeSpan timeSpanB = DateTime.Now - dtUpperB;
            //检测B上暂存区是否有料盘
            if (IOValue(IO_Type.UpperArea_Check_A).Equals(IO_VALUE.HIGH))
            {
                if (timeSpanB.TotalSeconds >= SigLastTime)
                    StartInstore(new InOutParam(BufferDataManager.BInStoreInfo));
            }
            else
            {
                dtUpperB = DateTime.Now;
            }
        }
        private void ExecuteOutListProcess()
        {
            try
            {
                //bool noInStore = true;
                //if (AutoInout.CurrInOutACount >= this.Config.Box_ResetACount && noInStore)
                //{
                //    if (storeRunStatus < StoreRunStatus.Runing || MoveInfo.MoveType == StoreMoveType.InStore || MoveInfo.MoveType == StoreMoveType.OutStore)
                //    {
                //        //    LogInfo("已经累计出入库" + AutoInout.CurrInOutACount + "次，当时当前正在忙碌中暂不复位");
                //    }
                //    else
                //    {
                //        LogInfo("已经累计出入库" + AutoInout.CurrInOutACount + "次，需要复位一下");
                //        Reset();
                //    }
                //    return;
                //}
                if (waitAOutStoreList.Count > 0)
                {
                    InOutParam param = null;
                    bool result = waitAOutStoreList.TryDequeue(out param);
                    if (result && param != null)
                    {
                        LogInfo("执行A面排队的出库【" + param.PosInfo.ToStr() + "】");
                        StartExecuctOut(param);
                        return;
                    }
                }
                if (waitBOutStoreList.Count > 0)
                {
                    InOutParam param = null;
                    bool result = waitBOutStoreList.TryDequeue(out param);
                    if (result && param != null)
                    {
                        LogInfo("执行B面排队的出库【" + param.PosInfo.ToStr() + "】");
                        StartExecuctOut(param);
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "处理出库排队列表出错：" + ex.ToString());
            }
        }
        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
            if (runStatus.Equals(RunStatus.Runing))
            {
                ExecuteOutListProcess();
            }
            if (autoFindPosMode)//自动对位模式
            {
                AutoFindPosProcess();
            }
            BusyMoveProcess();

            if (NoErrorAlarm())
            {
                CheckAxisAlarm();
            }
        }
        protected override void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 3 && alarmType.Equals(AlarmType.IoSingleTimeOut))
                {
                    preIoTimerOutTime = DateTime.Now;

                    if (runStatus < RunStatus.Runing || isInSuddenDown || isNoAirpressure_Check)
                    {
                        return;
                    }
                    ////若BOX和出料都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    if (MoveInfo.IsInWait.Equals(false) && NoErrorAlarm())
                    {
                        LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                        alarmType = AlarmType.None;
                        SetWarnMsg("");
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("IOTimeOutProcess出错：", ex);
            }
        }
        internal override void StopMove()
        {


            MoveInfo.EndMove();

            PullAxis_Updown.SuddenStop();
            MoveAxis.SuddenStop();
            PullAxis_Inout.SuddenStop();

            MiddleAxis_A.SuddenStop();
            UpdownAxis.SuddenStop();
            XAxis_A.SuddenStop();
            ComAxis_A.SuddenStop();

            CloseAllAxis();


        }

        public override void StopRun()
        {
            SetConnectServerTimer(false);
            SetAllTimer(false);
            StopMove();
            SetBoxStatus(DeviceStatus.None, RunStatus.Wait);
            //StopCamera();
        }

        public override string GetMoveStr()
        {
            string msg = "";
            int tLength = 15;

            msg += "runStatus：  " + runStatus + "\n";
            msg += "runStep：  " + MoveInfo.MoveStep + "\n";
            msg += "alarm：  " + alarmType + "\n";



            return msg;
        }

        #region 轴运动

        private DateTime checkAlarmTime = DateTime.Now;
        public void CheckAxisAlarm()
        {
            if (alarmType.Equals(AlarmType.AxisAlarm) || alarmType.Equals(AlarmType.AxisMoveError))
            {
                return;
            }
            TimeSpan span = DateTime.Now - checkAlarmTime;
            //在回原点，复位，出入库时，检测报警间隔减小
            if (MoveInfo.MoveType.Equals(MoveType.None))
            {
                if (span.TotalSeconds < 5)
                {
                    return;
                }
            }
            else if (span.TotalSeconds < 1)
            {
                return;
            }

            checkAlarmTime = DateTime.Now;
            foreach (AxisBean axisInfo in moveAxisArray)
            {
                if (AxisIsAlarm(axisInfo))
                {
                    return;
                }
            }

            if (AxisIsAlarm(PullAxis_Updown))
            {
                return;
            }
        }


        public bool OpenAllAxis(bool isCheck = true)
        {
            foreach (AxisBean axis in moveAxisArray)
            {
                string outMsg = "";
                if (!axis.Open(true, out outMsg))
                {
                    LogUtil.info(outMsg);
                    return false;
                }
            }
            return true;
        }

        public void CloseAllAxis()
        {
            foreach (AxisBean axis in moveAxisArray)
            {
                axis.SuddenStop();
                axis.ServoOff();
            }
        }


        #endregion




    }
}