Kepler-Release/Venus/Venus_RT/Devices/JetPMBase.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using System.Collections.Generic;
using Venus_Core;
using Aitex.Core.RT.Device.Unit;
using Venus_RT.Modules;
using System;
using Aitex.Core.RT.SCCore;
using System.Threading.Tasks;

namespace Venus_RT.Devices
{
    abstract class JetPMBase : BaseDevice, IDevice
    {
        // 盖子的状态
        public abstract bool IsLidClosed { get; }
        public virtual bool IsLidLoadlockClosed { get; }

        public abstract bool IsSlitDoorClosed { get; }

        public abstract bool IsPumpRunning { get; }
        public abstract bool IsTurboPumpRunning { get; }
        public abstract bool IsTurboPumpAtSpeed { get; }
        public abstract float TurboPumpSpeed { get; }
        public abstract bool HasPumpError { get; }

        public abstract bool HasTurboPumpError { get; }

        public abstract bool IsCDA_OK { get; }

        public abstract bool IsFastPumpOpened { get; }
        public abstract bool IsSoftPumpOpened { get; }
        public abstract bool IsMfc1ValveOpened { get; }
        public abstract bool IsMfc2ValveOpened { get; }
        public abstract bool IsMfc3ValveOpened { get; }
        public abstract bool IsMfc4ValveOpened { get; }
        public abstract bool IsMfc5ValveOpened { get; }
        public abstract bool IsMfc6ValveOpened { get; }
        public abstract bool IsMfc7ValveOpened { get; }
        public abstract bool IsMfc8ValveOpened { get; }
        public abstract bool IsGuageValveOpened { get; }

        public abstract bool IsATM { get; }

        public abstract bool PVN22ValveIsOpen { get; }
        public abstract bool LiftPinIsDown { get; }
        public abstract bool LiftPinIsUp { get; }

        public abstract bool IsATMLoadlock { get; }
        public abstract bool IsVACLoadLock { get; }
        public abstract bool IsVAC { get; }
        public abstract bool IsWaterFlowOk { get; }
        public abstract bool IsWLK { get; }
        public abstract bool IsRFGInterlockOn { get; }

        public abstract bool PMLidClosed { get; }
        public abstract bool TurboPumpInterlock { get; }
        public virtual bool SourceRFFanInterlock { get; }
        public virtual bool SourceRFMatchInterlock { get; }

        public abstract bool SlitDoorClosed { get; }

        public abstract double ProcessLowPressure { get; }
        public abstract double ProcessHighPressure { get; }
        public abstract double ProcessPressure { get; }
        public abstract double ChamberPressure { get; }
        public virtual double CalculationPressure { get; }
        public abstract double ForelinePressure { get; }
        public abstract double TargetPressure { get; }
        public virtual double ESCHePressure { get; }

        public virtual int ESCOutputVoltage { get; }
        public virtual double ESCPositiveOutputCurrent { get; }//R+
        public virtual double ESCNegativeOutputCurrent { get; }//R-

        public virtual bool IsHVOn { get; }

        public abstract float CoolantInletTempFB { get; }
        public abstract float CoolantOutletTempFB { get; }
        public abstract bool ChillerIsRunning { get; }
        //Loadlock_Arm
        public virtual bool IsLoadlockArmRetract { get; }
        public virtual bool IsLoadlockArmExtend { get; }
        //Loadlock_Arm DO
        public virtual bool LoadlockArmRetract { get; }
        public virtual bool LoadlockArmExtend { get; }

        public abstract float ReflectPower { get; }
        public virtual float BiasReflectPower { get; }

        public virtual float ForwardPower { get; }
        public virtual float BiasForwardPower { get; }

        public abstract bool BackSideHeOutOfRange { get; }

        public abstract float RFMatchC1 { get; }
        public abstract float RFMatchC2 { get; }
        public virtual float BiasRFMatchC1 { get; }
        public virtual float BiasRFMatchC2 { get; }

        public new ModuleName Module;

        public abstract MovementPosition LiftPinPosition { get; }

        public abstract bool CheckAtm();
        public abstract bool CheckSlitDoorOpen();

        public abstract bool CheckSlitDoorClose();

        public abstract bool CheckLiftUp();

        public abstract bool CheckLiftDown();
        public abstract double TotalGasSetpoint { get; }

        public abstract bool HasGasOutOfRange { get; }
        public abstract bool PendulumValveIsOpen();

        public abstract double LoadlockPressure { get; }

        public virtual double MFC1FeedBack { get; }
        public virtual double MFC2FeedBack { get; }
        public virtual double MFC3FeedBack { get; }
        public virtual double MFC4FeedBack { get; }
        public virtual double MFC5FeedBack { get; }
        public virtual double MFC6FeedBack { get; }
        public virtual double MFC7FeedBack { get; }
        public virtual double MFC8FeedBack { get; }


        public double TMPressure { get { return Singleton<RouteManager>.Instance.TM.TMPressure; } }

        public bool IsTMATM
        {
            get
            {
                if (Singleton<RouteManager>.Instance.TM != null)
                {
                    return Singleton<RouteManager>.Instance.TM.IsTMATM;
                }
                else
                {
                    return Singleton<RouteManager>.Instance.seTM.TMIsATM;
                }
            }
        }

        public bool IsTMVAC
        {
            get
            {
                if (Singleton<RouteManager>.Instance.TM != null)
                {
                    return Singleton<RouteManager>.Instance.TM.IsTMVac;
                }
                else
                {
                    return Singleton<RouteManager>.Instance.seTM.TMIsVAC;
                }
            }
        }

        // EndPoint 
        private readonly JetEPDBase _epdClient;
        public List<string> EPDCfgList => _epdClient?.CFGFileList;

        //public List<string> EPDCfgList=new List<string>() { "1","2"};
        public bool EPDCaptured => _epdClient.Captured;
        public bool EPDConnected => _epdClient.IsEPDConnected;

        public JetChamber ChamberType = JetChamber.None;

        public JetPMBase(ModuleName module) : base(module.ToString(), module.ToString(), module.ToString(), module.ToString())
        {
            Module = module;

            _epdClient = DEVICE.GetDevice<JetEPDBase>($"{Module}.{VenusDevice.EndPoint}");
            ChamberType = (JetChamber)SC.GetValue<int>($"{Module}.ChamberType");
            DATA.Subscribe($"{Name}.ForelinePressure", () => ForelinePressure);
            DATA.Subscribe($"{Name}.ProcessHighPressure", () => ProcessHighPressure);
            DATA.Subscribe($"{Name}.ProcessLowPressure", () => ProcessLowPressure);
            DATA.Subscribe($"{Name}.CalculationPressure", () => CalculationPressure);

            DATA.Subscribe($"{Name}.ESCHePressure", () => ESCHePressure);
            DATA.Subscribe($"{Name}.LoadlockPressure", () => LoadlockPressure);

            DATA.Subscribe($"{Name}.IsATM", () => IsATM, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsVAC", () => IsVAC, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.LiftPinIsUp", () => LiftPinIsUp, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.LiftPinIsDown", () => LiftPinIsDown, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.PumpIsRunning", () => IsPumpRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.TurboPumpIsRunning", () => IsTurboPumpRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsSlitDoorClosed", () => IsSlitDoorClosed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsLidClosed", () => IsLidClosed, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Name}.TurboPumpRotationalSpeed", () => TurboPumpSpeed);

            DATA.Subscribe($"{Name}.IsWaterFlowOk", () => IsWaterFlowOk, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsWLK", () => IsWLK, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsCDA_OK", () => IsCDA_OK, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.SourceRFFanInterlock", () => SourceRFFanInterlock, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.SourceRFMatchInterlock", () => SourceRFMatchInterlock, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Name}.IsTurboPumpInterlock", () => TurboPumpInterlock, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Name}.IsATMLoadlock", () => IsATMLoadlock, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsVACLoadlock", () => IsVACLoadLock, SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Name}.GetPVPosition", () => GetPVPosition());

            DATA.Subscribe($"{Name}.ESCHV.Temp", () => CoolantOutletTempFB);
            DATA.Subscribe($"{Name}.Chiller.Temp", () => CoolantInletTempFB);

            //DATA.Subscribe($"{Name}.Chiller.IsOn", () => ChillerIsRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Name}.IsTurboPumpAtSpeed", () => IsTurboPumpAtSpeed);
            DATA.Subscribe($"{Name}.EPDCfgList", () => EPDCfgList, SubscriptionAttribute.FLAG.IgnoreSaveDB);



            OP.Subscribe($"{Module}.SetLiftPin", (cmd, args) =>
            {
                if ((bool)args[0] == true)
                {
                    return SetLiftPin(MovementPosition.Up, out _);
                }
                else
                {
                    return SetLiftPin(MovementPosition.Down, out _);
                }

            });

            OP.Subscribe($"{Module}.SetSRf", (cmd, args) =>
            {
                var ison = (bool)args[1];
                if (ison == true)
                {
                    GeneratorPowerOn(true);

                    GeneratorSetpower((float)args[0]);


                }
                else
                {
                    GeneratorPowerOn(false);
                }
                return true;
            });

            OP.Subscribe($"{Module}.SetBRf", (cmd, args) =>
            {

                var ison = (bool)args[1];
                if (ison == true)
                {
                    GeneratorBiasPowerOn(true);

                    GeneratorBiasSetpower((float)args[0]);
                }
                else
                {
                    GeneratorBiasPowerOn(false);
                }
                return true;
            });


            OP.Subscribe($"{Module}.SetSlitDoor", (cmd, args) =>
            {
                SetSlitDoor((bool)args[0], out _);
                return true;
            });

            OP.Subscribe($"{Module}.SetESCHVIsOn", (cmd, args) =>
            {
                OnOffSetESCHV((bool)args[0]);
                return true;
            });
            OP.Subscribe($"{Module}.SetESCHV", (cmd, args) =>
            {
                SetESCClampVoltage((int)args[0]);
                return true;
            });

            OP.Subscribe($"{Module}.SetPVPostion", (cmd, args) =>
            {
                SetPVPostion((int)args[0]);
                return true;
            });

            OP.Subscribe($"{Module}.SetPVPressure", (cmd, args) =>
            {
                SetPVPressure((int)args[0]);
                return true;
            });

            OP.Subscribe($"{Module}.ClosePump", (cmd, args) =>
            {
                TurnDryPump(false);
                return true;
            });
            OP.Subscribe($"{Module}.CloseTurboPump", (cmd, args) =>
            {
                TurnTurboPump(false);
                return true;
            });
            OP.Subscribe($"{Module}.ControlValve", (cmd, args) =>
            {
                if (ChamberType == JetChamber.VenusSE|| ChamberType == JetChamber.VenusDE)
                {
                    if (Enum.TryParse(args[0].ToString(), out ValveType targetvalve))
                    {
                        OpenValve(targetvalve, (bool)args[1]);
                    }
                }
                else
                {
                    OpenValve((ValveType)((int)args[0]), (bool)args[1]);
                }
                return true;
            });

            OP.Subscribe($"{Module}.TurnPendulumValve", (cmd, args) =>
            {
                TurnPendulumValve((bool)args[0]);
                return true;
            });

            OP.Subscribe($"{Module}.HeatChiller", (cmd, args) =>
            {
                var chillerType = (ChillerType)Enum.Parse(typeof(ChillerType), args[0].ToString());
                HeatChiller(chillerType, (float)args[1], (float)args[2]);
                return true;
            });
            OP.Subscribe($"{Module}.OnOffChiller", (cmd, args) =>
            {
                var chillerType = (ChillerType)Enum.Parse(typeof(ChillerType), args[0].ToString());
                var ison = Convert.ToBoolean(args[1]);
                OnOffChiller(chillerType, ison);
                return true;
            });
            OP.Subscribe($"{Module}.WallChiller", (cmd, args) =>
            {
                float value;
                float.TryParse(args[0].ToString(), out value);
                SetWallTCTemperature(value);
                return true;
            });
            OP.Subscribe($"{Module}.SetBacksideHeFlow", (cmd, args) =>
            {
                double value;
                double.TryParse(args[0].ToString(), out value);
                SetBacksideHeFlow(value);
                return true;
            });
            OP.Subscribe($"{Module}.SetBacksideHePressure", (cmd, args) =>
            {
                float value;
                float.TryParse(args[0].ToString(), out value);
                SetBacksideHePressure(value);
                return true;
            });
            OP.Subscribe($"{Module}.EndPoint.SearchCfg", (cmd, args) =>
            {
                _epdClient?.QueryConfigList();
                return true;
            });
        }

        public abstract void CloseValves(int? delayTime=null);


        public abstract void TurnDryPump(bool on);

        public abstract void TurnTurboPump(bool on);

        public abstract void OpenValve(ValveType vlvType, bool on);

        public virtual void Monitor()
        {

        }
        public virtual bool Initialize()
        {
            return true;
        }
        public virtual void Terminate()
        {

        }

        public virtual void Reset()
        {

        }

        public virtual bool OnOffSetESCHV(bool on)
        {
            return false;
        }

        public abstract bool SetWallTCTemperature(float value);
        protected abstract void CheckPermanentInterlock();

        public abstract void CheckIdleInterlock();

        public virtual void BuzzerBlinking(double time)
        { 
        
        }

        public virtual void SwitchOnBuzzerAndRed()
        { 
        
        }

        public abstract void Home();

        public virtual bool SetLiftPin(MovementPosition dirt, out string reason)
        {
            reason = "";
            return false;
        }

        public abstract bool SetSlitDoor(bool open, out string reason);

        public virtual bool RetractWafer()
        {
            return false;
        }

        public virtual bool ExtendWafer()
        { 
            return false;
        }
        public abstract bool FlowGas(int gasNum, double val);

        public abstract bool StopGas(int gasNum);

        public abstract bool FlowN2(double val);

        public abstract bool StopN2();

        public abstract void StopAllGases();

        public abstract bool TurnPendulumValve(bool on);

        public abstract bool SetPVPressure(int pressure);

        public abstract bool SetPVPostion(int position);

        public abstract int GetPVPosition();

        public virtual void HeatChiller(ChillerType chillerType, double value, double offset)
        {
            
        }

        public virtual void OnOffChiller(ChillerType chillerType, bool onoff)
        {

        }

        public virtual bool CheckChillerStatus()
        {
            return false;
        }


        public abstract void SetGeneratorCommunicationMode(int mode);

        public abstract bool GeneratorPowerOn(bool on);

        public abstract bool GeneratorSetpower(float val);

        public virtual bool GeneratorBiasPowerOn(bool on)
        { return false; }

        public virtual bool GeneratorBiasSetpower(float val)
        { return false; }

        public virtual bool GeneratorBiasSetMatchMode(bool val)
        { return false; }

        public abstract bool SetMatchPosition(float c1, float c2);

        public virtual bool SetBiasMatchPosition(float c1, float c2)
        { return false; }

        public virtual bool SetMatchWorkMode(MatchWorkMode matchWorkMode)
        {
            return false;
        }
        public virtual bool SetBiasMatchWorkMode(MatchWorkMode matchWorkMode)
        {
            return false;
        }

        public virtual bool SetBiasPulseMode(bool on)
        { return false; }
        public virtual bool SetBiasPulseRateFreq(int nFreq)
        {
            return false;
        }

        public virtual bool SetDiasPulseDutyCycle(int percentage)
        {
            return false;
        }

        public virtual bool SetESCClampVoltage(int nVoltage)
        {
            return false;
        }

        public abstract bool CheckGeneratorAndHVInterlock(VenusDevice device);



        #region EndPoint
        public void EPDRecipeStart(string recipe)
        {
            try
            {
                _epdClient?.RecipeStart(recipe);
            }
            catch
            {
            }
        }

        public void EPDRecipeStop()
        {
            try
            {
                _epdClient?.RecipeStop();
            }
            catch
            {
            }

        }

        public void EPDStepStart(string cfgName, int step)
        {
            try
            {
                _epdClient?.StepStart(cfgName, step);
            }
            catch
            {
            }
        }

        public void EPDStepStop()
        {
            try
            {
                _epdClient?.StepStop();
            }
            catch
            {
            }
        }

        #endregion

        public virtual void SetBacksideHeFlow(double flow)
        {
        }

        public virtual bool SetBacksideHePressure(float mTorr)
        {
            return false;
        }

        public abstract bool SetBacksideHeThreshold(int nMin, int nMax);
        public virtual bool HighTemperatureHeaterGotoPosition(HighTemperatureHeaterPosition highTemperatureHeaterPosition)
        {
            return false;
        }
        public virtual bool SetHighTemperatureHeaterRate(int rate)
        {
            return false;
        }
        public virtual bool StartControlPressure(int pressureSetpoint, int flowSetpoint)
        {
            return false;
        }
        public virtual async Task<bool> AbortControlPressure()
        {
            return false;
        }
        public virtual bool PreparePlace()
        {
            return false;
        }
        public virtual bool PreparePlaceIsOK()
        {
            return false;
        }
        public virtual bool PreparePick()
        {
            return false;
        }

        public virtual bool PreparePickIsOK()
        {
            return false;
        }
        public virtual bool EndPlace()
        {
            return false;
        }
        public virtual bool EndPlaceIsOK()
        {
            return false;
        }
        public virtual bool EndPick()
        {
            return false;
        }
        public virtual bool EndPickIsOK()
        {
            return false;
        }
        public virtual void RTCloseEvent()
        { 
        
        }
        public virtual bool RFInterlock(VenusDevice device)
        {
            return true;
        }
    }
}