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 FabConnect.SecsGemInterface.Application.Objects.ProcessManagement;

namespace Venus_RT.Devices
{
    abstract class JetPMBase : BaseDevice, IDevice
    {
        // 盖子的状态
        public abstract bool IsLidClosed { get; }
        public abstract 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 abstract bool SourceRFFanInterlock { 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 abstract double ForelinePressure { get; }
        public abstract double TargetPressure { get; }
        public abstract double ESCHePressure { get; }

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

        public abstract bool IsHVOn { get; }

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

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

        public abstract bool BackSideHeOutOfRange { 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 double TMPressure { get { return Singleton<RouteManager>.Instance.TM.TMPressure; } }

        public bool IsTMATM { get { return Singleton<RouteManager>.Instance.TM.IsTMATM; } }

        public bool IsTMVAC { get { return Singleton<RouteManager>.Instance.TM.IsTMVac; } }

        // 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 JetPMBase(ModuleName module) :  base(module.ToString(), module.ToString(), module.ToString(), module.ToString())
        {
            Module = module;

            _epdClient = DEVICE.GetDevice<JetEPDBase>($"{Module}.{VenusDevice.EndPoint}");

            DATA.Subscribe($"{Name}.ForelinePressure", () => ForelinePressure);
            DATA.Subscribe($"{Name}.ProcessHighPressure", () => ProcessHighPressure);
            DATA.Subscribe($"{Name}.ProcessLowPressure", () => ProcessLowPressure);
            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}.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) => {
                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();


        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 abstract bool OnOffSetESCHV(bool on);

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

        public abstract void CheckIdleInterlock();

        public abstract void BuzzerBlinking(double time);

        public abstract void SwitchOnBuzzerAndRed();

        public abstract void Home();

        public abstract bool SetLiftPin(MovementPosition dirt, out string reason);

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

        public abstract bool RetractWafer();

        public abstract bool ExtendWafer();
        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 abstract  void HeatChiller(ChillerType chillerType,double value, double offset);

        public abstract void OnOffChiller(ChillerType chillerType,bool onoff);

        public abstract bool CheckChillerStatus();


        public abstract void SetGeneratorCommunicationMode(int mode);

        public abstract bool GeneratorPowerOn(bool on);

        public abstract bool GeneratorSetpower(float val);

        public abstract bool GeneratorBiasPowerOn(bool on);

        public abstract bool GeneratorBiasSetpower(float val);

        public abstract bool GeneratorBiasSetMatchMode(bool val);

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

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

        public abstract bool SetBiasPulseMode(bool on);
        public abstract bool SetBiasPulseRateFreq(int nFreq);

        public abstract bool SetDiasPulseDutyCycle(int percentage);

        public abstract bool SetESCClampVoltage(int nVoltage);

        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 abstract void SetBacksideHeFlow(double flow);

        public abstract bool SetBacksideHePressure(float mTorr);

        public abstract bool SetBacksideHeThreshold(int nMin, int nMax);

       
    }
}