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

namespace OnlineStore.DeviceLibrary
{
    public abstract class EquipBase : DeviceBase
    {
        public bool IsDebug = false;
        /// <summary>
        /// 暂停运动
        /// </summary>
        public bool MoveStop = false;
        protected int TimerMaxSeconds = 3;
        public bool AxisAlarmFlag = false;//轴报警异常标识

        protected void SetAllTimer(bool open)
        {
            IoCheckTimer.Enabled = open;
            mainTimer.Enabled = open;
            ledProcessTimer.Enabled = open;
        }


        protected abstract void BaseTimerProcess();
        object locobj = new object();
        protected override void mainTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (Monitor.TryEnter(locobj))
            {
                try
                {
                    TimerProcess();
                }
                finally { Monitor.Exit(locobj); }
            }

        }

        public DateTime LastAlarmTime = DateTime.Now;
        public override void Alarm(AlarmType alarmType)
        {
            if (alarmType.Equals(AlarmType.None).Equals(false))
            {
                LastAlarmTime = DateTime.Now;
            }
            if (alarmType.Equals(AlarmType.None).Equals(false))
            {
                LastAlarmTime = DateTime.Now;
            }
            if (this.alarmType.Equals(alarmType))
            {
                return;
            }
            if (alarmType.Equals(AlarmType.SuddenStop))
            {
                isInSuddenDown = true;
            }
            else if (alarmType.Equals(AlarmType.NoAirpressure_Check))
            {
                isNoAirpressure_Check = true;
            }
            this.alarmType = alarmType;
            if (alarmType.Equals(AlarmType.SuddenStop) || alarmType.Equals(AlarmType.NoAirpressure_Check) ||
                alarmType.Equals(AlarmType.AxisAlarm) || alarmType.Equals(AlarmType.AxisMoveError))
            {
                AxisAlarmFlag = true;
                StopMove();
            }
        }

        object worklock = new object();

        protected override void BusyMoveProcess()
        {
            if (MoveStop)
            {
                return;
            }


            if (MoveInfo.MoveType.Equals(MoveType.RHome))
            {
                ResetProcess();
            }
            else if (MoveInfo.MoveType.Equals(MoveType.Reset))
            {
                ResetProcess();
            }
            if (MoveInfo.MoveType.Equals(MoveType.InStore))
            {
                InstoreProcess();
            }
            else if (MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                OutstoreProcess();
            }

        }

        private DateTime lastProTimer = DateTime.Now;
        public void TimerProcess()
        {
            if (runStatus <= RunStatus.Wait)
            {
                return;
            }
            TimeSpan span = DateTime.Now - lastProTimer;
            if (isInPro && span.TotalSeconds < TimerMaxSeconds)
            {
                return;
            }
            isInPro = true;
            lastProTimer = DateTime.Now;
            try
            {
                OnTimerProcess();
                if (IsDebug && runStatus <= RunStatus.Wait)
                {
                    isInPro = false;
                    return;
                }
                BaseTimerProcess();

                if (TimerMaxSeconds > 3 && runStatus >= RunStatus.Runing)
                {
                    TimerMaxSeconds = 3;
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "TimerProcess出错：", ex);
            }
            finally
            {
                isInPro = false;
            }
        }

        internal void AutoStartProcess()
        {
            DateTime time = DateTime.Now;
            if (runStatus.Equals(RunStatus.Wait))
            {
                //取新的Io状态
                IO_VALUE fuweiValue = IOValue(IO_Type.Reset_BTN);
                if (DILastValueMap.ContainsKey(IO_Type.Reset_BTN))
                {
                    IO_VALUE lastFuwei = DILastValueMap[IO_Type.Reset_BTN];
                    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("启动失败，等待下次启动");
                        }
                    }
                }
                addLastDI(IO_Type.Reset_BTN, fuweiValue);
                return;
            }
        }
        protected virtual void OnTimerProcess()
        {

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

                    if (runStatus < RunStatus.Runing || isInSuddenDown || isNoAirpressure_Check)
                    {
                        return;
                    }
                    //若BOX和出料都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    if (MoveInfo.MoveType.Equals(MoveType.None))
                    {
                        LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                        alarmType = AlarmType.None;
                        SetWarnMsg("");
                    }
                }
                else if (runStatus.Equals(RunStatus.Runing) && alarmType.Equals(AlarmType.None))
                {
                    //设备处于空闲时且无异常，清空异常缓存
                    if (WarnMsg != "")
                        SetWarnMsg("");
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("IOTimeOutProcess出错：", ex);
            }
        }
        public bool CanStartRun()
        {
            string canResult = StoreManager.XLRStore.CanStart();
            if (String.IsNullOrEmpty(canResult).Equals(false))
            {
                SetWarnMsg(Name + canResult);
                return false;
            }
            if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg(Name + "启动失败：急停未开");
                return false;

            }
            else if (this.baseConfig.DType.Equals(DeviceType.InputEquip) && IOValue(IO_Type.Airpressure_Check).Equals(IO_VALUE.LOW))
            {
                SetWarnMsg(Name + "启动失败：没有气压信号");
                return false;
            }
            return true;
        }

        public void ChangeDebug(bool isDebug)
        {
        }
        #region  伺服运动

        public bool RunAxis(bool isCheck, AxisBean axis)
        {
            string msg = "";
            bool result = axis.Open(isCheck, out msg);
            if (result && String.IsNullOrEmpty(msg))
            {
                return true;
            }
            return false;
        }

        public void CloseAxis(AxisBean axis)
        {
            axis.ServoOff();
        }


        protected bool AxisIsAlarm(AxisBean axisInfo, bool NeedAlarm = true)
        {
            int alarmIo = AxisManager.instance.GetAlarmStatus(axisInfo.Config.DeviceName, axisInfo.Config.GetAxisValue());

            if (alarmIo.Equals(1))
            {
                Thread.Sleep(100);
                alarmIo = AxisManager.instance.GetAlarmStatus(axisInfo.Config.DeviceName, axisInfo.Config.GetAxisValue());
                if (alarmIo.Equals(1))
                {
                    WarnMsg = Name + " " + axisInfo.AxisName + "报警";

                    LogUtil.error(WarnMsg);

                    if (NeedAlarm)
                    {
                        Alarm(AlarmType.AxisAlarm);
                    }

                    return true;
                }
            }
            return false;
        }
        #endregion


        #region CheckWait处理

        protected DateTime preRWTime = DateTime.Now;
        short curTor, preTor;
        internal void CheckWait(DeviceMoveInfo moveInfo)
        {
            try
            {
                List<WaitResultInfo> list = moveInfo.WaitList;
                int cutWLcount = list.Count;
                if (list.Count <= 0)
                {
                    moveInfo.EndStepWait();
                    return;
                }
                //当等待超过一分钟时，需要打印提示 
                TimeSpan span = DateTime.Now - moveInfo.LastSetpTime;
                string NotOkMsg = "";
                bool isOk = true;
                if (moveInfo.OneWaitCanEndStep)
                {
                    isOk = false;
                }
                foreach (WaitResultInfo wait in list)
                {
                    if (wait.IsEnd)
                    {
                        continue;
                    }
                    NotOkMsg = " [" + wait.ToStr() + "] ";
                    if (wait.WaitType.Equals(WaitEnum.W001_AxisMove))
                    {

                        string msg = "";
                        if (wait.IsHomeMove)
                        {
                            wait.IsEnd = AxisBean.HomeMoveIsEnd(moveInfo, wait.AxisInfo, out msg);
                        }
                        else
                        {
                            wait.IsEnd = AxisBean.ACAxisMoveIsEnd(moveInfo, wait.AxisInfo, wait.TargetPosition, wait.TargetSpeed, out msg);
                        }
                        if (!msg.Equals(""))
                        {
                            isOk = false;
                            WarnMsg = Name + msg;

                            Alarm(AlarmType.AxisMoveError);
                            LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                            break;

                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W002_IOValue))
                    {
                        NotOkMsg = " [" + IOManager.GetIO(wait.IoType, DeviceID).DisplayStr + "=" + wait.IoValue + "]";
                        wait.IsEnd = IOValue(wait.IoType).Equals(wait.IoValue);

                        if (!wait.IsEnd)
                        {
                            TimeSpan rwSpan = DateTime.Now - preRWTime;
                            int timeOutSeconds = StoreManager.Config.IOSingle_TimerOut;
                            if (MoveInfo.IsStep(StepEnum.II42_WaitNoReel) || MoveInfo.IsStep(StepEnum.II62_WaitNoReel))
                            {
                                timeOutSeconds = 40;
                            }
                            //一分钟还未检测到
                            if (span.TotalSeconds > timeOutSeconds && alarmType <= AlarmType.IoSingleTimeOut)
                            {
                                ConfigIO io = baseConfig.getWaitIO(wait.IoType);
                                WarnMsg = moveInfo.Name + "[" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "] 等待" + NotOkMsg + " 超时 " + Math.Round(span.TotalSeconds, 1) + "秒";

                                LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                                if (NoAlarm())
                                {
                                    Alarm(AlarmType.IoSingleTimeOut);
                                }
                            }
                            else if (rwSpan.TotalSeconds > 5 && span.TotalSeconds > 6 && span.TotalSeconds < StoreManager.Config.IOSingle_TimerOut * 2)
                            {
                                preRWTime = DateTime.Now;
                                string msg = moveInfo.Name + " [" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "] " + NotOkMsg + "已等待 " + Math.Round(span.TotalSeconds, 1) + "秒，重写DO：";
                                bool isLog = false;
                                foreach (WaitResultInfo ww in list)
                                {
                                    if (ww != null && ww.WaitType.Equals(2) && baseConfig.DOList.ContainsKey(ww.IoType))
                                    {
                                        if (IOManager.DOValue(ww.IoType, baseConfig.Id).Equals(ww.IoValue).Equals(false))
                                        {
                                            isLog = true;
                                            IOMove(ww.IoType, ww.IoValue);
                                            msg += ww.ToStr() + "，";
                                        }
                                    }
                                }
                                if (isLog)
                                {
                                    LogUtil.error(msg);
                                }
                            }
                        }
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W003_Time))
                    {
                        wait.IsEnd = (span.TotalMilliseconds >= wait.TimeMSeconds);
                    }
                    else if (wait.WaitType.Equals(WaitEnum.W006_AxisOrg))
                    {
                        wait.IsEnd = AxisManager.instance.GetHomeSingle(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(1);
                        //LogInfo($"{wait.AxisInfo.DeviceName}-{wait.AxisInfo.GetAxisValue()}-{AxisManager.instance.GetHomeSingle(wait.AxisInfo.DeviceName, wait.AxisInfo.GetAxisValue()).Equals(1)}");
                    }
                    else
                    {
                        wait.IsEnd = CheckWaitResult(moveInfo, wait);
                    }

                    if (wait.IsEnd)
                    {
                        if (moveInfo.OneWaitCanEndStep)
                        {
                            isOk = true;
                            break;
                        }
                    }
                    else
                    {
                        if (!moveInfo.OneWaitCanEndStep)
                        {
                            isOk = false;
                            break;
                        }
                    }
                }
                if (isOk)
                {
                    if (moveInfo.WaitList.Count > cutWLcount && !moveInfo.OneWaitCanEndStep)
                    {
                        LogUtil.info(moveInfo.Name + " moveInfo.WaitList.Count:" + moveInfo.WaitList.Count.ToString() + ",cutWLcount:" + cutWLcount.ToString()); ;
                    }
                    moveInfo.EndStepWait();

                }
                else if (span.TotalSeconds > moveInfo.TimeOutSeconds)
                {
                    WarnMsg = moveInfo.Name + "[" + moveInfo.MoveType + "][" + moveInfo.MoveStep + "]等待" + NotOkMsg
                      + "超时[" + Math.Round(span.TotalSeconds, 1) + "]秒";
                    //int second = 10;

                    //second = (int)(span.TotalSeconds/moveInfo.TimeOutSeconds  ) * 10;
                    //if (second > 120)
                    //{
                    //    second = 120;
                    //}
                    //else if (second < 10)
                    //{
                    //    second = 10;
                    //}
                    LogUtil.error(WarnMsg, moveInfo.ErrorLogType, moveInfo.logSeconds());
                    Alarm(AlarmType.IoSingleTimeOut);
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(moveInfo.Name + " [" + moveInfo.MoveStep + "] CheckWait 出错：", ex);
            }
        }

        protected virtual bool CheckWaitResult(DeviceMoveInfo moveInfo, WaitResultInfo wait)
        {
            return false;
        }

        #endregion

        #region 日志打印 
        internal int WorkLogLevel = 1;
        protected void InoutLog(string msg, int level = 1)
        {
            if (level < 0)
            {
                level = WorkLogLevel;
            }
            if (level <= WorkLogLevel)
            {
                level = WorkLogLevel;
            }
            string code = "";
            if (MoveInfo.MoveParam != null && MoveInfo.MoveParam.PosInfo != null && MoveInfo.MoveParam.PosInfo.barcode != null)
            {
                if (!MoveInfo.MoveParam.PosInfo.barcode.Equals(""))
                {
                    code = MoveInfo.MoveParam.PosInfo.barcode;
                }
            }
            if (level.Equals(1))
            {
                LogUtil.info(MoveInfo.Name + "[" + code + "]" + "[" + MoveInfo.MoveStep + "] " + msg);
            }
            else
            {
                LogUtil.debug(MoveInfo.Name + "[" + code + "]" + "[" + MoveInfo.MoveStep + "] " + msg);
            }
        }



        public virtual string GetMoveStr()
        {
            string msg = "";
            int tLength = 15;
            msg += "runS：  " + runStatus + "\n";
            msg += "alarm：  " + alarmType + " " + LastAlarmTime.ToLongTimeString() + "\n";
            msg += "MoveT：" + MoveInfo.MoveType + "\n";
            msg += "MoveS ：" + MoveInfo.MoveStep + "\n";
            return msg;
        }

        #endregion



        #region 灯光处理 


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

        protected AlarmType alarmRedLedType = AlarmType.AxisAlarm;
        protected void LedProcess(object sender, ElapsedEventArgs e)
        {
            try
            {
                DateTime time = DateTime.Now;
                if (runStatus <= RunStatus.Wait)
                {
                    CloseLed();
                    return;
                }
                bool isNeedAlarmLed = false;
                bool isInOut = false;
                bool yellowMove = false;
                if (runStatus.Equals(RunStatus.HomeMoving) || runStatus.Equals(RunStatus.Reset))
                {
                    yellowMove = true;
                }
                if (isInSuddenDown || isNoAirpressure_Check || alarmType >= alarmRedLedType|| MoveStop)
                {
                    isNeedAlarmLed = true;
                }
                else if (alarmType.Equals(AlarmType.None).Equals(false))
                {
                    yellowMove = true;
                }




                //黄灯
                if (yellowMove)
                {
                    //开机执行中时黄灯闪烁
                    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 && StoreManager.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
        #region 急停，气压检测
        protected IO_VALUE CheckAir(IO_VALUE Airpressure_Check, IO_VALUE lastAir)
        {
            IO_VALUE airValue = IO_VALUE.HIGH;
            if (Airpressure_Check == IO_VALUE.LOW && (!isInSuddenDown))
            {
                //判断是否持续了3秒
                if (lastAir == IO_VALUE.LOW)
                {
                    if ((DateTime.Now - lastAirCloseTime).TotalSeconds > StoreManager.Config.Airpressure_CheckSeconds)
                    {
                        SetWarnMsg("持续" + StoreManager.Config.Airpressure_CheckSeconds + "秒未检测到气压信号");
                        //SendAlarmCode(0, LineAlarm.NoAirpressure_Check);
                        airValue = IO_VALUE.LOW;
                        Alarm(AlarmType.NoAirpressure_Check);
                    }
                }
                else
                {
                    lastAirCloseTime = DateTime.Now;
                    isNoAirpressure_Check = false;
                }
            }
            else
            {
                isNoAirpressure_Check = false;
            }
            return airValue;
        }

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

                    //取新的Io状态
                    IO_VALUE fuweiValue = IOValue(IO_Type.Reset_BTN);
                    IO_VALUE suddenBtn = IOValue(IO_Type.SuddenStop_BTN);
                    addLastDI(IO_Type.SuddenStop_BTN, suddenBtn);
                    IO_VALUE airValue = IO_VALUE.HIGH;

                    if (DILastValueMap.ContainsKey(IO_Type.Airpressure_Check) && baseConfig.DIList.ContainsKey(IO_Type.Airpressure_Check))
                    {
                        IO_VALUE Airpressure_Check = IOValue(IO_Type.Airpressure_Check);
                        IO_VALUE lastAir = DILastValueMap[IO_Type.Airpressure_Check];
                        addLastDI(IO_Type.Airpressure_Check, Airpressure_Check);
                        //气压检测按钮灭三秒以上才算关闭
                        airValue = CheckAir(Airpressure_Check, lastAir);
                    }

                    if (DILastValueMap.ContainsKey(IO_Type.Reset_BTN))
                    {
                        IO_VALUE lastFuwei = DILastValueMap[IO_Type.Reset_BTN];
                        addLastDI(IO_Type.Reset_BTN, fuweiValue);

                        //急停按钮和气压检测按钮需要一起使用  
                        if (suddenBtn.Equals(IO_VALUE.LOW))
                        {
                            if (isInSuddenDown.Equals(false))
                            {
                                LogUtil.error(Name + "收到急停信号，等待200后再次验证急停");
                                //Task.Factory.StartNew(delegate
                                //{
                                Thread.Sleep(200);
                                if (IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                                {
                                    SetWarnMsg("收到急停信号，报警急停");
                                    Alarm(AlarmType.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();
                            }
                        }
                    }
                    else
                    {
                        addLastDI(IO_Type.SuddenStop_BTN, suddenBtn);
                        addLastDI(IO_Type.Reset_BTN, fuweiValue);
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "定时检测报警出错：", ex);
            }
            Thread.Sleep(1);
        }
        #endregion
        private bool IsDoValue(string ioType, IO_VALUE value)
        {
            if (IOManager.DOValue(ioType, baseConfig.Id).Equals(value))
            {
                return true;
            }
            return false;
        }
        protected void ClearSpecifiedAlarm(string msg)
        {
            if (WarnMsg.Contains(msg))
            {
                SetWarnMsg("");
            }
        }
        protected void ClearTimeoutAlarm(string msg)
        {
            if (isInSuddenDown || isNoAirpressure_Check)
            {
                return;
            }
            if (WarnMsg.Contains(msg) && alarmType.Equals(AlarmType.IoSingleTimeOut))
            {
                LogUtil.info(Name + "清理信号超时报警【" + WarnMsg + "】 ");
                alarmType = AlarmType.None;
                SetWarnMsg("");
            }
        }
        public Color GetShowColor()
        {
            if (runStatus.Equals(RunStatus.Wait))
            {
                if (IsDebug)
                {
                    return Color.LightGray;
                }
                else
                {
                    return Color.White;
                }
            }
            else if (alarmType.Equals(AlarmType.IoSingleTimeOut))
            {
                return Color.LightCoral;
            }
            else if (alarmType.Equals(AlarmType.None).Equals(false))
            {
                return Color.Red;
            }
            else if (runStatus.Equals(RunStatus.HomeMoving) || runStatus.Equals(RunStatus.Reset))
            {
                return Color.Orange;
            }
            else if (runStatus.Equals(RunStatus.Busy))
            {
                return Color.LimeGreen;
            }
            else if (runStatus.Equals(RunStatus.Runing))
            {
                return Color.LightBlue;
            }
            return Color.White;
        }
        protected void MoveTimeOut(DeviceMoveInfo move, string msg)
        {
            WarnMsg = move.Name + "[" + move.MoveStep + "] " + msg + " [" + FormUtil.GetSpanStr(move.StepSpan()) + "]";
            int logId = DeviceID * 10000 + (int)move.MoveStep;
            LogUtil.error(WarnMsg, logId);
            Alarm(AlarmType.IoSingleTimeOut);
        }
    }
}