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

using Aitex.Sorter.Common;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Schedulers;
using OpenSEMI.ClientBase;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;

namespace Venus_MainPages.ViewModels
{
    public enum SeTMModule
    {
        PMA, PMB, PMC, VCE1, Aligner
    }
    public enum SeTMBlade
    {
        Blade1, Blade2
    }
    internal class SeTMViewModel : BindableBase
    {
        #region 私有字段
        private ModuleInfo m_VCE1ModuleInfo;
        private ModuleInfo m_AlignerModuleInfo;
        private ModuleInfo m_TMModuleInfo;

        //Wafer
        private WaferInfo m_PMAWafer;
        private WaferInfo m_PMBWafer;
        private WaferInfo m_PMCWafer;
        //Door
        private bool m_PMADoorIsOpen;
        private bool m_PMBDoorIsOpen;
        private bool m_PMCDoorIsOpen;
        private bool m_VCE1DoorIsOpen;
        //Pick、Place、Extend、Retract行下拉框内容
        private SeTMModule m_PickSelectedModule;
        private SeTMModule m_PlaceSelectedModule;
        private SeTMModule m_ExtendSelectedModule;
        private SeTMModule m_RetractSelectedModule;
        private SeTMBlade m_PickSelectedBlade;
        private SeTMBlade m_PlaceSelectedBlade;
        private SeTMBlade m_ExtendSelectedBlade;
        private SeTMBlade m_RetractSelectedBlade;

        //Pick、Place、Extend、Retract行下拉框关联
        private ObservableCollection<int> m_PickSoltItemsSource = new ObservableCollection<int>();
        private ObservableCollection<int> m_PlaceSoltItemsSource = new ObservableCollection<int>();
        private ObservableCollection<int> m_ExtendSoltItemsSource = new ObservableCollection<int>();
        private ObservableCollection<int> m_RetractSoltItemsSource = new ObservableCollection<int>();
        private int m_PickSoltSelectedIndex;
        private int m_PlaceSoltSelectedIndex;
        private int m_ExtendSoltSelectedIndex;
        private int m_RetractSoltSelectedIndex;


        //下拉框内容
        private List<SeTMModule> m_TMModules = new List<SeTMModule>();

        private bool m_PMAIsInstalled;
        private bool m_PMBIsInstalled;
        private bool m_PMCIsInstalled;
        private bool m_VCE1IsInstalled;
        private bool m_AlignerIsInstalled;
        private bool m_VCEOutDoorIsOpen;
        private Dictionary<string, object> m_RtDataValues = new Dictionary<string, object>();
        private List<string> m_RtDataKeys = new List<string>();
        #endregion

        #region 属性
        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 bool VCE1DoorIsOpen
        {
            get => m_VCE1DoorIsOpen;
            set
            {
                SetProperty(ref m_VCE1DoorIsOpen,value);
            }
        }

        public bool PMCDoorIsOpen
        {
            get => m_PMCDoorIsOpen;
            set
            {
                SetProperty(ref m_PMCDoorIsOpen, value);
            }
        }

        public bool PMADoorIsOpen
        {
            get { return m_PMADoorIsOpen; }
            set { SetProperty(ref m_PMADoorIsOpen, value); }
        }
        public bool PMBDoorIsOpen
        {
            get { return m_PMBDoorIsOpen; }
            set { SetProperty(ref m_PMBDoorIsOpen, value); }
        }
        public ModuleInfo VCE1ModuleInfo
        {
            get { return m_VCE1ModuleInfo; }
            set
            {
                SetProperty(ref m_VCE1ModuleInfo, value);
            }
        }
        public ModuleInfo AlignerModuleInfo
        {
            get { return m_AlignerModuleInfo; }
            set
            {
                SetProperty(ref m_AlignerModuleInfo, value);
            }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }

        public bool VCEOutDoorIsOpen { get => m_VCEOutDoorIsOpen; set => SetProperty(ref m_VCEOutDoorIsOpen, 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 VCE1IsInstalled
        {
            get { return m_VCE1IsInstalled; }
            set { SetProperty(ref m_VCE1IsInstalled, value); }
        }
        public bool AlignerIsInstalled
        {
            get { return m_AlignerIsInstalled; }
            set { SetProperty(ref m_AlignerIsInstalled, value); }
        }

        public List<SeTMModule> TMModules
        {
            get { return m_TMModules; }
            set { SetProperty(ref m_TMModules, value); }
        }

        //Module属性
        public SeTMModule PickSelectedModule
        {
            get { return m_PickSelectedModule; }
            set { SetProperty(ref m_PickSelectedModule, value); }
        }
        public SeTMModule PlaceSelectedModule
        {
            get { return m_PlaceSelectedModule; }
            set { SetProperty(ref m_PlaceSelectedModule, value); }
        }
        public SeTMModule ExtendSelectedModule
        {
            get { return m_ExtendSelectedModule; }
            set { SetProperty(ref m_ExtendSelectedModule, value); }
        }
        public SeTMModule RetractSelectedModule
        {
            get { return m_RetractSelectedModule; }
            set { SetProperty(ref m_RetractSelectedModule, value); }
        }
        public ModuleInfo TMModuleInfo
        {
            get { return m_TMModuleInfo; }
            set
            {
                SetProperty(ref m_TMModuleInfo, value);
            }
        }
        //Blade属性
        public SeTMBlade PickSelectedBlade
        {
            get { return m_PickSelectedBlade; }
            set { SetProperty(ref m_PickSelectedBlade, value); }
        }
        public SeTMBlade PlaceSelectedBlade
        {
            get { return m_PlaceSelectedBlade; }
            set { SetProperty(ref m_PlaceSelectedBlade, value); }
        }
        public SeTMBlade ExtendSelectedBlade
        {
            get { return m_ExtendSelectedBlade; }
            set { SetProperty(ref m_ExtendSelectedBlade, value); }
        }
        public SeTMBlade RetractSelectedBlade
        {
            get { return m_RetractSelectedBlade; }
            set { SetProperty(ref m_RetractSelectedBlade, value); }
        }
        public ObservableCollection<int> PickSoltItemsSource
        {
            get { return m_PickSoltItemsSource; }
            set { SetProperty(ref m_PickSoltItemsSource, value); }
        }
        public ObservableCollection<int> PlaceSoltItemsSource
        {
            get { return m_PlaceSoltItemsSource; }
            set { SetProperty(ref m_PlaceSoltItemsSource, value); }
        }
        public ObservableCollection<int> ExtendSoltItemsSource
        {
            get { return m_ExtendSoltItemsSource; }
            set { SetProperty(ref m_ExtendSoltItemsSource, value); }
        }
        public ObservableCollection<int> RetractSoltItemsSource
        {
            get { return m_RetractSoltItemsSource; }
            set { SetProperty(ref m_RetractSoltItemsSource, value); }
        }
        public int PickSoltSelectedIndex
        {
            get { return m_PickSoltSelectedIndex; }
            set { SetProperty(ref m_PickSoltSelectedIndex, value); }
        }
        public int PlaceSoltSelectedIndex
        {
            get { return m_PlaceSoltSelectedIndex; }
            set { SetProperty(ref m_PlaceSoltSelectedIndex, value); }
        }
        public int ExtendSoltSelectedIndex
        {
            get { return m_ExtendSoltSelectedIndex; }
            set { SetProperty(ref m_ExtendSoltSelectedIndex, value); }
        }
        public int RetractSoltSelectedIndex
        {
            get { return m_RetractSoltSelectedIndex; }
            set { SetProperty(ref m_RetractSoltSelectedIndex, value); }
        }


        #endregion

        #region 命令
        //模块下拉框选择命令
        private DelegateCommand<object> _ModuleChangeCommand;
        public DelegateCommand<object> ModuleChangeCommand =>
            _ModuleChangeCommand ?? (_ModuleChangeCommand = new DelegateCommand<object>(OnModuleChange));
        //Pick按钮命令
        private DelegateCommand _PickCommand;
        public DelegateCommand PickCommand =>
            _PickCommand ?? (_PickCommand = new DelegateCommand(OnPick));
        //Place按钮命令
        private DelegateCommand _PlaceCommand;
        public DelegateCommand PlaceCommand =>
            _PlaceCommand ?? (_PlaceCommand = new DelegateCommand(OnPlace));
        //Extend按钮命令
        private DelegateCommand _ExtendCommand;
        public DelegateCommand ExtendCommand =>
            _ExtendCommand ?? (_ExtendCommand = new DelegateCommand(OnExtend));
        //Retract按钮命令
        private DelegateCommand _RetractCommand;
        public DelegateCommand RetractCommand =>
            _RetractCommand ?? (_RetractCommand = new DelegateCommand(OnRetract));
        //RobotHome按钮命令
        public DelegateCommand _RobotHomeCommand;
        public DelegateCommand RobotHomeCommand =>
            _RobotHomeCommand ?? (_RobotHomeCommand = new DelegateCommand(OnRobotHome));
        #endregion

        #region 构造函数
        public SeTMViewModel()
        {
            string allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString();
            PMAIsInstalled = allModules.Contains("PMA");
            PMBIsInstalled = allModules.Contains("PMB");
            PMCIsInstalled = allModules.Contains("PMC");
            VCE1IsInstalled = allModules.Contains("VCE1");
            AlignerIsInstalled = allModules.Contains("VPA");
            if (PMAIsInstalled == true)
            {
                TMModules.Add(SeTMModule.PMA);
            }
            if (PMBIsInstalled == true)
            {
                TMModules.Add(SeTMModule.PMB);
            }
            if (PMCIsInstalled == true)
            {
                TMModules.Add(SeTMModule.PMC);
            }
            if (VCE1IsInstalled == true)
            {
                TMModules.Add(SeTMModule.VCE1);
            }
            if (AlignerIsInstalled == true)
            {
                TMModules.Add(SeTMModule.Aligner);
            }

            PickSoltItemsSource.Add(1);
            PlaceSoltItemsSource.Add(1);
            ExtendSoltItemsSource.Add(1);
            RetractSoltItemsSource.Add(1);


            addDataKeys();
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

            VCE1DoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESlitDoorClosed");
            PMADoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMASlitDoorClosed");
            PMBDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMBSlitDoorClosed");
            PMCDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMCSlitDoorClosed");
            VCEOutDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "VCE1.VCEOutDoorClosed");
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.5);
            timer.Tick += Timer_Tick;
            timer.Start();

        }
        #endregion

        #region 命令方法
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"SETM.VCESlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMASlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMBSlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMCSlitDoorClosed");
            m_RtDataKeys.Add($"VCE1.VCEOutDoorClosed");

        }
        //模块选择根据obj选择下拉框内容
        private void OnModuleChange(object obj)
        {
            var value = obj.ToString();
            switch (value)
            {
                case "Pick":
                    PickSoltItemsSource.Clear();
                    if ((int)PickSelectedModule == 3)
                    {
                        for (int i = 1; i <= 25; i++)
                        {
                            PickSoltItemsSource.Add(i);
                        }
                    }
                    else
                    {
                        PickSoltItemsSource.Add(1);

                    }
                    PickSoltSelectedIndex = 0;
                    break;
                case "Place":
                    PlaceSoltItemsSource.Clear();
                    if ((int)PlaceSelectedModule == 3)
                    {
                        for (int i = 1; i <= 25; i++)
                        {
                            PlaceSoltItemsSource.Add(i);
                        }
                    }
                    else
                    {
                        PlaceSoltItemsSource.Add(1);

                    }
                    PlaceSoltSelectedIndex = 0;
                    break;
                case "Extend":
                    ExtendSoltItemsSource.Clear();
                    if ((int)ExtendSelectedModule == 3)
                    {
                        for (int i = 1; i <= 25; i++)
                        {
                            ExtendSoltItemsSource.Add(i);
                        }
                    }
                    else
                    {
                        ExtendSoltItemsSource.Add(1);

                    }
                    ExtendSoltSelectedIndex = 0;
                    break;
                case "Retract":
                    RetractSoltItemsSource.Clear();
                    if ((int)RetractSelectedModule == 3)
                    {
                        for (int i = 1; i <= 25; i++)
                        {
                            RetractSoltItemsSource.Add(i);
                        }
                    }
                    else
                    {
                        RetractSoltItemsSource.Add(1);

                    }
                    RetractSoltSelectedIndex = 0;
                    break;

            }

        }
        private void OnPick()
        {
            Queue<MoveItem> moveItems = new Queue<MoveItem>();
            var moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), PickSelectedModule.ToString(), true);
            var selectedHand = (Hand)Enum.Parse(typeof(Hand), PickSelectedBlade.ToString(), true);
            MoveItem moveItem = new MoveItem(moduleName, PickSoltItemsSource[PickSoltSelectedIndex] - 1, ModuleName.TMRobot, 0, selectedHand);
            moveItems.Enqueue(moveItem);
            //var moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), PickSelectedModule.ToString(), true);
            //var selectedHand = (Hand)Enum.Parse(typeof(Hand), PickSelectedBlade.ToString(), true);
            if ((int)PickSelectedModule < TMModules.Count - 2)
            {
                InvokeClient.Instance.Service.DoOperation($"SETM.PMPick", moveItems);
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"SETM.Pick", moveItems);
            }

        }
        private void OnPlace()
        {
            Queue<MoveItem> moveItems = new Queue<MoveItem>();
            var moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), PlaceSelectedModule.ToString(), true);
            var selectedHand = (Hand)Enum.Parse(typeof(Hand), PlaceSelectedBlade.ToString(), true);
            MoveItem moveItem = new MoveItem( ModuleName.TMRobot, 0, moduleName, PlaceSoltItemsSource[PickSoltSelectedIndex] - 1, selectedHand);
            moveItems.Enqueue(moveItem);
            if ((int)PickSelectedModule < TMModules.Count - 2)
            {
                InvokeClient.Instance.Service.DoOperation($"SETM.PMPlace", moveItems);
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"SETM.Place", moveItems);
            }
        }
        private void OnExtend()
        {
            var moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), ExtendSelectedModule.ToString(), true);
            var selectedHand = (Hand)Enum.Parse(typeof(Hand), ExtendSelectedBlade.ToString(), true);
            InvokeClient.Instance.Service.DoOperation($"SETM.Extend", moduleName, ExtendSoltItemsSource[ExtendSoltSelectedIndex] - 1, selectedHand);
        }
        private void OnRetract()
        {
            //Queue<MoveItem> moveItems = new Queue<MoveItem>();
            var moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), RetractSelectedModule.ToString(), true);
            var selectedHand = (Hand)Enum.Parse(typeof(Hand), RetractSelectedBlade.ToString(), true);
            //MoveItem moveItem = new MoveItem(moduleName, RetractSoltItemsSource[PickSoltSelectedIndex] - 1, 0, 0, selectedHand);
            //moveItems.Enqueue(moveItem);
            InvokeClient.Instance.Service.DoOperation($"SETM.Retract", moduleName, RetractSoltItemsSource[PlaceSoltSelectedIndex] - 1, selectedHand);
        }
        //令选择的模块下发Home指令
        private void OnRobotHome()
        {
            InvokeClient.Instance.Service.DoOperation($"SETM.RobotHome");
        }
        #endregion

        #region 私有方法
        private void Timer_Tick(object sender, EventArgs e)
        {
            TMModuleInfo = ModuleManager.ModuleInfos["TMRobot"];
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            VCE1DoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESlitDoorClosed");
            PMADoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMASlitDoorClosed");
            PMBDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMBSlitDoorClosed");
            PMCDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMCSlitDoorClosed");
            VCEOutDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "VCE1.VCEOutDoorClosed");
        }
        #endregion
    }

}