using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

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 string lastBarcode = "";
        public string executeTime = "";
        public DeviceStatus deviceStatus = DeviceStatus.ResetMove;
        public string CID = "";
        int rows = 15;//层
        /// <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;
        /// <summary>
        /// 滑梯位置表
        /// </summary>
        public List<BoxSlidePos> BoxSlidePos;
        public DeviceMoveInfo MoveInfoLineA;
        public DeviceMoveInfo MoveInfoLineB;
        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(" 存储机构 ");
            MoveInfoLineA = new DeviceMoveInfo("A面流水线");
            MoveInfoLineB = new DeviceMoveInfo("B面流水线");
            //温湿度
            humBean = new HumitureBean(config.Humiture_Port, Name);
            InitRowColumnSig();
            InitAllAxis();
            InitPosititionNumList();
            LoadCameraConfig();
            //库位调试
            InitPosDebugInfo();
            //加载滑梯位置
            loadSlideData();
            alarmRedLedType = AlarmType.IoSingleTimeOut;
        }
        void loadSlideData()
        {
            BoxSlidePos = new List<BoxSlidePos>();
            string[] slideStr = File.ReadAllLines(Application.StartupPath + ConfigAppSettings.GetValue(Setting_Init.ConfigPath_SlidePosition));
            if (slideStr == null || slideStr.Length == 0 || slideStr.Length != Config.Drawer_Columns * 2)
            {
                for (int i = 1; i <= Config.Drawer_Columns; i++)
                {
                    BoxSlidePos.Add(new BoxSlidePos() { Column = i, Side = "A" });
                    BoxSlidePos.Add(new BoxSlidePos() { Column = i, Side = "B" });
                }
                SaveSlideData();
            }
            else
            {
                foreach (var item in slideStr)
                {
                    BoxSlidePos.Add(JsonHelper.DeserializeJsonToObject<BoxSlidePos>(item));
                }
            }
        }
        bool GetSlidePos(string side, int col, out BoxSlidePos slidePos)
        {
            slidePos = BoxSlidePos.Find(s => s.Side.Equals(side) && s.Column.Equals(col));
            return slidePos != null;
        }
        public void SaveSlideData()
        {
            string path = Application.StartupPath + ConfigAppSettings.GetValue(Setting_Init.ConfigPath_SlidePosition);
            List<string> pos = new List<string>();
            foreach (var item in BoxSlidePos)
            {
                pos.Add(JsonHelper.SerializeObject(item));
            }
            File.WriteAllLines(path, pos);
        }
        void InitRowColumnSig()
        {
            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,
            IO_Type.Column_Check_A7,
            };
            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,
            IO_Type.Column_Check_B7,
            };
            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",
            "A_Col7_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",
            "B_Col7_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);
                }
                else
                {
                    MessageBox.Show($"设备编号={DeviceID}与库位配置文件的料仓Id={position.StoreId}不匹配,请检查该列");
                    return;
                }
            }
        }
        public bool InStoreUpperDoorOpen()
        {
            if (IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.HIGH))
                return true;
            return false;
        }
        public override bool StartRun()
        {
            if (CanStartRun().Equals(false))
            {
                return false;
            }
            bool rtn = false;
            rtn = OpenAllAxis();
            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;
            rtn = OpenAllAxis();
            if (!rtn)
            {
                CloseAllAxis();
                return false;
            }
            mainTimer.Enabled = false;
            SetBoxStatus(DeviceStatus.ResetMove, RunStatus.Reset);
            MoveInfo.NewMove(MoveType.Reset);

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


        #region 复位处理
        private bool CanReset()
        {
            if (!AxisAlarmFlag && (PullAxis_Inout.IsInPosition(Config.PullAxis_Inout_CamA) ||
                PullAxis_Inout.IsInPosition(Config.PullAxis_Inout_CamB) ||
                PullAxis_Inout.IsInPosition(Config.PullAxis_Inout_P1)))
                return true;
            return false;
        }
        private void StartReset()
        {
            if (!CanReset())
            {
                if (System.Windows.Forms.MessageBox.Show("检测到可能的撞机风险，抽屉没有挂在进出轴上才能复位，是否继续？", "警告",
                    System.Windows.Forms.MessageBoxButtons.YesNo).Equals(System.Windows.Forms.DialogResult.No))
                {
                    SetBoxStatus(DeviceStatus.None, RunStatus.Wait);
                    MoveInfo.NewMove(MoveType.None);
                    LogInfo($"复位 {MoveInfo.SLog} ：确认取消");
                    return;
                }
            }

            if (!CheckTrayState(out string msg))
            {
                System.Windows.Forms.MessageBox.Show($"{msg},不允许启动/复位", "警告",
                    System.Windows.Forms.MessageBoxButtons.OK);
                SetBoxStatus(DeviceStatus.None, RunStatus.Wait);
                MoveInfo.NewMove(MoveType.None);
                LogInfo($"复位 {MoveInfo.SLog} ：因信号异常,{msg}");
                return;
            }
            CheckAndMove(IO_Type.DeviceLed, IO_VALUE.HIGH);
            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();
            //}
        }
        static int axisDiff = 20000;
        private void MoveResetPro()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            switch (MoveInfo.MoveStep)
            {
                //回零
                case StepEnum.BOX_H001_Wait:
                    if (GetCurLocation())
                    {
                        if (MoveAxis.IsInPosition(MoveInfo.MoveParam.MoveP.MoveAxis_P3))
                        {
                            MoveInfo.NextMoveStep(StepEnum.BOX_H002_PullAxis_UpdownToP3);
                            ComAxis_To_P2();
                            UpdownAxisTo_P6_P12();
                            PullAxis_UpdownToHighP3();
                            LogInfo($"复位 {MoveInfo.SLog}：抽屉在轴上,行走机构在抽屉位置,压紧轴到压紧前点，移栽升降轴到抽屉上方过度点，抽屉升降轴到高点P3");
                        }
                        else
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：抽屉在轴上,但行走机构不在抽屉位置{MoveInfo.MoveParam.MoveP.MoveAxis_P3}, 无法进行复位,请确认！");
                            System.Windows.Forms.MessageBox.Show($"抽屉在轴上, 但行走机构不在抽屉位置{MoveInfo.MoveParam.MoveP.MoveAxis_P3}，无法进行复位，请确认！");
                            SetBoxStatus(DeviceStatus.None, RunStatus.Wait);
                            MoveInfo.EndMove();
                        }
                    }
                    else
                    {
                        if (MoveAxis.IsInPosition(Config.MoveAxis_P2))
                        {
                            MoveInfo.NextMoveStep(StepEnum.BOX_H0101_CheckXAxisAndUpdownAxis);
                            if (MiddleAxis_A.IsInPosition(Config.MiddleAxis_A_P2) && XAxis_A.IsInPosition(Config.XAxis_A_P2))
                            {
                                ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_A_P2_Speed);
                                LogInfo($"复位 {MoveInfo.SLog}：抽屉未在料屉轴上,行走机构在暂存区,A面旋转轴在水平面，A面移栽X轴在暂存区取放料点P2，A面压紧轴张开");
                            }

                            if (MiddleAxis_B.IsInPosition(Config.MiddleAxis_B_P2) && XAxis_B.IsInPosition(Config.XAxis_B_P2))
                            {
                                ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_B_P2_Speed);
                                LogInfo($"复位 {MoveInfo.SLog}：抽屉未在料屉轴上,行走机构在暂存区,B面旋转轴在水平面，B面移栽X轴在暂存区取放料点P2，B面压紧轴张开");
                            }

                        }
                        else
                        {
                            MoveInfo.NextMoveStep(StepEnum.BOX_H01_CheckCurPullDownPos);
                            LogInfo($"复位 {MoveInfo.SLog}：抽屉未在抽屉轴上且行走机构不在暂存区,进出轴回待机点P1");
                            PullAxis_Inout_To_P1();
                        }
                    }
                    break;
                case StepEnum.BOX_H002_PullAxis_UpdownToP3:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H003_PullAxis_InoutToP2P4);
                    LogInfo($"复位 {MoveInfo.SLog}：推到抽屉提取点，抽屉拉取进出轴到抽屉提取点P2");
                    PullAxis_Inout_To_P2_P4();

                    //MoveInfo.NextMoveStep(StepEnum.BOX_H003_1_InoutToP1);
                    //LogInfo($"复位 {MoveInfo.SLog}：将抽屉拉到进出轴待机点");
                    //PullAxis_Inout_To_P1();
                    break;
                //case StepEnum.BOX_H003_1_InoutToP1:
                //    MoveInfo.NextMoveStep(StepEnum.BOX_H003_2_CheckDrawerIsInAxis);
                //    LogInfo($"复位 {MoveInfo.SLog}：在进出轴待机点");
                //    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                //    break;
                //case StepEnum.BOX_H003_2_CheckDrawerIsInAxis:
                //    MoveInfo.NextMoveStep(StepEnum.BOX_H03_PullAxis_InoutHome);
                //    LogInfo($"复位 {MoveInfo.SLog}：抽屉不在轴上，抽屉拉取进出轴回原点");
                //    //PullAxis_Inout.HomeMove(MoveInfo);
                //    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_H0101_CheckXAxisAndUpdownAxis:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H0101_XAxisToP1);
                    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);
                    LogInfo($"复位 {MoveInfo.SLog}：移栽X轴到P1");
                    break;
                case StepEnum.BOX_H0101_XAxisToP1:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H0102_MiddleAxisToP2);
                    if (!MiddleAxis_A.IsInPosition(Config.MiddleAxis_A_P2))
                    {
                        MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P2, Config.MiddleAxis_A_P2_Speed);
                        LogInfo($"复位 {MoveInfo.SLog}：A面旋转轴不在水平面，A面移栽旋转轴到水平点");
                    }
                    if (!MiddleAxis_B.IsInPosition(Config.MiddleAxis_B_P2))
                    {
                        MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P2, Config.MiddleAxis_B_P2_Speed);
                        LogInfo($"复位 {MoveInfo.SLog}：B面旋转轴不在水平面，B面移栽旋转轴到水平点");
                    }
                    break;
                case StepEnum.BOX_H0102_MiddleAxisToP2:
                    if (IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.LOW) || IOValue(IO_Type.LineA_ReelInPlaceCheck).Equals(IO_VALUE.LOW))
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H0103_ToAInputHighPos);
                        if (UpdownAxis.GetAclPosition() >= (MoveInfo.MoveParam.MoveP.Updown_P5 - axisDiff) && UpdownAxis.GetAclPosition() <= (MoveInfo.MoveParam.MoveP.Updown_P4 + axisDiff)
                            && (BufferDataManager.AOutStoreInfo == null || IOValue(IO_Type.LineA_ReelInPlaceCheck).Equals(IO_VALUE.LOW)))
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在A下暂存区低点和高点之间,到高点P4,A面移栽X轴去暂存区P2,A面压紧轴到压紧前点P2");
                            ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_A_P2_Speed);
                            XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P2, Config.XAxis_A_P2_Speed);
                            UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P4, Config.Updown_P4_Speed);
                        }
                        else if (UpdownAxis.GetAclPosition() >= (MoveInfo.MoveParam.MoveP.Updown_P3 - axisDiff) && UpdownAxis.GetAclPosition() <= (MoveInfo.MoveParam.MoveP.Updown_P2 + axisDiff)
                            && (BufferDataManager.AInStoreInfo == null || IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.LOW)))
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在A上暂存区低点和高点之间,到高点P2,A面移栽X轴去暂存区P2，A面压紧轴到压紧前点P2");
                            ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_A_P2_Speed);
                            XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P2, Config.XAxis_A_P2_Speed);
                            UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P2, Config.Updown_P2_Speed);
                        }
                        else
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴不在A暂存区低点和高点之间，不动作");
                        }
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H0105_A_XAxisToP1);
                        XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P1, Config.XAxis_A_P1_Speed);
                        LogInfo($"复位 {MoveInfo.SLog}：A暂存区有料，A面移栽X轴到待机点P1");
                    }
                    break;
                case StepEnum.BOX_H0103_ToAInputHighPos:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H0104_ToAInputLowPos);
                    if (UpdownAxis.IsInPosition(MoveInfo.MoveParam.MoveP.Updown_P2))
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在A上暂存区低点P3");
                        UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P3, Config.Updown_P3_Speed);
                    }
                    else if (UpdownAxis.IsInPosition(MoveInfo.MoveParam.MoveP.Updown_P4))
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在A下暂存区低点P5");
                        UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P5, Config.Updown_P5_Speed);
                    }
                    else
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴不在A暂存区低点和高点之间，不动作");
                    }
                    break;
                case StepEnum.BOX_H0104_ToAInputLowPos:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H0105_A_XAxisToP1);
                    XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P1, Config.XAxis_A_P1_Speed);
                    LogInfo($"复位 {MoveInfo.SLog}：A面移栽X轴到待机点P1");
                    break;

                case StepEnum.BOX_H0105_A_XAxisToP1:
                    if (IOValue(IO_Type.FeedB_ReelCheck).Equals(IO_VALUE.LOW) || IOValue(IO_Type.LineB_ReelInPlaceCheck).Equals(IO_VALUE.LOW))
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H0105_ToBInputHighPos);
                        if (UpdownAxis.GetAclPosition() >= (MoveInfo.MoveParam.MoveP.Updown_P11 - axisDiff) && UpdownAxis.GetAclPosition() <= (MoveInfo.MoveParam.MoveP.Updown_P10 + axisDiff) &&
                            (BufferDataManager.BOutStoreInfo == null || IOValue(IO_Type.LineB_ReelInPlaceCheck).Equals(IO_VALUE.LOW)))
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在B下暂存区低点和高点之间,到高点P10,B面移栽X轴去暂存区P2,B面压紧轴到压紧前点P2");
                            ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_B_P2_Speed);
                            XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P2, Config.XAxis_B_P2_Speed);
                            UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P10, Config.Updown_P10_Speed);
                        }
                        else if (UpdownAxis.GetAclPosition() >= (MoveInfo.MoveParam.MoveP.Updown_P9 - axisDiff) && UpdownAxis.GetAclPosition() <= (MoveInfo.MoveParam.MoveP.Updown_P8 + axisDiff) &&
                            (BufferDataManager.BInStoreInfo == null || IOValue(IO_Type.FeedB_ReelCheck).Equals(IO_VALUE.LOW)))
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在B上暂存区低点和高点之间,到高点P8,B面移栽X轴去暂存区P2,B面压紧轴到压紧前点P2");
                            ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_B_P2_Speed);
                            XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P2, Config.XAxis_B_P2_Speed);
                            UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P8, Config.Updown_P8_Speed);
                        }
                        else
                        {
                            LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴不在B暂存区低点和高点之间，不动作");
                        }
                    }
                    else
                    {
                        MoveInfo.NextMoveStep(StepEnum.BOX_H01_CheckCurPullDownPos);
                        XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P1, Config.XAxis_B_P1_Speed);
                        MoveAxisToP1();
                        LogInfo($"复位 {MoveInfo.SLog}：B暂存区有料，B面移栽X轴到待机点P1,行走机构到待机点P1，在暂存区复位结束");
                    }
                    break;
                case StepEnum.BOX_H0105_ToBInputHighPos:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H0106_ToBInputLowPos);
                    if (UpdownAxis.IsInPosition(MoveInfo.MoveParam.MoveP.Updown_P8))
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在B上暂存区低点P9");
                        UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P9, Config.Updown_P9_Speed);
                    }
                    else if (UpdownAxis.IsInPosition(MoveInfo.MoveParam.MoveP.Updown_P10))
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴在B下暂存区低点P11");
                        UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P11, Config.Updown_P11_Speed);
                    }
                    else
                    {
                        LogInfo($"复位 {MoveInfo.SLog}：移栽升降轴不在B暂存区低点和高点之间，不动作");
                    }
                    break;
                case StepEnum.BOX_H0106_ToBInputLowPos:
                    MoveInfo.NextMoveStep(StepEnum.BOX_H01_CheckCurPullDownPos);
                    XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P1, Config.XAxis_B_P1_Speed);
                    MoveAxisToP1();
                    LogInfo($"复位 {MoveInfo.SLog}：B面移栽X轴到待机点P1,行走机构到待机点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_Updown.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);
                    PullAxis_Updown.AbsMove(MoveInfo, Config.PullAxis_Updown_P1, Config.PullAxis_Updown_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}：所有轴到达待机位完成");
                    BuffAreaInstoreDoor(false);
                    BuffAreaOutstoreDoor(false);
                    SetBoxStatus(DeviceStatus.StoreOnline, RunStatus.Runing);
                    MoveInfo.EndMove();
                    CheckBoxLine();
                    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;
        private DateTime errUpperA = DateTime.Now;
        private DateTime errUpperB = DateTime.Now;
        private DateTime errUnderA = DateTime.Now;
        private DateTime errUnderB = DateTime.Now;
        int SigLastTime = 2;//5秒
        protected override void OnTimerProcess()
        {
            if (IsDebug) return;
            //if (!runStatus.Equals(RunStatus.Runing))
            //    return;
            TimeSpan tsUppA = DateTime.Now - errUpperA;
            TimeSpan tsUnA = DateTime.Now - errUnderA;
            TimeSpan tsUppB = DateTime.Now - errUpperB;
            TimeSpan tsUnB = DateTime.Now - errUnderB;
            int errSeconds = 10;
            if (IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.LOW) && BufferDataManager.AInStoreInfo != null)
            {
                if (tsUppA.TotalSeconds > errSeconds)
                    SetWarnMsg("A上进料暂存区有料盘，但信号未亮");
            }
            else
            {
                ClearSpecifiedAlarm("A上进料暂存区有料盘，但信号未亮");
                errUpperA = DateTime.Now;
            }
            if (IOValue(IO_Type.LineA_ReelInPlaceCheck).Equals(IO_VALUE.LOW) && BufferDataManager.AOutStoreInfo != null)
            {
                if (tsUnA.TotalSeconds > errSeconds)
                    SetWarnMsg("A下出料暂存区有料盘，但信号未亮");
            }
            else
            {
                ClearSpecifiedAlarm("A下出料暂存区有料盘，但信号未亮");
                errUnderA = DateTime.Now;
            }
            if (IOValue(IO_Type.FeedB_ReelCheck).Equals(IO_VALUE.LOW) && BufferDataManager.BInStoreInfo != null)
            {
                if (tsUppB.TotalSeconds > errSeconds)
                    SetWarnMsg("B上进料暂存区有料盘，但信号未亮");
            }
            else
            {
                ClearSpecifiedAlarm("B上进料暂存区有料盘，但信号未亮");
                errUpperB = DateTime.Now;
            }
            if (IOValue(IO_Type.LineB_ReelInPlaceCheck).Equals(IO_VALUE.LOW) && BufferDataManager.BOutStoreInfo != null)
            {
                if (tsUnB.TotalSeconds > errSeconds)
                    SetWarnMsg("B下出料暂存区有料盘，但信号未亮");
            }
            else
            {
                ClearSpecifiedAlarm("B下出料暂存区有料盘，但信号未亮");
                errUnderB = DateTime.Now;
            }
        }
        private void ExecuteOutListProcess()
        {
            try
            {
                if (waitAOutStoreList.Count > 0)//
                {
                    if (CloseOutStoreCheck)
                    {
                        InOutParam param = null;
                        bool result = waitAOutStoreList.TryDequeue(out param);
                        if (result && param != null)
                        {
                            //LogInfo("执行A面排队的出库【" + param.PosInfo.ToStr() + "】");
                            StartExecuctOut(param);
                            return;
                        }
                    }
                    else if (CheckAOutDoor())
                    {
                        InOutParam param = null;
                        bool result = waitAOutStoreList.TryDequeue(out param);
                        if (result && param != null)
                        {
                            //LogInfo("执行A面排队的出库【" + param.PosInfo.ToStr() + "】");
                            StartExecuctOut(param);
                            return;
                        }
                    }
                }
                else
                {
                    BufferDataManager.SideAHasOutTask = true;
                }
                if (waitBOutStoreList.Count > 0)//
                {
                    if (CloseOutStoreCheck)
                    {
                        InOutParam param = null;
                        bool result = waitBOutStoreList.TryDequeue(out param);
                        if (result && param != null)
                        {
                            //LogInfo("执行B面排队的出库【" + param.PosInfo.ToStr() + "】");
                            StartExecuctOut(param);
                            return;
                        }
                    }
                    else if (CheckBOutDoor())
                    {
                        InOutParam param = null;
                        bool result = waitBOutStoreList.TryDequeue(out param);
                        if (result && param != null)
                        {
                            //LogInfo("执行B面排队的出库【" + param.PosInfo.ToStr() + "】");
                            StartExecuctOut(param);
                            return;
                        }
                    }
                }
                else
                {
                    BufferDataManager.SideBHasOutTask = true;

                }

                TimeSpan timeSpanA = DateTime.Now - dtUpperA;
                TimeSpan timeSpanB = DateTime.Now - dtUpperB;

                if (IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.HIGH) && BufferDataManager.AInStoreInfo != null
                    && IOValue(IO_Type.FeedB_ReelCheck).Equals(IO_VALUE.HIGH) && BufferDataManager.BInStoreInfo != null)
                {
                    StartInstore(new InOutParam() { PosInfo = BufferDataManager.AInStoreInfo, PosInfoBack = BufferDataManager.BInStoreInfo });
                }
                //检测A上暂存区是否有料盘
                if (IOValue(IO_Type.FeedA_ReelCheck).Equals(IO_VALUE.HIGH) && BufferDataManager.AInStoreInfo != null)
                {
                    if (timeSpanA.TotalSeconds >= SigLastTime)
                    {
                        StartInstore(new InOutParam(BufferDataManager.AInStoreInfo));
                        return;
                    }

                }
                else
                {
                    dtUpperA = DateTime.Now;
                }
                //检测B上暂存区是否有料盘
                if (IOValue(IO_Type.FeedB_ReelCheck).Equals(IO_VALUE.HIGH) && BufferDataManager.BInStoreInfo != null)
                {
                    if (timeSpanB.TotalSeconds >= SigLastTime)
                    {
                        StartInstore(new InOutParam(BufferDataManager.BInStoreInfo));
                        return;
                    }

                }
                else
                {
                    dtUpperB = DateTime.Now;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "处理出库排队列表出错：" + ex.ToString());
            }
        }
        protected override void BaseTimerProcess()
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
            DoorLimitProcess();
            if (runStatus.Equals(RunStatus.Runing))
            {
                ExecuteOutListProcess();

            }
            if (isInitPosDebugInfo)
            {
                PosDebugProcess();
            }
            BusyMoveProcess();
            LineProcess();
            IOTimeOutProcess();
            if (NoErrorAlarm())
            {
                CheckAxisAlarm();
            }
        }
        /// <summary>
        /// 启动完成后检查线体是否有料盘
        /// </summary>
        void CheckBoxLine()
        {
            if (BufferDataManager.ALineStoreInfo != null)
            {
                LogInfo("启动完成，A皮带线有料盘，启动线体处理");
                StartLineARun(new InOutParam(BufferDataManager.ALineStoreInfo));
            }
            if (BufferDataManager.BLineStoreInfo != null)
            {
                LogInfo("启动完成，B皮带线有料盘，启动线体处理");
                StartLineBRun(new InOutParam(BufferDataManager.BLineStoreInfo));
            }
        }
        /// <summary>
        /// 皮带线处理
        /// </summary>
        private void LineProcess()
        {
            if (MoveInfoLineA.MoveType.Equals(MoveType.Working))
                LineAProcess();
            if (MoveInfoLineB.MoveType.Equals(MoveType.Working))
                LineBProcess();
        }
        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("");
                    }
                    if (MoveInfoLineA.IsInWait.Equals(false) && NoErrorAlarm())
                    {
                        LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                        alarmType = AlarmType.None;
                        SetWarnMsg("");
                    }
                    if (MoveInfoLineB.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 = "";
            msg += "runStatus：  " + runStatus + "\n";
            msg += "runStep：  " + MoveInfo.MoveStep + "\n";
            msg += "alarm：  " + alarmType + "\n";
            msg += $"stepMsg:{StepMsg}" + "\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))
                {
                    SetWarnMsg(Name + outMsg);
                    return false;
                }
            }
            return true;
        }

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


        #endregion

        #region 门禁
        //门禁状态：0正常。1=安全门禁打开，已停止运动
        private int CurDoorLimitState = 0;
        protected void DoorLimitProcess()
        {
            try
            {
                if (!baseConfig.DIList.ContainsKey(IO_Type.FrontDoor_Limit))
                {
                    return;
                }
                if (!baseConfig.DIList.ContainsKey(IO_Type.BackDoor_Limit))
                {
                    return;
                }

                if (CurDoorLimitState.Equals(0))
                {
                    if (StoreManager.DisBoxDoorLimit)
                    {
                    }
                    else if (IOValue(IO_Type.FrontDoor_Limit).Equals(IO_VALUE.LOW))
                    {
                        SecurityAccessStop("前门门禁");
                    }
                    else if (IOValue(IO_Type.BackDoor_Limit).Equals(IO_VALUE.LOW))
                    {
                        SecurityAccessStop("后门门禁");
                    }
                }
                else if (CurDoorLimitState.Equals(1))
                {
                    if (IOValue(IO_Type.FrontDoor_Limit).Equals(IO_VALUE.HIGH) &&
                        IOValue(IO_Type.BackDoor_Limit).Equals(IO_VALUE.HIGH))
                    {
                        SecurityAccessReset();
                    }
                }

            }
            catch (Exception ex)
            {
                LogUtil.error(Name + " 出错 ：" + ex.ToString());
            }

        }

        private void SecurityAccessStop(string doorname)
        {
            if (!baseConfig.DIList.ContainsKey(IO_Type.FrontDoor_Limit))
            {
                return;
            }
            if (!baseConfig.DIList.ContainsKey(IO_Type.BackDoor_Limit))
            {
                return;
            }
            CurDoorLimitState = 1;
            if (alarmType > (AlarmType.IoSingleTimeOut))
            {
                return;
            }

            LogUtil.info($"{Name} {doorname}被打开，停止当前运动{MoveInfo.MoveType},MoveStop={MoveStop}，暂停运动");
            MoveStop = true;
            SetWarnMsg($"{doorname}被打开，{Name}暂停运动");
            //Alarm(AlarmType.SuddenStop);

        }

        private void SecurityAccessReset()
        {
            if (!baseConfig.DIList.ContainsKey(IO_Type.FrontDoor_Limit))
            {
                return;
            }
            if (!baseConfig.DIList.ContainsKey(IO_Type.BackDoor_Limit))
            {
                return;
            }
            CurDoorLimitState = 0;
            //MoveStop = false;
            if (WarnMsg.Contains("暂停运动"))
            {
                SetWarnMsg("");
            }
            if (alarmType > (AlarmType.IoSingleTimeOut))
            {
                return;
            }
            //光栅恢复处理
        }
        #endregion


    }
}