using log4net;
using OnlineStore.Common;
using OnlineStore.DeviceLibrary.ESS;
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, EquipBase> AllEquipMap { get; set; }

        public Line_Config Config { get; set; }
        ESSService eSSService = new ESSService();
        #region  初始化
        public List<string> cioList = new List<string>();
        private bool canStart = false;

        public LineBean(Line_Config lineConfig, Dictionary<int, AGVEquip_Config> agvConfigMap, Dictionary<int, StationEquip_Config> stationMap,
            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;
            MoveInfo = new LineMoveInfo(DeviceID, "[流水线-Move] ");
            Name = (" 流水线_" + Config.CID + " ").ToUpper();


            AllEquipMap = new Dictionary<int, EquipBase>();
            List<string> ioList = new List<string>();
            ioList = new List<string>(DeviceConfig.ProIOIpMap.Values);
            AddDeviceName(ioList, Config.IOIPList);
            foreach (AGVEquip_Config config in agvConfigMap.Values)
            {
                AGVEquipBase equip = AGVEquipBase.GetAGVEquip(lineConfig.CID, config);
                AddDeviceName(ioList, config.IOIPList);
                AllEquipMap.Add(config.Id, equip);
            }
            foreach (StationEquip_Config config in stationMap.Values)
            {
                StationEquip equip = new StationEquip(lineConfig.CID, config);

                AddDeviceName(ioList, config.IOIPList);
                AllEquipMap.Add(config.Id, equip);
            }
            foreach (HYEquip_Config config in hyConfigMap.Values)
            {
                HYEquipBase equip = HYEquipBase.GetHY(lineConfig.CID, config);
                AddDeviceName(ioList, config.IOIPList);
                AllEquipMap.Add(config.Id, equip);
            }
            IOManager.Init();

            //初始化摄像机配置  

            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;
                canStart = true;

            });
            //开启web服务
            string url = ConfigAppSettings.GetValue(Setting_Init.Webservice);
            eSSService.Open(url);
        }


        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 = 1000;
            serverConTimer.AutoReset = true;
            serverConTimer.Elapsed += ServerConTimer_Elapsed;
            serverConTimer.Enabled = false;
        }


        #endregion

        public string CanStart()
        {
            if (!canStart)
            {
                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);
                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; }
                // WriteDrivetMotorRun(IO_VALUE.LOW);
                IoCheckTimer.Enabled = true;
                mainTimer.Enabled = true;
                serverConTimer.Enabled = true;
                return true;
            }
        }
        private void EquipStartRun(EquipBase moveEquip)
        {
            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 = 300;
            maxSeconds = 10;
            //  TrayManager.SidesWayStateMap = new System.Collections.Concurrent.ConcurrentDictionary<int, int>() ;
            alarmType = LineAlarmType.None;
            mainTimer.Enabled = false;
            IoCheckTimer.Enabled = false;
            isInSuddenDown = false;
            isNoAirCheck = false;
            ContainerManager.TrayErrorMsg = "";
            SetWarnMsg("");
            MoveInfo.NewMove(LineMoveType.Reset);
            MoveInfo.NextMoveStep(LineMoveStep.Wait);
            ContainerManager.ErrorContainerId = "";

        }

        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 || (!NoAlarm()))
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 需要复位");
                    equip.Reset();
                    Thread.Sleep(60);
                }
                else
                {
                    LogUtil.info(Name + "收到复位信号，" + equip.Name + " 正常无报警，不需要复位");
                }
            }
            else
            {
                LogUtil.info(Name + "收到复位信号，" + equip.Name + " 调试中");
            }
        }


        public override void StopRun()
        {
            IoCheckTimer.Enabled = false;
            mainTimer.Enabled = false;
            serverConTimer.Enabled = false;
            //停止运行时，把阻挡气缸上升
            //StopMove();
            foreach (EquipBase equip in this.AllEquipMap.Values)
            {
                if (!equip.IsDebug)
                {
                    equip.StopRun();
                }
            }
            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);

            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);
                foreach (EquipBase equip in this.AllEquipMap.Values)
                {
                    if (equip.runStatus > LineRunStatus.Wait)
                    {
                        equip.Alarm(alarmType);
                    }
                }

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


        public void WriteDrivetMotorRun(IO_VALUE value)
        {
            IOMove(IO_Type.MotorRun_A, value);
            IOMove(IO_Type.MotorRun_B, 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) || ContainerManager.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);
        }
        object timerLockobj = new object();
        protected override void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (Monitor.TryEnter(timerLockobj))
            {
                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 > 5000)
                    {
                        LogUtil.error(Name + "主定时器处理耗时：" + FormUtil.GetSpanStr(span));
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error(Name + "主定时器出错：", ex);
                }
                finally
                {
                    Monitor.Exit(timerLockobj);
                }
            }

            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;
                }
            }
            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;
        }

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

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

        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.runStatus.Equals(LineRunStatus.HomeMoving) || equip.runStatus.Equals(LineRunStatus.Reset) || equip.runStatus.Equals(LineRunStatus.Wait))
                    {
                        if (equip.NoAlarm())
                        {
                            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;
                    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 += "状态： " + runStatus + "\t ";
            msg += "alarm：  " + alarmType + "\n";
            msg += "Move：" + MoveInfo.MoveType + "  " + MoveInfo.SLog + "\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;
            }
            try
            {
                conIsPro = true;
                conLastTime = DateTime.Now;
                #region 异常上报
                //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);
                #endregion

                Dictionary<string, string> map = new Dictionary<string, string>();
                //工位状态定时上报
                foreach (EquipBase equip in AllEquipMap.Values)
                {
                    if (equip is StationEquip)
                    {
                        RFIDData data = equip.UpdateStationCode();
                        if (data.IsValidated())
                        {
                            map.Add($"s{equip.DeviceID}", data.StrData);
                            //自动上传出库料箱被其他工位拿走的状态
                            if (ContainerManager.GetOutStoreBox(data.ToContainerId()))
                            {
                                ContainerManager.UpdateTaskStatus(data.ToContainerId(), TaskStatus.FINISHED, $"s{equip.DeviceID}");
                                LogUtil.info($"出库容器被拿上工位s{equip.DeviceID},自动完成：{data.ToContainerId()}");
                            }
                        }
                        else
                        {
                            map.Add($"s{equip.DeviceID}", "");
                        }
                    }
                }
                List<string> inTask = SServerManager.UploadStationInfo(Name, map);
                if (inTask != null && inTask.Count > 0)
                {
                    foreach (var item in inTask)
                    {
                        if (map.ContainsKey(item))
                        {
                            ContainerManager.AddOrUpdateContainerInfo(item, map[item]);
                        }
                    }
                }
                List<OutTaskData> outTask = SServerManager.GetOutTask(Name);
                if (outTask != null && outTask.Count > 0)
                {
                    RobotStates states = SServerManager.GetRobotState();
                    if (LineManager.RobotIsIdle(states) || LineManager.CheckRobotTrayIsInstore(states))
                    {
                        foreach (var item in outTask)
                        {
                            ContainerManager.AddOrUpdateContainerInfo(item.barcode);
                        }
                    }

                }
                //发送呼叫任务
                ContainerManager.HandlePendingTask();
                //上报容器状态
                ContainerManager.UpdateContainerStatus();
            }
            catch (Exception ex)
            {
                LogUtil.error("ServerConTimer_Elapsed 出错：" + ex.ToString());
            }
            finally
            {
                conIsPro = false;
            }
        }

    }
}