using HuichuanLibrary;
using log4net;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using System.Windows.Forms;

namespace OnlineStore.DeviceLibrary
{ 
    public partial class LineBean : KTK_Store
    {
        public bool IsDebug = false;  
        private System.Timers.Timer ledProcessTimer = null;
        /// <summary>
        /// 分出一个线程，专门处理急停，报警，气压检测，工单信号检测等处理
        /// </summary>
        private System.Timers.Timer IoCheckTimer = null;

        private System.Timers.Timer serverConTimer = null;
         
        public Dictionary<int, MoveEquip> MoveEquipMap { get; set; }

        public Dictionary<int, FeedingEquip> FeedingEquipMap { get; set; }
        public Dictionary<int, HYEquipBase> HYEquipMap { get; set; } 
        public Dictionary<int, EquipBase> AllEquipMap { get; set; }
         
        public Line_Config Config { get; set; }

        #region  初始化
        public List<string> cioList = new List<string>(); 
        private bool canStart = false;

        public LineBean(Line_Config lineConfig, Dictionary<int, MoveEquip_Config> configList, Dictionary<int, FeedingEquip_Config> feedMap,
            Dictionary<int, HYEquip_Config> hyConfigMap)
        {
            if (lineConfig.IOSingle_TimerOut <= 0)
            {
                lineConfig.IOSingle_TimerOut = 5000;
            }
            Init();
            InitTimer();
            baseConfig = lineConfig;
            this.Config = lineConfig;
            this.DeviceID = lineConfig.Id;
            T3C1_MoveInfo = new LineMoveInfo(DeviceID, " T3-C1 "); 
            MoveInfo = new LineMoveInfo(DeviceID, "[流水线-Move] ");
            Name = (" 流水线_" + Config.CID + " ").ToUpper();
             

            AllEquipMap = new Dictionary<int, EquipBase>();
            MoveEquipMap = new Dictionary<int, MoveEquip>();
            FeedingEquipMap = new Dictionary<int, FeedingEquip>();
            HYEquipMap = new Dictionary<int, HYEquipBase>(); 
            List<string> ioList = new List<string>();
            ioList = new List<string>(DeviceConfig.ProIOIpMap.Values);
            AddDeviceName(ioList, Config.IOIPList);

            foreach (FeedingEquip_Config config in feedMap.Values)
            {
                FeedingEquip equip = new FeedingEquip(lineConfig.CID, config);
                //增加AGV小车客户端
                AgvClient.NodeList.Add(config.AgvInName);
                AgvClient.NodeList.Add(config.AgvOutName);

                AddDeviceName(ioList, config.IOIPList);
                FeedingEquipMap.Add(config.Id, equip);
                AllEquipMap.Add(config.Id, equip); 
            }
            foreach (MoveEquip_Config config in configList.Values)
            {
                MoveEquip equip = new MoveEquip(lineConfig.CID, config); 
                AddDeviceName(ioList, config.IOIPList);
                MoveEquipMap.Add(config.Id, equip);
                AllEquipMap.Add(config.Id, equip);
            }
            foreach (HYEquip_Config config in hyConfigMap.Values)
            {
                HYEquipBase equip =HYEquipBase.GetHY(  lineConfig.CID, config); 
                AddDeviceName(ioList, config.IOIPList);
                HYEquipMap.Add(config.Id, equip);
                AllEquipMap.Add(config.Id, equip); 
            }

            //先初始化设备
            HCBoardManager.InitConfig();
            IOManager.Init();
            AxisManager.Init();
            AxisManager.instance.OpenCard();

            //初始化摄像机配置  
            CodeManager.LoadConfig();

            cioList = new List<string>(ioList); 
           
            Task.Factory.StartNew(delegate
            {
                LogUtil.info(Name + "开始连接IO模块 ");
                IOManager.instance.ConnectionIOList(cioList);
                addLastDI(IO_Type.Airpressure_Check, IOValue(IO_Type.Airpressure_Check));
                addLastDI(IO_Type.SuddenStop_BTN, IOValue(IO_Type.SuddenStop_BTN));
                addLastDI(IO_Type.Reset_BTN, IOValue(IO_Type.Reset_BTN)); 

                mainTimer.Enabled = true;
                IoCheckTimer.Enabled = true;
                AgvClient.Init();
                canStart = true;

            });
        }


        private void AddDeviceName(List<string> targetList, List<string> list)
        {
            foreach (string str in list)
            {
                if (!targetList.Contains(str))
                {
                    targetList.Add(str);
                }
            }
        }
        public void InitTimer()
        {
            ledProcessTimer = new System.Timers.Timer();
            ledProcessTimer.Interval = 1000;
            ledProcessTimer.Elapsed += LedProcess;
            ledProcessTimer.AutoReset = true;
            ledProcessTimer.Enabled = false;

            IoCheckTimer = new System.Timers.Timer();
            IoCheckTimer.Interval = 200;
            IoCheckTimer.Elapsed += IoCheckTimerProcess;
            IoCheckTimer.AutoReset = true;
            IoCheckTimer.Enabled = false;
            
            serverConTimer = new System.Timers.Timer();
            serverConTimer.Interval = 3000;
            serverConTimer.AutoReset = true;
            serverConTimer.Elapsed += ServerConTimer_Elapsed;
            serverConTimer.Enabled = false;
        }


        #endregion

        public string CanStart()
        {
            if (!canStart)
            {
                return "启动失败：设备未初始化完成";
            }
            if (!HCBoardManager.CardInitOk())
            {
                return "启动失败：板卡未初始化完成";
            }
            if (MoveEquipMap == null)
            {
                return "启动失败：未加载到移栽信息";
            }
            if (IsDebug)
            {
                return "";
            }

            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                return "启动失败：急停未开";

            }
            else if (IOValue(IO_Type.Airpressure_Check).Equals(IO_VALUE.LOW))
            {
                return "启动失败：没有气压信号";
            }
            return "";
        }
        public override bool StartRun(bool isDebug = false)
        {
            string result = CanStart();
            if (String.IsNullOrEmpty(result).Equals(false))
            {
                SetWarnMsg(result);
                return false;
            }
            else if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg("启动失败：急停未开");
                return false;
            }
            else
            {
                // ledProcessTimer.Enabled = false;
                IoCheckTimer.Enabled = false;
                mainTimer.Enabled = false;
                ledProcessTimer.Enabled = true;
               
                runStatus = LineRunStatus.HomeMoving;
                StartTime = DateTime.Now;
                LogUtil.info(Name + "开始启动，启动时间：" + StartTime.ToString() + "先转动链条");
                WriteDrivetMotorRun(IO_VALUE.HIGH);

                Thread.Sleep(5);

                LineServer.StartServer(ConfigAppSettings.GetIntValue(Setting_Init.TCPServerPort));
                RHomeOp();

                foreach (EquipBase moveEquip in this.AllEquipMap.Values)
                {
                    //如果已经转动5秒，先停止链条
                    TimeSpan span = DateTime.Now - StartTime;
                    if (span.TotalSeconds > 5)
                    {
                        LogUtil.info(Name + "链条转动超过5秒，先停止链条转动");
                        WriteDrivetMotorRun(IO_VALUE.LOW);
                    }
                    if (runStatus.Equals(LineRunStatus.Wait))
                    {
                        LogUtil.error(Name + "启动过程中发现 runStatus=Wait，中断启动");
                        return false;
                    }

                    EquipStartRun(moveEquip);
                }
                if (runStatus.Equals(LineRunStatus.Wait))
                { return false; }
                RFIDManager.Open();
                // WriteDrivetMotorRun(IO_VALUE.LOW);
                IoCheckTimer.Enabled = true;
                mainTimer.Enabled = true;
                serverConTimer.Enabled = true;
                return true;
            }
        }
        private void EquipStartRun(EquipBase moveEquip)
        {
            if (moveEquip.IsDebug)
            {
                moveEquip.OpenStopBlock();
            }
            else if(moveEquip.runStatus.Equals(LineRunStatus.Wait))
            {
                bool result = moveEquip.StartRun();
                Thread.Sleep(60);
            }
            else
            {
                LogUtil.info(Name + " EquipStartRun：" + moveEquip.Name+" 已启动，不需要重复启动");
            }
        }
        private void RHomeOp()
        {
            mainTimer.Interval = 1000;
            maxSeconds = 10;
            //  TrayManager.SidesWayStateMap = new System.Collections.Concurrent.ConcurrentDictionary<int, int>() ;
            alarmType = LineAlarmType.None;
            mainTimer.Enabled = false;
            IoCheckTimer.Enabled = false; 
            isInSuddenDown = false;
            isNoAirCheck = false;
            TrayManager.TrayErrorMsg = "";
            SetWarnMsg("");
            MoveInfo.NewMove(LineMoveType.Reset);
            MoveInfo.NextMoveStep(LineMoveStep.Wait);
            if (TrayManager.ErrorDeviceId > 0)
            {
                if (MoveEquipMap.ContainsKey(TrayManager.ErrorDeviceId))
                {
                    MoveEquipMap[TrayManager.ErrorDeviceId].preTrayNum = 0;
                }
            }
            TrayManager.ErrorDeviceId = -1;

            T3C1_Stop(MoveInfo);
            T3C1_TrayNum = -1;
          
        }

        public override bool Reset()
        {
            mainTimer.Enabled = false;
            IoCheckTimer.Enabled = false; 
            bool isNeedAllReset = false;

            if (isInSuddenDown || isNoAirCheck)
            {
                //TrayManager.LineNeedEmptyTrayNum = 0;
                isNeedAllReset = true;
                LogUtil.error(Name + "收到复位信号，急停中或没有气压报警中，强制所有设备复位~");
            }
            else if ((runStatus == LineRunStatus.HomeMoving || runStatus == LineRunStatus.Reset) && NoAlarm())
            {
                LogUtil.error(Name + "收到复位信号，已经在复位或原点返回中，且当前无报警，不处理复位");
                return false;
            }

            //停止运动
            MoveInfo.EndMove();
             
            runStatus = LineRunStatus.Reset;
            LogUtil.info(Name + "开始复位，先转动链条5秒  ");
            DateTime rstartTime = DateTime.Now;
            WriteDrivetMotorRun(IO_VALUE.HIGH);
            //重置通用处理
            RHomeOp();

            foreach (EquipBase equip in AllEquipMap.Values)
            {      
                //如果已经转动5秒，先停止链条
                TimeSpan span = DateTime.Now - rstartTime;
                if (span.TotalSeconds > 5)
                {
                    LogUtil.info(Name + "链条转动超过5秒，先停止链条转动");
                    WriteDrivetMotorRun(IO_VALUE.LOW);
                    //if (!DisableShunt2)
                    //{
                    //    IOMove(IO_Type.Shunt2_StopDown1_Front, IO_VALUE.LOW);
                    //}
                }
                if (runStatus.Equals(LineRunStatus.Wait))
                {
                    LogUtil.error(Name + "复位过程中发现 runStatus=Wait，中断启动");
                    return false;
                }      
                EquipReset(equip, isNeedAllReset);
            }
            if (runStatus.Equals(LineRunStatus.Wait))
            { return false; }
            IoCheckTimer.Enabled = true;
            mainTimer.Enabled = true;
            serverConTimer.Enabled = true;
            return true;
        }
        private void EquipReset(EquipBase equip, bool isNeedAllReset)
        {
            //调试状态不再重置
            if (!equip.IsDebug)
            {
                if (isNeedAllReset || TrayManager.ErrorDeviceId.Equals(equip.DeviceID) || (!NoAlarm()))
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                    equip.Reset();
                    Thread.Sleep(60);
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                }
            }
            else
            {
                LogUtil.info(Name + "收到复位信号，" + equip.Name + " 调试中，需要下降阻挡气缸");
                equip.OpenStopBlock();
            }
        }


        public override void StopRun()
        {
            IoCheckTimer.Enabled = false;
            mainTimer.Enabled = false;
            serverConTimer.Enabled = false ;
            AgvClient.SetCancelState(true);
            RFIDManager.Close();
            //停止运行时，把阻挡气缸上升
            //StopMove();
            foreach (EquipBase equip in this.AllEquipMap.Values)
            {
                if (!equip.IsDebug)
                {
                    equip.StopRun();
                }
                else
                {
                    equip.CloseStopBlock();
                }
            }
            MoveInfo.EndMove();

            WriteDrivetMotorRun(IO_VALUE.LOW);
            //IOMove(IO_Type.SW4_MotorRun, IO_VALUE.LOW);
            //IOMove(IO_Type.SW4_TopCylinder_Down, IO_VALUE.LOW);
            //IOMove(IO_Type.SW4_TopCylinder_Up, IO_VALUE.LOW);

            //SideWayStop();
            //ShuntStop();
            //Shunt2Stop();
            runStatus = LineRunStatus.Wait;

            ledProcessTimer.Enabled = false;
            CloseLed();
            WriteDrivetMotorRun(IO_VALUE.LOW);
            LineServer.StopServer();

            TimeSpan span = DateTime.Now - StartTime;
            LogUtil.info(Name + ",停止运行，总运行时间：" + span.ToString());
        }
        public DateTime LastAlarmTime = DateTime.Now;
        public override void Alarm(LineAlarmType alarmType)
        {
            if (alarmType.Equals(LineAlarmType.None).Equals(false))
            {
                LastAlarmTime = DateTime.Now;
            }
            if (this.alarmType.Equals(alarmType))
            {
                return;
            }
            // SaveAlarmInfo(alarmType, alarmDetial, alarmMsg, storeMoveType);
            this.alarmType = alarmType;
            if (alarmType == LineAlarmType.SuddenStop)
            {
                isInSuddenDown = true;
            }
            else if (alarmType.Equals(LineAlarmType.NoAirCheck))
            {
                isNoAirCheck = true;
            }

            if (alarmType.Equals(LineAlarmType.SuddenStop) || alarmType.Equals(LineAlarmType.NoAirCheck))
            {
                LogUtil.error(WarnMsg);
                MoveInfo.EndMove();
                WriteDrivetMotorRun(IO_VALUE.LOW);
                T3C1_Stop();

                foreach (EquipBase equip in this.AllEquipMap.Values)
                {
                    if (equip.runStatus > LineRunStatus.Wait)
                    {
                        equip.Alarm(alarmType);
                    }
                    else
                    {
                        equip.CloseStopBlock();
                    }
                }

            }
            IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
        }


        public void WriteDrivetMotorRun(IO_VALUE value)
        {
            IOMove(IO_Type.MotorRun_C1_123, value);
            IOMove(IO_Type.MotorRun_C1_4, value);
            IOMove(IO_Type.MotorRun_23458, value);
            IOMove(IO_Type.MotorRun_679, value);
        }


        #region 灯光处理 


        private void CloseLed()
        { 
            CheckAndMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
        }
        private void LedProcess(object sender, ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (runStatus <= LineRunStatus.Wait)
                {
                    CloseLed();
                    return;
                }
                bool isNeedAlarmLed = false;
                bool isInOut = false;
                bool yellowShanShuo = false;
                if (runStatus.Equals(LineRunStatus.HomeMoving) || runStatus.Equals(LineRunStatus.Reset))
                {
                    yellowShanShuo = true;
                }
                if (isInSuddenDown||isNoAirCheck||alarmType>LineAlarmType.AxisAlarm  )
                {
                    isNeedAlarmLed = true;
                }
                else if(alarmType.Equals(LineAlarmType.None).Equals(false)||TrayManager.TrayErrorMsg!="")
                { 
                    yellowShanShuo = true;
                }

                foreach (EquipBase moveEquip in AllEquipMap.Values)
                { 
                    if (moveEquip.isNoAirCheck || moveEquip.isInSuddenDown || moveEquip.alarmType > LineAlarmType.AxisAlarm)
                    {
                        isNeedAlarmLed = true;
                    }
                    else if (moveEquip.alarmType.Equals(LineAlarmType.None).Equals(false))
                    {
                        yellowShanShuo = true;
                    }
                    if (moveEquip.MoveInfo.MoveType.Equals(LineMoveType.InStore) || moveEquip.MoveInfo.MoveType.Equals(LineMoveType.OutStore))
                    {
                        isInOut = true;
                    }
                }


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

                //严重报警中 ，红灯闪烁
                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 (isNeedAlarmLed && LineManager.UseBuzzer)
                {
                    CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.HIGH);
                }
                else
                {
                    CheckAndMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
                }

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

        private void IoCheckTimerProcess(object sender, ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (this.runStatus >= LineRunStatus.HomeMoving)
                {

                    //取新的Io状态
                    IO_VALUE fuweiValue = IOValue(IO_Type.Reset_BTN);
                    IO_VALUE suddenBtn = IOValue(IO_Type.SuddenStop_BTN);
                    IO_VALUE airCheck = IOValue(IO_Type.Airpressure_Check);

                    IO_VALUE lastAir = DILastValueMap[IO_Type.Airpressure_Check];
                    IO_VALUE lastFuwei = DILastValueMap[IO_Type.Reset_BTN];

                    addLastDI(IO_Type.Airpressure_Check, airCheck);
                    addLastDI(IO_Type.SuddenStop_BTN, suddenBtn);
                    addLastDI(IO_Type.Reset_BTN, fuweiValue);

                    //气压检测按钮灭三秒以上才算关闭
                    IO_VALUE airValue = CheckAir(airCheck, lastAir);

                    //急停按钮和气压检测按钮需要一起使用  
                    if (suddenBtn.Equals(IO_VALUE.LOW))
                    {
                        if (isInSuddenDown.Equals(false))
                        {
                            LogUtil.error(Name + "收到急停信号，等待300后再次验证急停");

                            Thread.Sleep(300);
                            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                            {
                                SetWarnMsg("收到急停信号，报警急停", "急停报警");
                                Alarm(LineAlarmType.SuddenStop);
                            }
                        }
                    }
                    else if (fuweiValue.Equals(IO_VALUE.HIGH) && (!fuweiValue.Equals(lastFuwei)))
                    {
                        if (suddenBtn.Equals(IO_VALUE.LOW))
                        {
                            SetWarnMsg("收到复位信号但急停未开，不处理复位");
                        }
                        else if (airValue.Equals(IO_VALUE.LOW))
                        {
                            SetWarnMsg("收到复位信号但未检测到气压信号，不处理复位");
                        }
                        else
                        {
                            LogUtil.info(Name + "收到复位信号，开始复位！");
                            Reset();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "定时检测报警出错：", ex);
            }
            Thread.Sleep(1);
        }  
        protected override void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (runStatus.Equals(LineRunStatus.Wait))
                {
                    //取新的Io状态
                   IO_VALUE fuweiValue = IOValue(IO_Type.Reset_BTN);
                    IO_VALUE lastFuwei = DILastValueMap[IO_Type.Reset_BTN];
                    addLastDI(IO_Type.Reset_BTN, fuweiValue);
                    bool isAutoStart = ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun) == 1;

                    //收到复位信号后启动
                    if (isAutoStart && fuweiValue.Equals(IO_VALUE.HIGH) && lastFuwei.Equals(IO_VALUE.LOW))
                    {
                        //没有启动时收到启动按钮
                        LogUtil.info( Name + "没有启动时收到启动按钮，开始调用启动方法！");
                        bool isOk = StartRun();
                        if (!isOk)
                        {
                            LogUtil.error("启动失败，等待下次启动");
                            mainTimer.Enabled = true;
                        }
                    }
                    return;
                }
                //判断急停 
                else if (this.runStatus >= LineRunStatus.HomeMoving)
                {
                    foreach (EquipBase moveEquip in this.AllEquipMap.Values)
                    {
                        if (!moveEquip.IsDebug)
                        {
                            moveEquip.TimerProcess();
                        }
                    }

                    LineTimerPro();
                }

                TimeSpan span = DateTime.Now - time;
                if (span.TotalMilliseconds > 1000)
                {
                    LogUtil.error(Name + "主定时器处理耗时：" + FormUtil.GetSpanStr(span));
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "主定时器出错：",ex);
            }
            Thread.Sleep(1);
        }
        private bool busyPro = false ;
        private DateTime busyProTime = DateTime.Now;
        private int maxSeconds = 3;
        private void LineTimerPro()
        {
            TimeSpan span = DateTime.Now - busyProTime;
            if (busyPro && span.TotalSeconds < maxSeconds)
            {
                return;
            }
            try
            {
                busyPro = true;
                busyProTime = DateTime.Now;
                switch (runStatus)
                {
                    case LineRunStatus.Busy:
                        BusyMoveProcess();
                        break;
                    case LineRunStatus.HomeMoving:
                        ResetProcess();
                        break;
                    case LineRunStatus.Reset:
                        ResetProcess();
                        break;
                    case LineRunStatus.Runing:
                        if ((isInSuddenDown.Equals(false) && isNoAirCheck.Equals(false)))
                        {
                            //清理超时异常
                            IOTimeOutProcess();
                        }
                        break;
                    default: break;
                }

                T3C1_TimerProcess(); 
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "LineTimerPro 出错：", ex);
            }
            busyPro = false;
        } 
        private IO_VALUE CheckAir(IO_VALUE airCheck, IO_VALUE lastAir)
        {
            IO_VALUE airValue = IO_VALUE.HIGH;
            if (airCheck == IO_VALUE.LOW && (!isInSuddenDown))
            {
                //判断是否持续了3秒
                if (lastAir == IO_VALUE.LOW)
                {
                    if ((DateTime.Now - lastAirCloseTime).TotalSeconds > Config.AirCheckSeconds)
                    {
                        SetWarnMsg("持续"+Config.AirCheckSeconds+"秒未检测到气压信号");
                        //SendAlarmCode(0, LineAlarm.NoAirCheck);
                        airValue = IO_VALUE.LOW;
                        Alarm(LineAlarmType.NoAirCheck );
                    }
                }
                else
                {
                    lastAirCloseTime = DateTime.Now;
                    isNoAirCheck = false;
                }
            }
            else
            {
                isNoAirCheck = false;
            }
            return airValue;
        }

        #region 是否已经接收到过出库信息
         
        public bool IsReviceInPosId(MoveEquip moveEquip, string posId)
        {
            bool isReviceInfo = false;
            try
            {
                if (moveEquip.MoveInfo.MoveType.Equals(LineMoveType.InStore) && moveEquip.MoveInfo.MoveParam != null && moveEquip.MoveInfo.MoveParam.PosId.Equals(posId))
                {
                    LogInfo(" IsReviceInPosId 正在入库中：" + MoveInfo.MoveParam.ToStr());
                    isReviceInfo = true;
                }

                //TODO 如果已经收到同库位的入库任务，
                List<InOutParam> inStoreList = new List<InOutParam>(moveEquip.waitInStoreList);
                if (!isReviceInfo && inStoreList.Count > 0)
                {
                    foreach (InOutParam inout in inStoreList)
                    {
                        if (inout.PosId.Equals(posId) && (!inout.WareCode.Equals("")))
                        {
                            LogInfo(" IsReviceInPosId 已存在入库任务：" + inout.ToStr());
                            isReviceInfo = true;
                            break;
                        }
                    }
                }
            }catch(Exception ex)
            {
                LogUtil.error("IsReviceInPosId【"+ posId + "】出错：" + ex.ToString());
            }
            return isReviceInfo;
        }
        #endregion 

        internal override void StopMove(string stopDes = "")
        {

            foreach (EquipBase equip in this.AllEquipMap.Values)
            {
                if (!equip.IsDebug)
                {
                    equip.StopMove();
                }
                else
                {
                    equip.CloseStopBlock();
                }
            }
            MoveInfo.EndMove(); 
            WriteDrivetMotorRun(IO_VALUE.LOW);
            T3C1_Stop(); 
        }

        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (!MoveInfo.IsInWait)
            {
                bool isOk = true;
                string msg = "";
                //判断是否所有的已经返回完成
                TimeSpan span = DateTime.Now - MoveInfo.LastSetpTime;
                foreach (EquipBase equip in this.AllEquipMap.Values)
                {
                    if (equip.IsDebug)
                    {

                        if (!equip.OpenStopBlockOk(span))
                        {
                            msg = equip.Name + "下降阻挡气缸";
                            TimeSpan rwSpan = DateTime.Now - preRWTime;
                            if (span.TotalSeconds > LineManager.Config.IOSingle_TimerOut * 2)
                            {
                                SetWarnMsg(equip.Name + "下降阻挡气缸超时，已等待" + FormUtil.GetSpanStr(span));
                                LogUtil.error(equip.Name + "下降阻挡气缸超时，已等待" + FormUtil.GetSpanStr(span), 902);
                            }
                            else if (rwSpan.TotalSeconds > 5 && span.TotalSeconds > 6 && span.TotalSeconds < LineManager.Config.IOSingle_TimerOut * 2)
                            {
                                preRWTime = DateTime.Now;
                                LogUtil.error(Name + "复位中：等待" + msg + "已【" + FormUtil.GetSpanStr(span) + "】重新调用OpenStopCylinder方法");
                                equip.OpenStopBlock();
                            }
                            isOk = false;
                            break;
                        }
                        continue;
                    }
                    if (equip.runStatus.Equals(LineRunStatus.HomeMoving) || equip.runStatus.Equals(LineRunStatus.Reset) || equip.runStatus.Equals(LineRunStatus.Wait))
                    {
                        if (equip.NoAlarm())
                        {
                            if (equip.baseConfig.DType.Equals(DeviceType.FeedingEquip) && equip.MoveInfo.MoveStep >= LineMoveStep.FR_11_BatchAxisHome)
                            {
                                continue;
                            }
                            msg = equip.Name + "复位结束";
                            isOk = false;
                            break;
                        }
                        else
                        {
                            //SetWarnMsg(moveEquip.Name + "在复位过程中报警，需要重新复位");
                            LogUtil.error(Name + " " + equip.Name + "在复位过程中报警，需要重新复位，调用 moveEquip.Reset();");
                            equip.Reset();
                            //如果小于80秒，继续等待
                            if (span.TotalSeconds < 80)
                            {
                                isOk = false;
                                break;
                            }
                        }
                    }
                }

                if (isOk)
                {
                    if (WarnMsg.Contains("下降阻挡气缸超时"))
                    {
                        SetWarnMsg("");
                    }
                    //    PreIsHasProcess = false;
                    //打开流水线
                    WriteDrivetMotorRun(IO_VALUE.HIGH);
                    //所有原点重置完成
                    runStatus = LineRunStatus.Runing; 
                    MoveInfo.EndMove();
                    mainTimer.Interval = 300;
                    maxSeconds = 3;
                    AgvClient.SetCancelState(AgvClient.CurrCancelState);
                    LogUtil.info(Name + "所有移栽模块复位完成，打开流水线，开始运转，定时器改为300，耗时 [" + FormUtil.GetSpanStr(span) + "]");
                }
                else if (span.TotalSeconds > 120)
                {
                    string warnmsg = Name + "[" + MoveInfo.MoveStep + "][" + msg + "]已等待[" + FormUtil.GetSpanStr(span ) + "]秒";
                    //LogUtil.error(WarnMsg, 903);
                    Alarm(LineAlarmType.IoSingleTimeOut);
                    MoveTimeoutAlarm(MoveInfo, msg);
                }
            }
        }

        public string GetMoveStr()
        {
            string msg = "";
            // int tLength = 20;
            //msg += "横移41托盘：" + Sw41TrayNum + "\n";
            msg += "T3C1托盘：" + T3C1_TrayNum + "\n";
            msg += "状态： " + runStatus + "\t "; 
            msg += "alarm：  " + alarmType + "\n";
            msg += "Move：" + MoveInfo.MoveType + "  " + MoveInfo.SLog + "\n";
            msg += "T3C1：" + T3C1_MoveInfo.MoveType + "  " + T3C1_MoveInfo.MoveStep + "\n";
        
            return msg;
        }

        private bool conIsPro = false;
        private DateTime conLastTime = DateTime.Now;
        private void ServerConTimer_Elapsed(object sender, ElapsedEventArgs e)
        {

            TimeSpan span = DateTime.Now - conLastTime;
            if (conIsPro && span.TotalSeconds < 30)
            {
                return;
            }

            //14.异常看板

            //   > 地址: 
            //>>/ rest / api / qisda / device / updateDeviceAlarmMsg
            //    >
            //    > 参数:
            //>> deviceAlarmList : 异常列表Json字符串  `[{"name":"移栽5", "msgKey":"line.move5.timeOut", "msgValue":"运动超时"},{"name":"移栽4", "msgKey":"line.move4.timeOut", "msgValue":"误差过大"}]`
            //>>>name :  异常位置名称
            //>>>msgKey :  异常信息唯一标识
            //>>>msgValue :  异常信息
            //>
            //>   返回: 
            //>>` {"code":0,"msg":"ok","data":""}`
            //>>
            //>> - code: 0为正常,其他为异常, 
            //          >> - msg:消息, 
            //          >> - data:
            try
            {
                conIsPro = true;
                conLastTime = DateTime.Now;
                List<AlarmMsg> alarmList = new List<AlarmMsg>();
                foreach (EquipBase equip in AllEquipMap.Values)
                {
                    if (equip.alarmType.Equals(LineAlarmType.None) || equip.WarnMsg.Contains("等待空托盘到达超时"))
                    {
                        continue;
                    }
                    else if (equip.alarmType.Equals(LineAlarmType.None) || equip.WarnMsg.Contains("获取库位号超时"))
                    {
                        continue;
                    }
                    else
                    {
                        alarmList.Add(new AlarmMsg(equip.Name, "line." + equip.Name + "_" + equip.alarmType, equip.WarnMsg));
                    }
                }
                SServerManager.updateDeviceAlarmMsg(alarmList);
            }
            catch (Exception ex)
            {
                LogUtil.error("ServerConTimer_Elapsed 出错：" + ex.ToString());
            }
            finally
            {
                conIsPro = false;
            }
        }
    }
}