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>();

        private Store_Config _config;
        public new Store_Config Config
        {
            get
            {
                return _config;
            }
            set
            {
                //base.Config = (BaseConfig)value;
                _config = value;
            }
        }
        public bool UseBuzzer = ConfigAppSettings.GetIntValue(Setting_Init.UseBuzzer).Equals(1);
        /// <summary>
        /// 取料提升机构气缸
        /// </summary>
        //public HoisterCylinder hoisterCylinder = new HoisterCylinder(0);
        public ElectricGripper electricClamp = new ElectricGripper();
        public AxisBean T1_BatchAxis = null;
        public AxisBean T2_MiddleAxis = null;
        public AxisBean T3_UpdownAxis = null;
        public AxisBean T4_InOut_Axis = null;
        public bool HasT4Axis = false;

        /// <summary>
        /// 轴列表
        /// </summary>
        public override List<ConfigMoveAxis> moveAxisList { get; set; } = new List<ConfigMoveAxis>();

        #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);
                bool boxDisable = ConfigAppSettings.GetIntValue("Store_CID_" + config.Id + "_disabled") == 1 ? true : false;
                equip.Disabled = boxDisable;
                AddDeviceName(ioList, config.IOIPList);
                BoxMap.Add(config.Id, equip);
                BoxConfigMap.Add(config.Id, config);
            }
            //Config.T1_Batch_Axis.BreakOnDO = IO_Type.BatchAxis_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);
            T4_InOut_Axis = new AxisBean(Config.T4_InOut_Axis, Name);

            moveAxisList = new List<ConfigMoveAxis>();
            moveAxisList.Add(Config.T1_Batch_Axis);
            moveAxisList.Add(Config.T2_Middle_Axis);
            moveAxisList.Add(Config.T3_Updown_Axis);
            moveAxisList.Add(Config.T4_InOut_Axis);

            AgvClient.NodeList.Add(Config.AgvInName);
            AgvClient.NodeList.Add(Config.AgvOutName);


            IOManager.Init();

            CodeManager.LoadConfig();
            CurrShelfNum = ConfigAppSettings.GetIntValue(Setting_Init.CurrShelfNum);
            CurrShelfType = ConfigAppSettings.GetIntValue(Setting_Init.CurrShelfType);
            UpdateShelfNum(CurrShelfNum, CurrShelfType);
            HasT4Axis  = Convert.ToBoolean(ConfigAppSettings.GetValue(Setting_Init.HasT4Axis));
            Task.Factory.StartNew(delegate
            {

                //RFIDManager.RfidReader.Open(rfidList.ToArray());
                IOManager.instance.ConnectionIOList(ioList);
                AxisManager.Init();
                //AgvClient.Init();
                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;
                if (!electricClamp.OpenPort(Config.Clamp1Port))
                {
                    Thread.Sleep(1000);
                    electricClamp.ClosePort();
                    if (!electricClamp.OpenPort(Config.Clamp1Port))
                    {
                        LogUtil.info(Name + $"电动夹爪打开失败 端口：{Config.Clamp1Port}");
                        return;
                    }
                }
                LogUtil.info(Name + $"加载电夹爪成功：{Config.Clamp1Port}");
                electricClamp.HomeReset();

                canStart = true;
                int isAuto = ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun);
                if (isAuto == 1)
                {
                    IoCheckTimer.Enabled = true;
                }

                LogUtil.info(Name + "初始化完成.等待启动.");
            });
        }
         
        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
            {
                if (!OpenAllAxis(true))
                {
                    return false;
                }
                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;
        }
        bool boxreset = true;
        public override void Reset(bool isNeedClearAuto = true)
        {
            mainTimer.Enabled = false;

            //停止运动
            MoveInfo.EndMove();
            if (!OpenAllAxis(true))
            {
                LogInfo("复位时打开轴失败，需要再次复位，直接报警停止复位");
                return;
            }
            runStatus = StoreRunStatus.Reset;
            StartResetMove();
            boxreset = true;
            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;
        }
        public void ResetLine()
        {
            mainTimer.Enabled = false;
            boxreset = false;
            //停止运动
            MoveInfo.EndMove();
            if (!OpenAllAxis(true))
            {
                LogInfo("复位时打开轴失败，需要再次复位，直接报警停止复位");
                return;
            }
            runStatus = StoreRunStatus.Reset;
            StartResetMove();
            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_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_Stop4_Out, IO_VALUE.LOW)); 
        }

        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_wait);
                LogUtil.info(Name + "复位 " + MoveInfo.MoveStep + " ：夹爪回原点，提升轴回原点，上下轴回原点，流水线停止");
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                electricClamp.HomeReset(MoveInfo);

                T1_BatchAxis.HomeMove(MoveInfo);
                T3_UpdownAxis.HomeMove(MoveInfo);
                LineStop(MoveInfo);
            }
            else if (MoveInfo.IsStep(StoreMoveStep.LR_03_BatchAxisHome_wait))
            {
                MoveInfo.NextMoveStep(StoreMoveStep.LR_03_BatchAxisHome);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            }
            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);
                electricClamp.Release(MoveInfo);
            }
            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);
                IOMove(IO_Type.RaiseStation_LocationUp, IO_VALUE.LOW);
                IOMove(IO_Type.RaiseStation_LocationDown, IO_VALUE.HIGH);
                //InOutStation_LocationDown();
                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;

                if (!boxreset)
                {
                    LogUtil.info(Name + "线体重置完成");
                    MoveEndP();
                    return;
                }
                //判断是否所有的已经返回完成
                string msg = "等待BOX复位完成超时";
                foreach (BoxBean box in this.BoxMap.Values)
                {
                    if (box.Disabled)
                        continue;
                    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();
            //轴运动停止
            T3_UpdownAxis.SuddenStop();
            T2_MiddleAxis.SuddenStop();
            T1_BatchAxis.SuddenStop();
            T4_InOut_Axis.SuddenStop();
            CloseAllAxis();

            LineStop();
        }
        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 + ",停止运行，总运行时间：" + 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);
                }
                if (IOValue(IO_Type.Line_OutCheck).Equals(IO_VALUE.HIGH))
                {
                    //IOMove(IO_Type.LineOut_Led, IO_VALUE.HIGH);
                }
                else
                {
                    //IOMove(IO_Type.LineOut_Led, IO_VALUE.LOW);
                }
                if (IOValue(IO_Type.Line_InCheck).Equals(IO_VALUE.LOW))
                {
                    //IOMove(IO_Type.LineIn_Led, IO_VALUE.HIGH);
                }
                else
                {
                    //IOMove(IO_Type.LineIn_Led, 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();
                    IOMinoitor();
                    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_Run).Equals(IO_VALUE.LOW) &&
                      IOValue(IO_Type.Line_BufferCheck).Equals(IO_VALUE.HIGH) &&
                      IOValue(IO_Type.Line_Stop4_Out).Equals(IO_VALUE.LOW) &&
                      LowProcess.Equals(false))
                {
                    if (StoreManager.checkWatch(lowWatch, 3000))
                    {
                        //左侧下层需要放个料架
                        Task.Run(()=>
                        {
                            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());
            }
        }
        public void OneShelfOutProcess()
        {
            try
            {
                if (IOValue(IO_Type.Line_OutCheck).Equals(IO_VALUE.HIGH) &&
                      IOValue(IO_Type.Line_Run).Equals(IO_VALUE.LOW) &&
                      LowProcess.Equals(false))
                {
                    if (StoreManager.checkWatch(lowWatch, 3000))
                    {
                        //左侧下层需要放个料架
                        Task.Run(() =>
                        {
                            LowProcess = true;
                            LogUtil.info(Name + "送出一个料架");
                            IOMove(IO_Type.Line_Run, IO_VALUE.HIGH, false, 30000);
                            IOMove(IO_Type.Line_Stop4_Out, IO_VALUE.HIGH, false, 1000);
                            if (WaitIo(IO_Type.Line_OutCheck, IO_VALUE.LOW, 30000, "送出一个料架"))
                            {
                                LineStop();
                            }
                            LowProcess = false;
                        });
                    }
                }
                else
                {
                    lowWatch.Stop();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + " OneShelfOutProcess 出错：" + ex.ToString());
            }
        }

        #endregion
        void IOMinoitor() {
            if (IOValue(IO_Type.Line_WaitCheck).Equals(IO_VALUE.LOW) && AgvClient.GetAction(Config.AgvInName) == ClientAction.None)
            {
                AgvClient.NeedEnter(Config.AgvInName);
            }
            if (IOValue(IO_Type.Line_OutCheck).Equals(IO_VALUE.HIGH) && AgvClient.GetAction(Config.AgvOutName) == ClientAction.None)
            {
                AgvClient.NeedLeave(Config.AgvOutName);
            }
        }


        public int GetShelfNum()
        {
            int ShelfCheck1 = 0;// (int)IOValue(IO_Type.ShelfCheck1);
            int ShelfCheck2 = 0;//(int)IOValue(IO_Type.ShelfCheck2);
            int ShelfCheck3 = 0;//(int)IOValue(IO_Type.ShelfCheck3);
            int ShelfCheck4 = 0;//(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_Run, IO_VALUE.HIGH));
            }
            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_Run, IO_VALUE.LOW));
            }
            IOMove(IO_Type.Line_Run, IO_VALUE.LOW);
        }

        public void OpenGate(StoreMoveInfo move = null) {
            CylinderMove(move, IO_Type.RightDoor_Close, IO_Type.RightDoor_Open);
            CylinderMove(move, IO_Type.LeftDoor_Close, IO_Type.LeftDoor_Open);
        }
        public void CloseGate(StoreMoveInfo move = null)
        {
            CylinderMove(move, IO_Type.RightDoor_Open, IO_Type.RightDoor_Close);
            CylinderMove(move, IO_Type.LeftDoor_Open, IO_Type.LeftDoor_Close);
        }
        public bool OpenAllAxis(bool isCheck = true)
        {
            if (RunMultiAxis(isCheck, new AxisBean []{ T3_UpdownAxis,T2_MiddleAxis,T4_InOut_Axis, T1_BatchAxis }))
            {
                return true;
                //if (RunAxis(isCheck, T1_BatchAxis)  )                    
                //   return true;
            }
            return false;
        }

        public void CloseAllAxis()
        {
            CloseMultiAxis(new AxisBean[] { T3_UpdownAxis, T2_MiddleAxis, T4_InOut_Axis, T1_BatchAxis });
            //CloseAxis(T1_BatchAxis); 
        }
    }
}