Kepler-Release/Venus/Venus_MainPages/ViewModels/OperationOverViewModel.cs

using Aitex.Core.RT.Log;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.OperationCenter;
using OpenSEMI.ClientBase;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_MainPages.Views;
using Venus_Themes.CustomControls;
using static Venus_Core.NiceRobotAction;
//using static Venus_Themes.UserControls.EFEM;

namespace Venus_MainPages.ViewModels
{
    public class OperationOverViewModel : BindableBase
    {
        #region 私有字段
        private bool m_TabIsChecked = true;
        private ModuleInfo m_LP1ModuleInfo;
        private ModuleInfo m_LP2ModuleInfo;
        private ModuleInfo m_LLAModuleInfo;
        private ModuleInfo m_LLBModuleInfo;

        private ModuleInfo m_LP3ModuleInfo;
        private ModuleInfo m_EFEMModuleInfo;
        private ModuleInfo m_TMModuleInfo;
        //private WaferRobotTAction m_Robot1TAction;
        //private WaferRobotXAction m_Robot1XAction;
        //private WaferRobotTAction m_Robot2TAction;
        //private WaferRobotXAction m_Robot2XAction;
        //private WaferRobotTAction m_Robot3TAction;
        //private WaferRobotXAction m_Robot3XAction;
        //private WaferRobotTAction m_Robot4TAction;
        //private WaferRobotXAction m_Robot4XAction;


        private NiceGuangChuanWaferRobotTAction m_BladeNiceGuangChuanWaferRobotTAction;
        //private NiceGuangChuanWaferRobotTAction m_Blade2NiceGuangChuanWaferRobotTAction;

        private NiceGuangChuanWaferRobotXAction m_Blade1NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract1;
        private NiceGuangChuanWaferRobotXAction m_Blade2NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract2;

        private NiceXinSongWaferRobotTAction m_BladeNiceXinSongWaferRobotTAction;
        //private NiceXinSongWaferRobotTAction m_Blade2NiceXinSongWaferRobotTAction;

        private NiceXinSongWaferRobotXAction m_Blade1NiceXinSongWaferRobotXAction;
        private NiceXinSongWaferRobotXAction m_Blade2NiceXinSongWaferRobotXAction;



        private RobotMoveInfo m_robotMoveInfo;
        private WaferInfo m_PMAWafer;
        private WaferInfo m_PMBWafer;
        private WaferInfo m_PMCWafer;
        private WaferInfo m_PMDWafer;
        private WaferInfo m_LLAWafer;
        private WaferInfo m_LLBWafer;
        private WaferInfo m_TMBladeAWafer;
        private WaferInfo m_TMBladeBWafer;
        private List<string> m_RtDataKeys = new List<string>();
        private Dictionary<string, object> m_RtDataValues;
        private bool m_PMAIsInstalled;
        private bool m_PMBIsInstalled;
        private bool m_PMCIsInstalled;
        private bool m_PMDIsInstalled;
        private bool m_LLAIsInstalled;
        private bool m_LLBIsInstalled;
        private bool m_TMIsInstalled;
        private bool m_EFEMIsInstalled;
        private bool m_ButtonIsEnableLP1;
        private bool m_ButtonIsEnableLP2;
        private bool m_ButtonIsEnableLP3;


        private WaferInfo m_EFEMBladeAWafer;
        private WaferInfo m_EFEMBladeBWafer;
        private WaferInfo m_Aligner1Wafer;
        private int m_LP1WaferCount;
        private int m_LP2WaferCount;
        private int m_LP3WaferCount;
        private WaferAssociationInfo _lp1WaferAssociation;
        private WaferAssociationInfo _lp2WaferAssociation;
        private WaferAssociationInfo _lp3WaferAssociation;

        private int m_CycledWafer;
        private int m_CycleCountDisplay;

        //private RobotPosition m_CurrentRobotPosition;

        private WaferInfo m_BladeAWafer;
        private WaferInfo m_BladeBWafer;

        private RecipeResult m_PMARecipeResult;
        private RecipeResult m_PMBRecipeResult;
        private RecipeResult m_PMCRecipeResult;
        private RecipeResult m_PMDRecipeResult;

        private bool m_ATMModeIsOn;


        private float m_TMPressure;

        private string m_RouteState;
        private PressureType m_PressureType;
        DispatcherTimer timer;

        private string m_PMAChamberType;
        private string m_PMBChamberType;
        private string m_PMCChamberType;
        private string m_PMDChamberType;

        #endregion

        #region  属性

        public string PMAChamberType
        {
            get { return m_PMAChamberType; }
            set { SetProperty(ref m_PMAChamberType, value); }
        }

        public string PMBChamberType
        {
            get { return m_PMBChamberType; }
            set { SetProperty(ref m_PMBChamberType, value); }
        }

        public string PMCChamberType
        {
            get { return m_PMCChamberType; }
            set { SetProperty(ref m_PMCChamberType, value); }
        }
        public PressureType PressureType
        {
            get { return m_PressureType; }
            set { SetProperty(ref m_PressureType, value); }
        }

        public string PMDChamberType
        {
            get { return m_PMDChamberType; }
            set { SetProperty(ref m_PMDChamberType, value); }
        }

        public bool TabIsChecked
        {
            get { return m_TabIsChecked; }
            set { SetProperty(ref m_TabIsChecked, value); }
        }
        public ModuleInfo LP1ModuleInfo
        {
            get { return m_LP1ModuleInfo; }
            set { SetProperty(ref m_LP1ModuleInfo, value); }
        }

        public ModuleInfo LLAModuleInfo
        {
            get { return m_LLAModuleInfo; }
            set { SetProperty(ref m_LLAModuleInfo, value); }
        }
        public ModuleInfo LLBModuleInfo
        {
            get { return m_LLBModuleInfo; }
            set { SetProperty(ref m_LLBModuleInfo, value); }
        }

        public ModuleInfo EFEMModuleInfo
        {
            get { return m_EFEMModuleInfo; }
            set { SetProperty(ref m_EFEMModuleInfo, value); }
        }
        public ModuleInfo TMModuleInfo
        {
            get { return m_TMModuleInfo; }
            set { SetProperty(ref m_TMModuleInfo, value); }
        }
        public ModuleInfo LP2ModuleInfo
        {
            get { return m_LP2ModuleInfo; }
            set { SetProperty(ref m_LP2ModuleInfo, value); }
        }
        public ModuleInfo LP3ModuleInfo
        {
            get { return m_LP3ModuleInfo; }
            set { SetProperty(ref m_LP3ModuleInfo, value); }
        }
        //public WaferRobotTAction Robot1TAction
        //{
        //    get { return m_Robot1TAction; }
        //    set { SetProperty(ref m_Robot1TAction, value); }
        //}
        //public WaferRobotXAction Robot1XAction
        //{
        //    get { return m_Robot1XAction; }
        //    set { SetProperty(ref m_Robot1XAction, value); }
        //}
        //public WaferRobotTAction Robot2TAction
        //{
        //    get { return m_Robot2TAction; }
        //    set { SetProperty(ref m_Robot2TAction, value); }
        //}
        //public WaferRobotXAction Robot2XAction
        //{
        //    get { return m_Robot2XAction; }
        //    set { SetProperty(ref m_Robot2XAction, value); }
        //}

        //public WaferRobotTAction Robot3TAction
        //{
        //    get { return m_Robot3TAction; }
        //    set { SetProperty(ref m_Robot3TAction, value); }
        //}
        //public WaferRobotXAction Robot3XAction
        //{
        //    get { return m_Robot3XAction; }
        //    set { SetProperty(ref m_Robot3XAction, value); }
        //}
        //public WaferRobotTAction Robot4TAction
        //{
        //    get { return m_Robot4TAction; }
        //    set { SetProperty(ref m_Robot4TAction, value); }
        //}
        //public WaferRobotXAction Robot4XAction
        //{
        //    get { return m_Robot4XAction; }
        //    set { SetProperty(ref m_Robot4XAction, value); }
        //}

        public RobotMoveInfo RobotMoveInfo
        {
            get { return m_robotMoveInfo; }
            set
            {
                TMRobotMoveInfoChanged(m_robotMoveInfo, value);
                //m_robotMoveInfo = value;
                SetProperty(ref m_robotMoveInfo, value);
            }
        }

        public NiceGuangChuanWaferRobotTAction BladeNiceGuangChuanWaferRobotTAction
        {
            get { return m_BladeNiceGuangChuanWaferRobotTAction; }
            set 
            { 
                SetProperty(ref m_BladeNiceGuangChuanWaferRobotTAction, value); 
            }
        }
        //public NiceGuangChuanWaferRobotTAction Blade2NiceGuangChuanWaferRobotTAction
        //{
        //    get { return m_Blade2NiceGuangChuanWaferRobotTAction; }
        //    set
        //    {
        //        SetProperty(ref m_Blade2NiceGuangChuanWaferRobotTAction, value);
        //    }
        //}

        public NiceGuangChuanWaferRobotXAction Blade1NiceGuangChuanWaferRobotXAction
        {
            get { return m_Blade1NiceGuangChuanWaferRobotXAction; }
            set
            {
                SetProperty(ref m_Blade1NiceGuangChuanWaferRobotXAction, value);
            }
        }
        public NiceGuangChuanWaferRobotXAction Blade2NiceGuangChuanWaferRobotXAction
        {
            get { return m_Blade2NiceGuangChuanWaferRobotXAction; }
            set
            {
                SetProperty(ref m_Blade2NiceGuangChuanWaferRobotXAction, value);
            }
        }


        public NiceXinSongWaferRobotTAction BladeNiceXinSongWaferRobotTAction
        {
            get { return m_BladeNiceXinSongWaferRobotTAction; }
            set
            {
                SetProperty(ref m_BladeNiceXinSongWaferRobotTAction, value);
            }
        }
        //public NiceXinSongWaferRobotTAction Blade2NiceXinSongWaferRobotTAction
        //{
        //    get { return m_Blade2NiceXinSongWaferRobotTAction; }
        //    set
        //    {
        //        SetProperty(ref m_Blade2NiceXinSongWaferRobotTAction, value);
        //    }
        //}

        public NiceXinSongWaferRobotXAction Blade1NiceXinSongWaferRobotXAction
        {
            get { return m_Blade1NiceXinSongWaferRobotXAction; }
            set
            {
                SetProperty(ref m_Blade1NiceXinSongWaferRobotXAction, value);
            }
        }
        public NiceXinSongWaferRobotXAction Blade2NiceXinSongWaferRobotXAction
        {
            get { return m_Blade2NiceXinSongWaferRobotXAction; }
            set
            {
                SetProperty(ref m_Blade2NiceXinSongWaferRobotXAction, value);
            }
        }
        public WaferInfo LLAWafer
        {
            get { return m_LLAWafer; }
            set { SetProperty(ref m_LLAWafer, value); }
        }
        public WaferInfo LLBWafer
        {
            get { return m_LLBWafer; }
            set { SetProperty(ref m_LLBWafer, value); }
        }
        public WaferInfo PMAWafer
        {
            get { return m_PMAWafer; }
            set { SetProperty(ref m_PMAWafer, value); }
        }
        public WaferInfo PMBWafer
        {
            get { return m_PMBWafer; }
            set { SetProperty(ref m_PMBWafer, value); }
        }
        public WaferInfo PMCWafer
        {
            get { return m_PMCWafer; }
            set { SetProperty(ref m_PMCWafer, value); }
        }
        public WaferInfo PMDWafer
        {
            get { return m_PMDWafer; }
            set { SetProperty(ref m_PMDWafer, value); }
        }

        public WaferInfo TMBladeAWafer
        {
            get { return m_TMBladeAWafer; }
            set { SetProperty(ref m_TMBladeAWafer, value); }
        }
        public WaferInfo TMBladeBWafer
        {
            get { return m_TMBladeBWafer; }
            set { SetProperty(ref m_TMBladeBWafer, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool PMAIsInstalled
        {
            get { return m_PMAIsInstalled; }
            set { SetProperty(ref m_PMAIsInstalled, value); }
        }
        public bool PMBIsInstalled
        {
            get { return m_PMBIsInstalled; }
            set { SetProperty(ref m_PMBIsInstalled, value); }
        }
        public bool PMCIsInstalled
        {
            get { return m_PMCIsInstalled; }
            set { SetProperty(ref m_PMCIsInstalled, value); }
        }
        public bool PMDIsInstalled
        {
            get { return m_PMDIsInstalled; }
            set { SetProperty(ref m_PMDIsInstalled, value); }
        }
        public bool LLAIsInstalled
        {
            get { return m_LLAIsInstalled; }
            set { SetProperty(ref m_LLAIsInstalled, value); }
        }
        public bool LLBIsInstalled
        {
            get { return m_LLBIsInstalled; }
            set { SetProperty(ref m_LLBIsInstalled, value); }
        }
        public bool TMIsInstalled
        {
            get { return m_TMIsInstalled; }
            set { SetProperty(ref m_TMIsInstalled, value); }
        }
        public bool EFEMIsInstalled
        {
            get { return m_EFEMIsInstalled; }
            set { SetProperty(ref m_EFEMIsInstalled, value); }
        }
        public bool ButtonIsEnableLP1
        {
            get { return m_ButtonIsEnableLP1; }
            set 
            {
                if (m_ButtonIsEnableLP1 == false && value == true && LP1WaferAssociation!=null)
                {
                    LP1WaferAssociation.IsEnableCycle = false;
                    LP1WaferAssociation.CycleNumber = 1;
                }
                SetProperty(ref m_ButtonIsEnableLP1, value); 
            }
        }
        public bool ButtonIsEnableLP2
        {
            get { return m_ButtonIsEnableLP2; }
            set 
            {
                if (m_ButtonIsEnableLP2 == false && value == true && LP2WaferAssociation != null)
                {
                    LP2WaferAssociation.IsEnableCycle = false;
                    LP2WaferAssociation.CycleNumber = 1;
                }
                SetProperty(ref m_ButtonIsEnableLP2, value); 
            }
        }
        public bool ButtonIsEnableLP3
        {
            get { return m_ButtonIsEnableLP3; }
            set 
            {
                if (m_ButtonIsEnableLP3 == false && value == true && LP3WaferAssociation != null)
                {
                    LP3WaferAssociation.IsEnableCycle = false;
                    LP3WaferAssociation.CycleNumber = 1;
                }
                SetProperty(ref m_ButtonIsEnableLP3, value);
            }
        }
        public WaferInfo EFEMBladeAWafer
        {
            get { return m_EFEMBladeAWafer; }
            set { SetProperty(ref m_EFEMBladeAWafer, value); }
        }
        public WaferInfo EFEMBladeBWafer
        {
            get { return m_EFEMBladeBWafer; }
            set { SetProperty(ref m_EFEMBladeBWafer, value); }
        }
        public WaferInfo Aligner1Wafer
        {
            get { return m_Aligner1Wafer; }
            set { SetProperty(ref m_Aligner1Wafer, value); }
        }
        public int LP1WaferCount
        {
            get { return m_LP1WaferCount; }
            set { SetProperty(ref m_LP1WaferCount, value); }
        }
        public int LP2WaferCount
        {
            get { return m_LP2WaferCount; }
            set { SetProperty(ref m_LP2WaferCount, value); }
        }
        public int LP3WaferCount
        {
            get { return m_LP3WaferCount; }
            set { SetProperty(ref m_LP3WaferCount, value); }
        }
        public WaferAssociationInfo LP1WaferAssociation
        {
            get { return _lp1WaferAssociation; }
            set { SetProperty(ref _lp1WaferAssociation, value); }
        }
        public WaferAssociationInfo LP2WaferAssociation
        {
            get { return _lp2WaferAssociation; }
            set { SetProperty(ref _lp2WaferAssociation, value); }
        }
        public WaferAssociationInfo LP3WaferAssociation
        {
            get { return _lp3WaferAssociation; }
            set { SetProperty(ref _lp3WaferAssociation, value); }
        }
        public int CycledWafer
        {
            get { return m_CycledWafer; }
            set { SetProperty(ref m_CycledWafer, value); }
        }
        public int CycleCountDisplay
        {
            get { return m_CycleCountDisplay; }
            set { SetProperty(ref m_CycleCountDisplay, value); }
        }
        public RobotMoveInfo m_EfemRobotMoveInfo;
        public RobotMoveInfo EfemRobotMoveInfo
        {
            get { return m_EfemRobotMoveInfo; }
            set
            {
                EFEMRobotMoveInfoChanged(m_EfemRobotMoveInfo, value);
                //m_EfemRobotMoveInfo = value;
                SetProperty(ref m_EfemRobotMoveInfo, value);

            }
        }
        //public RobotPosition CurrentRobotPosition
        //{
        //    get { return m_CurrentRobotPosition; }
        //    set { SetProperty(ref m_CurrentRobotPosition, value); }
        //}
        public WaferInfo BladeAWafer
        {
            get { return m_BladeAWafer; }
            set { SetProperty(ref m_BladeAWafer, value); }
        }
        public WaferInfo BladeBWafer
        {
            get { return m_BladeBWafer; }
            set { SetProperty(ref m_BladeBWafer, value); }
        }
        public RecipeResult PMARecipeResult
        {
            get { return m_PMARecipeResult; }
            set { SetProperty(ref m_PMARecipeResult, value); }
        }
        public RecipeResult PMBRecipeResult
        {
            get { return m_PMBRecipeResult; }
            set { SetProperty(ref m_PMBRecipeResult, value); }
        }
        public RecipeResult PMCRecipeResult
        {
            get { return m_PMCRecipeResult; }
            set { SetProperty(ref m_PMCRecipeResult, value); }
        }
        public RecipeResult PMDRecipeResult
        {
            get { return m_PMDRecipeResult; }
            set { SetProperty(ref m_PMDRecipeResult, value); }
        }
        public bool ATMModeIsOn
        {
            get { return m_ATMModeIsOn; }
            set { SetProperty(ref m_ATMModeIsOn, value); }
        }

        public float TMPressure
        {
            get { return m_TMPressure; }
            set { SetProperty(ref m_TMPressure, value); }
        }
        public string RouteState
        {
            get { return m_RouteState; }
            set { SetProperty(ref m_RouteState, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand<object> _LoadCommand;
        public DelegateCommand<object> LoadCommand =>
            _LoadCommand ?? (_LoadCommand = new DelegateCommand<object>(OnLoad));

        private DelegateCommand<object> _LoadWaferCommand;
        public DelegateCommand<object> LoadWaferCommand =>
            _LoadWaferCommand ?? (_LoadWaferCommand = new DelegateCommand<object>(OnLoadWafer));

        private DelegateCommand<object> _UnLoadWaferCommand;
        public DelegateCommand<object> UnLoadWaferCommand =>
            _UnLoadWaferCommand ?? (_UnLoadWaferCommand = new DelegateCommand<object>(OnUnLoadWafer));

        private DelegateCommand<object> _SelectAllCommand;
        public DelegateCommand<object> SelectAllCommand =>
            _SelectAllCommand ?? (_SelectAllCommand = new DelegateCommand<object>(OnSelectAll));

        private DelegateCommand<object> _UnSelectAllCommand;
        public DelegateCommand<object> UnSelectAllCommand =>
            _UnSelectAllCommand ?? (_UnSelectAllCommand = new DelegateCommand<object>(OnUnSelectAll));

        private DelegateCommand<object> _StartCommand;
        public DelegateCommand<object> StartCommand =>
            _StartCommand ?? (_StartCommand = new DelegateCommand<object>(OnStart));

        private DelegateCommand<object> _StopCommand;
        public DelegateCommand<object> StopCommand =>
            _StopCommand ?? (_StopCommand = new DelegateCommand<object>(OnStop));

        private DelegateCommand<object> _AbortCommand;
        public DelegateCommand<object> AbortCommand =>
            _AbortCommand ?? (_AbortCommand = new DelegateCommand<object>(OnAbort));


        private DelegateCommand _HomeAllCommand;
        public DelegateCommand HomeAllCommand =>
            _HomeAllCommand ?? (_HomeAllCommand = new DelegateCommand(OnHomeAll));


        private DelegateCommand _ResumeAllJobCommand;
        public DelegateCommand ResumeAllJobCommand =>
            _ResumeAllJobCommand ?? (_ResumeAllJobCommand = new DelegateCommand(OnResumeAllJob));

        private DelegateCommand _AbortAllCommand;
        public DelegateCommand AbortAllCommand =>
            _AbortAllCommand ?? (_AbortAllCommand = new DelegateCommand(OnAbortAll));

        private DelegateCommand _ReturnAllWaferCommand;
        public DelegateCommand ReturnAllWaferCommand =>
            _ReturnAllWaferCommand ?? (_ReturnAllWaferCommand = new DelegateCommand(OnReturnAllWafer));

        private DelegateCommand<object> _SetSequenceCommand;
        public DelegateCommand<object> SetSequenceCommand =>
            _SetSequenceCommand ?? (_SetSequenceCommand = new DelegateCommand<object>(OnSetSequence));

        private DelegateCommand<object> _CreateJobCommand;
        public DelegateCommand<object> CreateJobCommand =>
            _CreateJobCommand ?? (_CreateJobCommand = new DelegateCommand<object>(OnCreateJob));

        private DelegateCommand<object> _AbortJobCommand;
        public DelegateCommand<object> AbortJobCommand =>
            _AbortJobCommand ?? (_AbortJobCommand = new DelegateCommand<object>(OnAbortJob));

        private DelegateCommand _EnableAutoCommand;
        public DelegateCommand EnableAutoCommand =>
            _EnableAutoCommand ?? (_EnableAutoCommand = new DelegateCommand(OnEnableAuto));

        private DelegateCommand _EnableManualCommand;
        public DelegateCommand EnableManualCommand =>
            _EnableManualCommand ?? (_EnableManualCommand = new DelegateCommand(OnEnableManual));

        private DelegateCommand _LostFocusCommand;
        public DelegateCommand LostFocusCommand =>
            _LostFocusCommand ?? (_LostFocusCommand = new DelegateCommand(OnLostFocus));

        private DelegateCommand _GotFocusCommand;
        public DelegateCommand GotFocusCommand =>
            _GotFocusCommand ?? (_GotFocusCommand = new DelegateCommand(OnGotFocus));


        public bool SwitchFlag;

        #endregion

        #region 构造函数
        public OperationOverViewModel()
        {
            string allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString();
            PMAIsInstalled = allModules.Contains("PMA");
            PMBIsInstalled = allModules.Contains("PMB");
            PMCIsInstalled = allModules.Contains("PMC");
            PMDIsInstalled = allModules.Contains("PMD");
            LLAIsInstalled = allModules.Contains("LLA");
            LLBIsInstalled = allModules.Contains("LLB");
            EFEMIsInstalled = allModules.Contains("EFEM");
            TMIsInstalled = allModules.Contains("TM");

            timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.5);
            addDataKeys();
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            timer.Tick += Timer_Tick;
            timer.Start();
            

            if (PMAIsInstalled)
            {
                PMAChamberType = ((JetChamber)QueryDataClient.Instance.Service.GetConfig($"PMA.ChamberType")).ToString().Substring(6);
            }
            if (PMBIsInstalled)
            {
                PMBChamberType = ((JetChamber)QueryDataClient.Instance.Service.GetConfig($"PMB.ChamberType")).ToString().Substring(6);
            }
            if (PMCIsInstalled)
            {
                PMCChamberType = ((JetChamber)QueryDataClient.Instance.Service.GetConfig($"PMC.ChamberType")).ToString().Substring(6);
            }
            if (PMDIsInstalled)
            {
                PMDChamberType = ((JetChamber)QueryDataClient.Instance.Service.GetConfig($"PMD.ChamberType")).ToString().Substring(6);
            }
            SwitchFlag = false;

            ATMModeIsOn = Convert.ToBoolean(QueryDataClient.Instance.Service.GetConfig("System.IsATMMode"));

            LOG.Info("开启UI界面");
        }


        #endregion

        #region 命令方法
        private void OnLoad(object obj)
        {
            if (!SwitchFlag)
            {
                //var t = (obj as OperationOverView);
                LP1WaferAssociation = new WaferAssociationInfo();
                LP3WaferAssociation = new WaferAssociationInfo();
                LP2WaferAssociation = new WaferAssociationInfo();
                LP1WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP1"];
                LP2WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP2"];
                LP3WaferAssociation.ModuleData = ModuleManager.ModuleInfos["LP3"];
                SwitchFlag = true;

                PressureType = (PressureType)Convert.ToInt32(QueryDataClient.Instance.Service.GetData("System.PressureUnitType"));
            }

        }

        //private void T_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        //{
        //    if (timer.IsEnabled)
        //    {
        //        timer.Stop();

        //    }
        //    else
        //    {
        //        timer.Start();
        //    }
        //}

        private void OnLoadWafer(object obj)
        {
            InvokeClient.Instance.Service.DoOperation($"{obj.ToString()}.Load", ModuleManager.ModuleInfos[obj.ToString()].ModuleID);
        }
        private void OnUnLoadWafer(object obj)
        {
            InvokeClient.Instance.Service.DoOperation($"{obj.ToString()}.Unload", ModuleManager.ModuleInfos[obj.ToString()].ModuleID);
        }
        private void OnSelectAll(object obj)
        {
            var info = obj as WaferAssociationInfo;

            var module = info.ModuleData.ModuleID;

            if (CommonFunction.GetValue<bool>(RtDataValues, $"{module}.IsLoaded"))
            {
                info.SlotFrom = 1;
                info.SlotTo = 25;
                AssociateSequence(info, true);
            }
        }
        private void OnUnSelectAll(object obj)
        {
            var info = obj as WaferAssociationInfo;

            var module = info.ModuleData.ModuleID;

            info.SlotFrom = 1;
            info.SlotTo = 25;
            AssociateSequence(info, false);
        }
        private void OnStart(object obj)
        {
            var info = obj as WaferAssociationInfo;
            InvokeClient.Instance.Service.DoOperation("System.StartJob", info.JobID);
            LOG.Info("System,Start Job");

        }
        private void OnStop(object obj)
        {
            var info = obj as WaferAssociationInfo;
            InvokeClient.Instance.Service.DoOperation("System.AbortJob", info.JobID);
            LOG.Info($"System,Stop Job{info.JobID}");
        }
        private void OnAbort(object obj)
        {
            var info = obj as WaferAssociationInfo;

            InvokeClient.Instance.Service.DoOperation("System.StopJob", info.JobID);
            LOG.Info($"System,Stop Job{info.JobID}");

        }
        private void OnHomeAll()
        {
            InvokeClient.Instance.Service.DoOperation("System.HomeAll");
            LOG.Info("System,Home All");
        }

        private void OnResumeAllJob()
        {
            var t = CommonFunction.GetValue<List<string>>(RtDataValues, "Scheduler.PjNameList");
            if (t == null && t.Count == 0)
            {
                return;
            }
            if (CommonFunction.GetValue<int>(RtDataValues, "EquipmentStatus") == 4)
            {
                t.ForEach(x =>
                {
                    InvokeClient.Instance.Service.DoOperation("System.ResumeJob", x);
                });
                LOG.Info("System,Resume All Job");

            }
            else
            {
                t.ForEach(x =>
                {
                    InvokeClient.Instance.Service.DoOperation("System.PauseJob", x);
                });
                LOG.Info("System,Pause All Job");
            }
        }
        private void OnAbortAll()
        {
            InvokeClient.Instance.Service.DoOperation("System.Abort");
            LOG.Info("System, Abort");

        }
        private void OnReturnAllWafer()
        {
            //Dialog
            //WaferDialogView dialog = new WaferDialogView()
            //{
            //    Owner = Application.Current.MainWindow,
            //};
            //dialog.Height = 300;
            //dialog.Width = 400;
            //double angel = 0;
            //double coolingtime = 0;
            //string message = "Please Confirm Return Wafer";
            //WaferDialogViewModel vm = new WaferDialogViewModel();
            //vm.ConfirmText = message;
            //dialog.DataContext = vm;
            //if (dialog.ShowDialog() == true)
            //{
            //    if ((bool)dialog.AlignFlag == true && !string.IsNullOrEmpty(dialog.Angle))
            //    {
            //        angel = Convert.ToDouble(dialog.Angle);
            //    }

            //    if ((bool)dialog.CoolingFlag == true && !string.IsNullOrEmpty(dialog.CoolingTime))
            //    {
            //        coolingtime = Convert.ToDouble(dialog.CoolingTime);
            //    }

            //}
            InvokeClient.Instance.Service.DoOperation("System.ReturnAllWafer", false, 0, false, 0);

            LOG.Info("System,Return All Wafer");
        }

        private void OnSetSequence(object obj)
        {
            var info = obj as WaferInfo;
            bool flag = info.SequenceName != "" ? false : true;
            if (info.ModuleID == "LP1" && (CommonFunction.GetValue<bool>(RtDataValues, "LP1.IsLoaded")))
            {
                AssociateSequence(LP1WaferAssociation, flag, info.SlotID);
            }
            else if (info.ModuleID == "LP2" && (CommonFunction.GetValue<bool>(RtDataValues, "LP2.IsLoaded")))
            {
                AssociateSequence(LP2WaferAssociation, flag, info.SlotID);
            }
            else if (info.ModuleID == "LP3" && (CommonFunction.GetValue<bool>(RtDataValues, "LP3.IsLoaded")))
            {
                AssociateSequence(LP3WaferAssociation, flag, info.SlotID);
            }
        }
        private void OnCreateJob(object obj)
        {
            var info = obj as WaferAssociationInfo;
            List<string> slotSequence = new List<string>();
            info.ModuleData.WaferManager.Wafers.ForEach(key => { slotSequence.Insert(0, key.SequenceName); });

            //string jobId = info.LotId.Trim();

            info.LotIdSaved = true;

            Dictionary<string, object> param = new Dictionary<string, object>()
            {
                {"JobId", info.JobID},
                {"LotId", info.LotId},         
                {"Module", info.ModuleData.ModuleID},
                {"SlotSequence", slotSequence.ToArray()},
                {"AutoStart", true},
                { "PreCleanRecipeName",info.PreCleanRecipeName},
                { "PostCleanRecipeName",info.PostCleanRecipeName},
                { "CycleNumber",info.CycleNumber}
            };
            InvokeClient.Instance.Service.DoOperation("System.CreateJob", param);
        }
        private void OnAbortJob(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("System.AbortJob", obj.ToString());
        }
        private void OnEnableAuto()
        {
            InvokeClient.Instance.Service.DoOperation("System.SetAutoMode");
        }
        private void OnEnableManual()
        {
            InvokeClient.Instance.Service.DoOperation("System.SetManualMode");
        }
        private void OnLostFocus()
        {
            timer.Stop();
        }
        private void OnGotFocus()
        {
            timer.Start();
        }

        #endregion

        #region 私有方法
        private void Timer_Tick(object sender, EventArgs e)
        {
            RobotMoveInfo = (RobotMoveInfo)QueryDataClient.Instance.Service.GetData("TM.RobotMoveAction");
            EfemRobotMoveInfo = (RobotMoveInfo)QueryDataClient.Instance.Service.GetData("EFEM.RobotMoveAction");

            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            if (RtDataValues == null || RtDataValues.Count==0)
            {
                return;
            }
            LP1ModuleInfo = ModuleManager.ModuleInfos["LP1"];
            LP2ModuleInfo = ModuleManager.ModuleInfos["LP2"];
            LP3ModuleInfo = ModuleManager.ModuleInfos["LP3"];
            EFEMModuleInfo = ModuleManager.ModuleInfos["EfemRobot"];
            TMModuleInfo = ModuleManager.ModuleInfos["TMRobot"];
            BladeAWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0];
            BladeBWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1];

            

            if (LLAIsInstalled == true)
            {
                LLAModuleInfo = ModuleManager.ModuleInfos["LLA"];
                LLAWafer = ModuleManager.ModuleInfos["LLA"].WaferManager.Wafers.FirstOrDefault(x => x.WaferStatus != 0);

            }
            if (LLBIsInstalled == true)
            {
                LLBModuleInfo = ModuleManager.ModuleInfos["LLB"];
                LLBWafer = ModuleManager.ModuleInfos["LLB"].WaferManager.Wafers.FirstOrDefault(x => x.WaferStatus != 0);
            }
            if (PMAIsInstalled == true)
            {
                PMAWafer = ModuleManager.ModuleInfos["PMA"].WaferManager.Wafers[0];
                PMARecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMA.CurrentRecipeResult");
            }
            if (PMBIsInstalled == true)
            {
                PMBWafer = ModuleManager.ModuleInfos["PMB"].WaferManager.Wafers[0];
                PMBRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMB.CurrentRecipeResult");

            }
            if (PMCIsInstalled == true)
            {
                PMCWafer = ModuleManager.ModuleInfos["PMC"].WaferManager.Wafers[0];
                PMCRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMC.CurrentRecipeResult");
            }
            if (PMDIsInstalled == true)
            {
                PMDWafer = ModuleManager.ModuleInfos["PMD"].WaferManager.Wafers[0];
                PMDRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, $"PMD.CurrentRecipeResult");

            }

            if (TMIsInstalled == true)
            {
                TMBladeAWafer = ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0];
                TMBladeBWafer = ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1];
                TMPressure = CommonFunction.GetValue<float>(RtDataValues, $"TM.TMProcessGauge.Value");
            }

            if (EFEMIsInstalled == true)
            {
                EFEMBladeAWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0];
                EFEMBladeBWafer = ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1];
                Aligner1Wafer = ModuleManager.ModuleInfos["Aligner1"].WaferManager.Wafers[0];
                ControlJobInfo lp1Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP1.CurrentControlJob");
                if (lp1Cj == null)
                {
                    ButtonIsEnableLP1 = true;
                }
                else
                {
                    ButtonIsEnableLP1= false;
                    UPdateWaferAssociation(LP1WaferAssociation, lp1Cj);
                }
                ControlJobInfo lp2Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP2.CurrentControlJob");
                if (lp2Cj == null)
                {
                    ButtonIsEnableLP2 = true;
                }
                else
                {
                    ButtonIsEnableLP2 = false;
                    UPdateWaferAssociation(LP2WaferAssociation, lp2Cj);
                }
                ControlJobInfo lp3Cj = CommonFunction.GetValue<ControlJobInfo>(RtDataValues, "LP3.CurrentControlJob");
                if (lp3Cj == null)
                {
                    ButtonIsEnableLP3 = true;
                }
                else
                {
                    ButtonIsEnableLP3 = false;
                    UPdateWaferAssociation(LP3WaferAssociation, lp3Cj);
                }
            }

            
            //LP1WaferCount = LP1ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            //LP2WaferCount = LP2ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            //LP3WaferCount = LP3ModuleInfo.WaferManager.Wafers.Where(x => x.WaferStatus != 0).Count();
            if (CommonFunction.GetValue<int>(RtDataValues, "EquipmentStatus") == 4)
            {
                RouteState = "Resume";
            }
            else
            {
                RouteState = "Pause";
            }
        }
        /// <summary>
        /// 更新Wafer情况
        /// </summary>
        /// <param name="info"></param>
        /// <param name="cjInfo"></param>
        private void UPdateWaferAssociation(WaferAssociationInfo info, ControlJobInfo cjInfo)
        {
            if(info==null)
            {
                return; 
            }
            if (cjInfo != null)
            {
                info.LotId = cjInfo.LotName;
                info.JobID = cjInfo.Name;
                info.JobStatus = cjInfo.State.ToString();
                if (cjInfo.SequenceNameList != null)
                {
                    for (int i = 0; i < cjInfo.SequenceNameList.Length; i++)
                    {
                        info.ModuleData.WaferManager.Wafers[24 - i].SequenceName = cjInfo.SequenceNameList[i];
                    }
                }
                info.PreCleanRecipeName = cjInfo.PreJobClean;
                info.PostCleanRecipeName = cjInfo.PostJobClean;
            }
            else
            {
                if (!string.IsNullOrEmpty(info.JobID))
                {
                    info.LotId = "";
                    info.JobID = "";
                    info.JobStatus = "";
                    info.PreCleanRecipeName = "";
                    info.PostCleanRecipeName = "";
                    AssociateSequence(info, false);
                }
            }
        }
        private async void TMRobotMoveInfoChanged(RobotMoveInfo oldValue, RobotMoveInfo newValue)
        {
            
            string RobotTarget;
            if (oldValue == null || newValue == null)
            {
                return;
            }

            #region Rotating
            if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && (newValue.Action == RobotAction.Rotating))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];

                bool isParseOK;
                BladeNiceXinSongWaferRobotTAction = CommonFunction.ToEnum<NiceXinSongWaferRobotTAction>(module, out isParseOK);
                if (isParseOK == false)
                {
                    return;
                }
             
                //if (arm == "ArmA")
                //{        
                //}
                //else if (arm == "ArmB")
                //{
                //    Blade2NiceXinSongWaferRobotTAction = (NiceXinSongWaferRobotTAction)Enum.Parse(typeof(NiceXinSongWaferRobotTAction), module, true);
                //}
            }
            #endregion

            #region pick 和 place LL
            if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && (newValue.Action == RobotAction.Placing || newValue.Action == RobotAction.Picking))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];

                if (arm == "ArmA")
                {

                    bool isParseOK;
                    BladeNiceXinSongWaferRobotTAction = CommonFunction.ToEnum<NiceXinSongWaferRobotTAction>(module, out isParseOK);
                    if (isParseOK == false)
                    {
                        return;
                    }

                    //var waferRobotTAction = (NiceXinSongWaferRobotTAction)Enum.Parse(typeof(NiceXinSongWaferRobotTAction), module, true);

                    //BladeNiceXinSongWaferRobotTAction = waferRobotTAction;
                    await Task.Delay(600);
                    Blade1NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Extend1;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[0].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    //Robot1XAction = WaferRobotXAction.Retract;
                    Blade1NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract1;

                }
                else if (arm == "ArmB")
                {
                    bool isParseOK;
                    BladeNiceXinSongWaferRobotTAction = CommonFunction.ToEnum<NiceXinSongWaferRobotTAction>(module, out isParseOK);
                    if (isParseOK == false)
                    {
                        return;
                    }
                    //var waferRobotTAction = (NiceXinSongWaferRobotTAction)Enum.Parse(typeof(NiceXinSongWaferRobotTAction), module, true);

                    //BladeNiceXinSongWaferRobotTAction = waferRobotTAction;
                    //var waferRobotTAction = (WaferRobotTAction)Enum.Parse(typeof(WaferRobotTAction), module, true);
                    //var waferRobotTAction = (NiceXinSongWaferRobotTAction)Enum.Parse(typeof(NiceXinSongWaferRobotTAction), module, true);
                    //Blade2NiceXinSongWaferRobotTAction = waferRobotTAction;

                    //if (waferRobotTAction != Blade2NiceXinSongWaferRobotTAction)
                    //{
                    //}
                    await Task.Delay(600);                  
                    Blade2NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Extend2;

                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["TMRobot"].WaferManager.Wafers[1].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }                    
                    Blade2NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract2;

                }
            }

            #endregion          

            #region pick 和 place pm
            else if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && newValue.Action == RobotAction.Extending)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];
                bool isParseOK;
                BladeNiceXinSongWaferRobotTAction = CommonFunction.ToEnum<NiceXinSongWaferRobotTAction>(module, out isParseOK);
                if (isParseOK == false)
                {
                    return;
                }
                //var waferRobotTAction = (NiceXinSongWaferRobotTAction)Enum.Parse(typeof(NiceXinSongWaferRobotTAction), module, true);
                //BladeNiceXinSongWaferRobotTAction = waferRobotTAction;
                if (arm == "ArmA")
                {                                                      
                    await Task.Delay(600);
                    Blade1NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Extend1;
                }
                else if (arm == "ArmB")
                {                                                        
                    await Task.Delay(600);
                    Blade2NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Extend2;
                }
            }
            else if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget) && newValue.Action == RobotAction.Retracting)
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                if (arm == "ArmA")
                {
                    //Robot1XAction = WaferRobotXAction.Retract;
                    Blade1NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract1;

                }
                else if (arm == "ArmB")
                {
                    //Robot2XAction = WaferRobotXAction.Retract;
                    Blade2NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract2;
                }
            }
            #endregion

            #region Home
            else if (oldValue.Action == RobotAction.None && newValue.Action == RobotAction.Homing)
            {
                Blade1NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract1;
                Blade2NiceXinSongWaferRobotXAction = NiceXinSongWaferRobotXAction.Retract2;

                await Task.Delay(2000);  
                BladeNiceXinSongWaferRobotTAction = NiceXinSongWaferRobotTAction.T_Origin;
                
            }

            #endregion

        }
        private async void EFEMRobotMoveInfoChanged(RobotMoveInfo oldValue, RobotMoveInfo newValue)
        {
            string RobotTarget;
            if (oldValue == null || newValue == null)
            {
                return;
            }
            #region pick 和 place LL

            if ((oldValue.Action == RobotAction.None || oldValue.ArmTarget != newValue.ArmTarget))
            {
                var TMRobotMoveActionBladeTarget = newValue.BladeTarget;
                if (TMRobotMoveActionBladeTarget != null)
                {
                    RobotTarget = TMRobotMoveActionBladeTarget.ToString();
                }
                else
                {
                    return;
                }
                var values = RobotTarget.Split('.');
                var arm = values[0];
                var module = values[1];
               
                if (arm == "ArmA")
                {

                    var bladeWaferRobotTAction = (NiceGuangChuanWaferRobotTAction)Enum.Parse(typeof(NiceGuangChuanWaferRobotTAction), module, true);
                    if (BladeNiceGuangChuanWaferRobotTAction != bladeWaferRobotTAction)
                    {
                        BladeNiceGuangChuanWaferRobotTAction = bladeWaferRobotTAction;
                        await Task.Delay(600);
                    }
                    Blade1NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Extend1;
                    //Robot3XAction = WaferRobotXAction.Extend;
                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[0].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    //Robot3XAction = WaferRobotXAction.Retract;
                    Blade1NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract1;
                }
                else if (arm == "ArmB")
                {
                    var bladeWaferRobotTAction = (NiceGuangChuanWaferRobotTAction)Enum.Parse(typeof(NiceGuangChuanWaferRobotTAction), module, true);
                    if (BladeNiceGuangChuanWaferRobotTAction != bladeWaferRobotTAction)
                    {
                        BladeNiceGuangChuanWaferRobotTAction = bladeWaferRobotTAction;
                        await Task.Delay(600);
                    }
                    //var blade2WaferRobotTAction = (NiceGuangChuanWaferRobotTAction)Enum.Parse(typeof(NiceGuangChuanWaferRobotTAction), module, true);                  
                    //if (Blade2NiceGuangChuanWaferRobotTAction != blade2WaferRobotTAction)
                    //{
                    //    Blade2NiceGuangChuanWaferRobotTAction = blade2WaferRobotTAction;
                    //    await Task.Delay(600);
                    //}

                    Blade2NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Extend2;

                    while ((newValue.Action == RobotAction.Placing && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1].WaferStatus != 0) || (newValue.Action == RobotAction.Picking && ModuleManager.ModuleInfos["EfemRobot"].WaferManager.Wafers[1].WaferStatus == 0))
                    {
                        await Task.Delay(100);
                    }
                    // Robot4XAction = WaferRobotXAction.Retract;
                    Blade2NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract2;

                }
            }

            #endregion        

            #region Home
            else if (oldValue.Action == RobotAction.Homing && newValue.Action == RobotAction.None)
            {
                Blade1NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract1;
                Blade2NiceGuangChuanWaferRobotXAction = NiceGuangChuanWaferRobotXAction.Retract2;

                await Task.Delay(1000);
                BladeNiceGuangChuanWaferRobotTAction = NiceGuangChuanWaferRobotTAction.T_Origin;
                //Blade2NiceGuangChuanWaferRobotTAction = NiceGuangChuanWaferRobotTAction.T_Origin;
            }

            #endregion

        }

        private void addDataKeys()
        {
            if (PMAIsInstalled)
            {
                m_RtDataKeys.Add("PMA.IsSlitDoorClosed");
                m_RtDataKeys.Add("PMA.CurrentRecipeResult");
                m_RtDataKeys.Add("PMA.IsOnline");
                m_RtDataKeys.Add("PMA.CalculationPressure");
                m_RtDataKeys.Add("PMA.IsLidClosed");
                m_RtDataKeys.Add("PMA.HighTemperatureHeater.DeviceData");

            }
            if (PMBIsInstalled)
            {
                m_RtDataKeys.Add("PMB.IsSlitDoorClosed");
                m_RtDataKeys.Add("PMB.CurrentRecipeResult");
                m_RtDataKeys.Add("PMB.IsOnline");
                m_RtDataKeys.Add("PMB.CalculationPressure");
                m_RtDataKeys.Add("PMB.IsLidClosed");
                m_RtDataKeys.Add("PMB.HighTemperatureHeater.DeviceData");

            }
            if (PMCIsInstalled)
            {
                m_RtDataKeys.Add("PMC.IsSlitDoorClosed");
                m_RtDataKeys.Add("PMC.CurrentRecipeResult");
                m_RtDataKeys.Add("PMC.IsOnline");
                m_RtDataKeys.Add("PMC.CalculationPressure");
                m_RtDataKeys.Add("PMC.IsLidClosed");
                m_RtDataKeys.Add("PMC.HighTemperatureHeater.DeviceData");

            }
            if (PMDIsInstalled)
            {
                m_RtDataKeys.Add("PMD.IsSlitDoorClosed");
                m_RtDataKeys.Add("PMD.CurrentRecipeResult");
                m_RtDataKeys.Add("PMD.IsOnline");
                m_RtDataKeys.Add("PMD.CalculationPressure");
                m_RtDataKeys.Add("PMD.IsLidClosed");
                m_RtDataKeys.Add("PMD.HighTemperatureHeater.DeviceData");

            }

            m_RtDataKeys.Add("TM.LLATSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLBTSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLAESlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.LLBESlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.IsOnline");
            m_RtDataKeys.Add("TM.TMProcessGauge.Value");
            m_RtDataKeys.Add("TM.IoSensor.TMATMSwitch.Value");
            m_RtDataKeys.Add("TM.IoSensor.TMVacSwitch.Value");
            m_RtDataKeys.Add("TM.TMProcessGauge.Value");
            //m_RtDataKeys.Add("TM.TMLidClosed");
            //m_RtDataKeys.Add("TM.LLALidClosed");
            //m_RtDataKeys.Add("TM.LLBLidClosed");

            m_RtDataKeys.Add("TM.PMASlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMBSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMCSlitDoor.IsClosed");
            m_RtDataKeys.Add("TM.PMDSlitDoor.IsClosed");
            m_RtDataKeys.Add("LLA.IsOnline");
            m_RtDataKeys.Add($"TM.LLAPressureGauge.Value");
            m_RtDataKeys.Add($"TM.IoSensor.LLAVacSwitch.Value");
            m_RtDataKeys.Add($"TM.IoSensor.LLAATMSwitch.Value");
            m_RtDataKeys.Add("LLB.IsOnline");
            m_RtDataKeys.Add($"TM.LLBPressureGauge.Value");
            m_RtDataKeys.Add($"TM.IoSensor.LLBVacSwitch.Value");
            m_RtDataKeys.Add($"TM.IoSensor.LLBATMSwitch.Value");
            m_RtDataKeys.Add("LP1.IsLoaded");
            m_RtDataKeys.Add("LP2.IsLoaded");
            m_RtDataKeys.Add("LP3.IsLoaded");
            m_RtDataKeys.Add("LP1.CassettePlaced");
            m_RtDataKeys.Add("LP2.CassettePlaced");
            m_RtDataKeys.Add("LP3.CassettePlaced");
            m_RtDataKeys.Add("LP1.CurrentControlJob");
            m_RtDataKeys.Add("LP2.CurrentControlJob");
            m_RtDataKeys.Add("LP3.CurrentControlJob");
            m_RtDataKeys.Add("EFEM.IsOnline");
            m_RtDataKeys.Add("System.IsAutoMode");
            m_RtDataKeys.Add("System.IsBusy");


            m_RtDataKeys.Add("LP1.CycledCount");
            m_RtDataKeys.Add("LP1.CycledWafer");
            m_RtDataKeys.Add("LP1.CycleSetPoint");
            //m_RtDataKeys.Add("LP1.Throughput");

            m_RtDataKeys.Add("LP2.CycledCount");
            m_RtDataKeys.Add("LP2.CycledWafer");
            m_RtDataKeys.Add("LP2.CycleSetPoint");
            //m_RtDataKeys.Add("LP2.Throughput");

            m_RtDataKeys.Add("LP3.CycledCount");
            m_RtDataKeys.Add("LP3.CycledWafer");
            m_RtDataKeys.Add("LP3.CycleSetPoint");
            //m_RtDataKeys.Add("LP3.Throughput");


            m_RtDataKeys.Add("EquipmentStatus");
            m_RtDataKeys.Add("Scheduler.PjNameList");

            m_RtDataKeys.Add("LLA.CoolingTime");
            m_RtDataKeys.Add("LLB.CoolingTime");


        }
        private void AssociateSequence(WaferAssociationInfo info, bool flag, int slot = -1)
        {
            List<WaferInfo> wafers = info.ModuleData.WaferManager.Wafers;

            if (slot >= 0) //by wafer
            {
                int index = wafers.Count - slot - 1;
                if (index < wafers.Count)
                {
                    if (flag && HasWaferOnSlot(wafers, index))
                        wafers[index].SequenceName = info.SequenceName;
                    else
                        wafers[index].SequenceName = string.Empty;
                }
            }
            else //by from-to
            {
                for (int i = info.SlotFrom - 1; i < info.SlotTo; i++)
                {
                    int index = wafers.Count - i - 1;
                    if (index < wafers.Count)
                    {
                        if (flag && HasWaferOnSlot(wafers, index))
                            wafers[index].SequenceName = info.SequenceName;
                        else
                            wafers[index].SequenceName = string.Empty;
                    }
                }
            }

            switch (info.ModuleData.ModuleID)
            {
                case "LP1":
                    LP1WaferAssociation = info;
                    break;
                case "LP2":
                    LP2WaferAssociation = info;
                    break;
                case "LP3":
                    LP3WaferAssociation = info;
                    break;
            }
        }
        private bool HasWaferOnSlot(List<WaferInfo> wafers, int index)
        {
            if (wafers[index].WaferStatus == 0)
                return false;

            return true;
        }
        public void EnterExitView(bool isEnter)
        {
            if (isEnter)
            {
                Timer_Tick(null, null);
                timer.Start();
            }
            else
            {
                timer.Stop();
            }
        }
        #endregion
    }
}