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

//using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using log4net.Util.TypeConverters;
using MECF.Framework.Common.CommonData.DeviceData;
using MECF.Framework.Common.DataCenter;
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.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;
using WPF.Themes.UserControls;

namespace Venus_MainPages.ViewModels
{
    public class PlatformViewModel : BindableBase
    {
        #region 私有字段
        private bool m_LoadLockDoorIsOpen;
        private bool m_LoadLockPumpValveIsOpen;
        private bool m_LoadLockVentValveIsOpen;
        private bool m_IsATM;
        private string ModuleName="PMA";
        private List<string> m_RtDataKeys=new List<string> ();
        private Dictionary<string, object> m_RtDataValues=new Dictionary<string, object> ();
        private bool m_PumpIsOpen;
        private int m_PurgeCounter;
        private Visibility m_PMAWaferIsVisibility;
        private Visibility m_LLAWaferIsVisibility;
        private PMState m_PMCurrentState;
        private WaferInfo m_LLAWafer;
        private WaferInfo m_PMAWafer;
        private bool m_WaferInPosSensor;

        private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
        private bool m_PVHe1ValveIsOpen;
        private bool m_PVHe2ValveIsOpen;
        private bool m_TurboPumpPumpingValveIsOpen;
        private bool m_TurboPumpPurgeValveIsOpen;
        private bool m_GuageValveIsOpen;
        private bool m_PendulumValveIsOpen;
        private bool m_TurboIsOpen;
        private int m_PositionValue;
        private float m_PendulumValvePosition;
        private float m_ProcessHighPressure;
        private float m_ProcessLowPressure;
        private float m_ForelinePressurePressure;
        private int m_TurboPumpRotationalSpeed;
        private AITMfcData m_MFCN2Data;
        private AITPendulumValveData m_PendulumValveData;
        private int soltCount;
        #endregion

        #region  属性
        public bool WaferInPosSensor
        {
            get { return m_WaferInPosSensor; }
            set 
            {
                if (m_WaferInPosSensor != value)
                {
                    if (value == true && PMCurrentState!=PMState.LLPicking && PMCurrentState != PMState.LLPlacing)
                    {
                        InvokeClient.Instance.Service.DoOperation("CreateWafer", "LLA", 1);
                    }
                    else if (value == false  && PMCurrentState != PMState.LLPicking && PMCurrentState != PMState.LLPlacing)
                    {
                        InvokeClient.Instance.Service.DoOperation("DeleteWafer", "LLA", 1);
                    }
                }
                SetProperty(ref m_WaferInPosSensor, value);
            }
        }

        public WaferInfo LLAWafer
        {
            get { return m_LLAWafer; }
            set { SetProperty(ref m_LLAWafer, value); }
        }
        public WaferInfo PMAWafer
        {
            get { return m_PMAWafer; }
            set { SetProperty(ref m_PMAWafer, value); }
        }
        public bool LoadLockDoorIsOpen
        {
            get { return m_LoadLockDoorIsOpen; }
            set {  SetProperty(ref m_LoadLockDoorIsOpen, value); }
        }
        public bool LoadLockPumpValveIsOpen
        {
            get { return m_LoadLockPumpValveIsOpen; }
            set { SetProperty(ref m_LoadLockPumpValveIsOpen, value); }
        }
        public bool LoadLockVentValveIsOpen
        {
            get { return m_LoadLockVentValveIsOpen; }
            set { SetProperty(ref m_LoadLockVentValveIsOpen, value); }
        }
        public bool IsATM
        {
            get { return m_IsATM; }
            set { SetProperty(ref m_IsATM, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool PumpIsOpen
        {
            get { return m_PumpIsOpen; }
            set { SetProperty(ref m_PumpIsOpen, value); }
        }

        public int PurgeCounter
        {
            get { return m_PurgeCounter; }
            set { SetProperty(ref m_PurgeCounter, value); }
        }
        public Visibility PMAWaferIsVisibility
        {
            get { return m_PMAWaferIsVisibility; }
            set { SetProperty(ref m_PMAWaferIsVisibility, value); }
        }

        public Visibility LLAWaferIsVisibility
        {
            get { return m_LLAWaferIsVisibility; }
            set { SetProperty(ref m_LLAWaferIsVisibility, value); }
        }
        public PMState PMCurrentState
        {
            get { return m_PMCurrentState; }
            set { SetProperty(ref m_PMCurrentState, value); }
        }

        public bool TurboPumpPumpingValveIsOpen
        {
            get { return m_TurboPumpPumpingValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPumpingValveIsOpen, value); }
        }
        public bool TurboPumpPurgeValveIsOpen
        {
            get { return m_TurboPumpPurgeValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPurgeValveIsOpen, value); }
        }
        public bool SoftPumpValveIsOpen
        {
            get { return m_SoftPumpValveIsOpen; }
            set { SetProperty(ref m_SoftPumpValveIsOpen, value); }
        }
        public bool FastPumpValveIsOpen
        {
            get { return m_FastPumpValveIsOpen; }
            set { SetProperty(ref m_FastPumpValveIsOpen, value); }
        }
        public bool GuageValveIsOpen
        {
            get { return m_GuageValveIsOpen; }
            set { SetProperty(ref m_GuageValveIsOpen, value); }
        }

        public bool PendulumValveIsOpen
        {
            get { return m_PendulumValveIsOpen; }
            set { SetProperty(ref m_PendulumValveIsOpen, value); }
        }

        public bool TurboIsOpen
        {
            get { return m_TurboIsOpen; }
            set { SetProperty(ref m_TurboIsOpen, value); }
        }
        public bool PVHe1ValveIsOpen
        {
            get { return m_PVHe1ValveIsOpen; }
            set { SetProperty(ref m_PVHe1ValveIsOpen, value); }
        }
        public bool PVHe2ValveIsOpen
        {
            get { return m_PVHe2ValveIsOpen; }
            set { SetProperty(ref m_PVHe2ValveIsOpen, value); }
        }
        public int PositionValue
        {
            get { return m_PositionValue; }
            set { SetProperty(ref m_PositionValue, value); }
        }
        public float PendulumValvePosition
        {
            get { return m_PendulumValvePosition; }
            set { SetProperty(ref m_PendulumValvePosition, value); }
        }
        public float ProcessHighPressure
        {
            get { return m_ProcessHighPressure; }
            set
            {
                SetProperty(ref m_ProcessHighPressure, value);
            }
        }
        public float ProcessLowPressure
        {
            get { return m_ProcessLowPressure; }
            set
            {
                SetProperty(ref m_ProcessLowPressure, value);
            }
        }
        public float ForelinePressure
        {
            get { return m_ForelinePressurePressure; }
            set
            {
                SetProperty(ref m_ForelinePressurePressure, value);
            }
        }
        public int TurboPumpRotationalSpeed
        {
            get { return m_TurboPumpRotationalSpeed; }
            set
            {
                SetProperty(ref m_TurboPumpRotationalSpeed, value);
            }
        }
        public AITMfcData MFCN2Data
        {
            get { return m_MFCN2Data; }
            set { SetProperty(ref m_MFCN2Data, value); }
        }
        public AITPendulumValveData PendulumValveData
        {
            get { return m_PendulumValveData; }
            set
            {
                SetProperty(ref m_PendulumValveData, value);
            }
        }
        #endregion


        #region 命令
        private DelegateCommand _PurgeCommand;
        public DelegateCommand PurgeCommand =>
            _PurgeCommand ?? (_PurgeCommand = new DelegateCommand(OnPurge));

        private DelegateCommand _VentCommand;
        public DelegateCommand VentCommand =>
            _VentCommand ?? (_VentCommand = new DelegateCommand(OnVent));

        private DelegateCommand _PumpCommand;
        public DelegateCommand PumpCommand =>
            _PumpCommand ?? (_PumpCommand = new DelegateCommand(OnPump));

        private DelegateCommand _OpenPumpCommand;
        public DelegateCommand OpenPumpCommand =>
            _OpenPumpCommand ?? (_OpenPumpCommand = new DelegateCommand(OnOpenPump));

        private DelegateCommand _ClosePumpCommand;
        public DelegateCommand ClosePumpCommand =>
            _ClosePumpCommand ?? (_ClosePumpCommand = new DelegateCommand(OnClosePump));

        private DelegateCommand _OpenDoorCommand;
        public DelegateCommand OpenDoorCommand =>
            _OpenDoorCommand ?? (_OpenDoorCommand = new DelegateCommand(OnOpenDoor));

        private DelegateCommand _CloseDoorCommand;
        public DelegateCommand CloseDoorCommand =>
            _CloseDoorCommand ?? (_CloseDoorCommand = new DelegateCommand(OnCloseDoor));

        private DelegateCommand _NewWaferCommand;
        public DelegateCommand NewWaferCommand =>
            _NewWaferCommand ?? (_NewWaferCommand = new DelegateCommand(OnNewWafer));

        private DelegateCommand _DeleteWaferCommand;
        public DelegateCommand DeleteWaferCommand =>
            _DeleteWaferCommand ?? (_DeleteWaferCommand = new DelegateCommand(OnDeleteWafer));

        private DelegateCommand _PlaceWaferCommand;
        public DelegateCommand PlaceWaferCommand =>
            _PlaceWaferCommand ?? (_PlaceWaferCommand = new DelegateCommand(OnPlaceWafer));

        private DelegateCommand _MoveWaferCommand;
        public DelegateCommand MoveWaferCommand =>
            _MoveWaferCommand ?? (_MoveWaferCommand = new DelegateCommand(OnMoveWafer));

        private DelegateCommand<object> _ControlValveCommand;
        public DelegateCommand<object> ControlValveCommand =>
            _ControlValveCommand ?? (_ControlValveCommand = new DelegateCommand<object>(OnControlValve));

        private DelegateCommand _OpenPendulumValveCommand;
        public DelegateCommand OpenPendulumValveCommand =>
            _OpenPendulumValveCommand ?? (_OpenPendulumValveCommand = new DelegateCommand(OnOpenPendulumValve));

        private DelegateCommand _ClosePendulumValveCommand;
        public DelegateCommand ClosePendulumValveCommand =>
            _ClosePendulumValveCommand ?? (_ClosePendulumValveCommand = new DelegateCommand(OnClosePendulumValve));
        private DelegateCommand _OpenButterflyValveViewCommand;
        //public DelegateCommand OpenButterflyValveViewCommand =>
        //    _OpenButterflyValveViewCommand ?? (_OpenButterflyValveViewCommand = new DelegateCommand(OnOpenButterflyValveView));
        private DelegateCommand _OpenTurboPumpCommand;
        public DelegateCommand OpenTurboPumpCommand =>
            _OpenTurboPumpCommand ?? (_OpenTurboPumpCommand = new DelegateCommand(OnOpenTurboPump));

        #endregion

        #region 构造函数
        public PlatformViewModel()
        {

            //m_PMAWaferIsVisibility = Visibility.Collapsed;
            //m_IsATM = true;
            //var test = RTData.GetRTData().RtDataValues;
            addDataKeys();
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.5);
            timer.Tick += timer_Tick;
            timer.Start();
            soltCount = Convert.ToInt32(QueryDataClient.Instance.Service.GetConfig($"LLA.SlotNumber"));


        }

        #endregion

        #region 命令方法   

        private void OnPump()
        {
            if (PMCurrentState == PMState.PumpingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.PumpLoadLock");
            }
        }
        private void OnPurge()
        {
            if (PMCurrentState == PMState.PurgingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.PurgeLoadLock");

            }
        }

        private void OnVent()
        {
            if (PMCurrentState == PMState.VentingLoadLock)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.VentLoadLock");

            }
        }
        private void OnOpenPump()
        {
            if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "LaunchingPump")
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StartPump");
        }
        private void OnClosePump()
        {
            //InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");

        }
        private void OnOpenDoor()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSlitDoor",true);
            
        }
        private void OnCloseDoor()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SetSlitDoor",false);
        }
        private void OnNewWafer()
        {
            InvokeClient.Instance.Service.DoOperation("CreateWafer", "PMA", 0);
        }

        private void OnDeleteWafer()
        {
            InvokeClient.Instance.Service.DoOperation("DeleteWafer", "PMA", 0);
        }

        private void OnPlaceWafer()
        {
            if (PMCurrentState == PMState.LLPlacing)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.LLPlace}");
            }
        }
        private void OnMoveWafer()
        {
            if (PMCurrentState == PMState.LLPicking)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }
            else
            { 
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.LLPick}");

            }
        }
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", Convert.ToInt32(commonValveControl.Tag.ToString()), !commonValveControl.Status);
            }
        }
        private void OnOpenPendulumValve()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.TurnPendulumValve", true);
        }
        private void OnClosePendulumValve()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.TurnPendulumValve", false);
        }
        private void OnOpenTurboPump()
        {
            //TurboIsOpen = true;
            //if (RtDataValues[$"{ModuleName}.FsmState"].ToString() == "LaunchingTurbo")
            if (PMCurrentState == PMState.LaunchingTurboPump)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
                return;
            }

            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.StartTurboPump");
        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {

            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            LoadLockPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveLoadlockPumping.IsOpen");

            LoadLockVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveLoadlockVent.IsOpen"); 
            PumpIsOpen = (bool)RtDataValues[$"{ModuleName}.PumpIsRunning"];
            PurgeCounter=(int)RtDataValues[$"{ModuleName}.LoadLockPurge.PurgeCounter"];

            LLAWafer = ModuleManager.ModuleInfos["LLA"].WaferManager.Wafers[soltCount-1];
            PMAWafer = ModuleManager.ModuleInfos["PMA"].WaferManager.Wafers[0];
            

            PMCurrentState= (PMState)Enum.Parse(typeof(PMState), RtDataValues[$"{ModuleName}.FsmState"].ToString());

            WaferInPosSensor = (bool)RtDataValues[$"{ModuleName}.SensorSmallWaferInPos.Value"];

            SoftPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveSoftPump.IsOpen");
            FastPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveFastPump.IsOpen");
            GuageValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveGuage.IsOpen");
 
            TurboPumpPumpingValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveTurboPumpPumping.IsOpen");
            TurboPumpPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValveTurboPumpPurge.IsOpen");
            PVHe1ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe1.IsOpen");
            PVHe2ValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.ValvePVHe2.IsOpen");

            PumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.PumpIsRunning");
            TurboIsOpen = CommonFunction.GetValue<bool>(RtDataValues, $"{ModuleName}.TurboPumpIsRunning");
            PendulumValvePosition = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.GetPVPosition");
            PositionValue = -((int)((PendulumValvePosition) * 0.09));

            ProcessHighPressure = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.ProcessHighPressure");
            ProcessLowPressure = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.ProcessLowPressure");
            ForelinePressure = CommonFunction.GetValue<float>(RtDataValues, $"{ModuleName}.ForelinePressure");
            TurboPumpRotationalSpeed = Convert.ToInt32(RtDataValues[$"{ModuleName}.TurboPumpRotationalSpeed"].ToString());
            MFCN2Data = CommonFunction.GetValue<AITMfcData>(RtDataValues, $"{ModuleName}.MfcN2");
            PendulumValveData = CommonFunction.GetValue<AITPendulumValveData>(RtDataValues, $"{ModuleName}.{VenusDevice.PendulumValve}.DeviceData");
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.FsmState");
            m_RtDataKeys.Add($"{ModuleName}.ValveLoadlockPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveLoadlockVent.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.PumpIsRunning");
            m_RtDataKeys.Add($"{ModuleName}.LoadLockPurge.PurgeCounter");
            m_RtDataKeys.Add($"{ModuleName}.IsSlitDoorClosed");
            m_RtDataKeys.Add($"{ModuleName}.LoadlockPressure");
            m_RtDataKeys.Add($"{ModuleName}.ForelinePressure");
            m_RtDataKeys.Add($"{ModuleName}.IsATMLoadlock");
            m_RtDataKeys.Add($"{ModuleName}.IsVACLoadlock");
            m_RtDataKeys.Add($"PMA.HasWafer");
            m_RtDataKeys.Add($"PMA.ModuleWaferList");
            m_RtDataKeys.Add($"LLA.HasWafer");
            m_RtDataKeys.Add($"LLA.ModuleWaferList");
            m_RtDataKeys.Add($"{ModuleName}.SensorSmallWaferInPos.Value");
            m_RtDataKeys.Add($"{ModuleName}.ValveSoftPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveFastPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveN2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPurge.IsOpen");

            m_RtDataKeys.Add($"{ModuleName}.ValveGuage.IsOpen");

            m_RtDataKeys.Add($"{ModuleName}.TurboPumpIsRunning");
            m_RtDataKeys.Add($"{ModuleName}.PumpIsRunning");
            m_RtDataKeys.Add($"{ModuleName}.IsATM");
            m_RtDataKeys.Add($"{ModuleName}.IsVAC");
            m_RtDataKeys.Add($"{ModuleName}.GetPVPosition");
            m_RtDataKeys.Add($"{ModuleName}.TurboPumpRotationalSpeed");
            m_RtDataKeys.Add($"{ModuleName}.MfcN2");
            m_RtDataKeys.Add($"{ModuleName}.{VenusDevice.PendulumValve}.DeviceData");
            m_RtDataKeys.Add($"{ModuleName}.ProcessHighPressure");
            m_RtDataKeys.Add($"{ModuleName}.ProcessLowPressure");

        }

        #endregion
    }
}