using System; using System.Collections.Generic; using Aitex.Core.Common; using Aitex.Core.RT.DataCenter; using Aitex.Core.RT.Device; using Aitex.Core.RT.Event; using Aitex.Core.RT.Fsm; using Aitex.Core.RT.OperationCenter; using Aitex.Core.RT.SCCore; using Aitex.Core.Util; using Aitex.Sorter.Common; using MECF.Framework.Common.Equipment; using MECF.Framework.Common.Schedulers; using MECF.Framework.Common.SubstrateTrackings; using Venus_Core; using Venus_RT.Devices; using Aitex.Core.RT.Log; using Aitex.Core.UI.DeviceControl; namespace Venus_RT.Modules.PMs { public class RecipeRunningInfo { public Guid InnerId { get; set; } public RecipeHead Head { get; set; } public List RecipeStepList { get; set; } public string RecipeName { get; set; } public DateTime BeginTime { get; set; } public DateTime EndTime { get; set; } public int StepNumber { get; set; } public string StepName { get; set; } public double StepTime { get; set; } public double StepElapseTime { get; set; } public double TotalTime { get; set; } public double TotalElapseTime { get; set; } } public class PMEntity : Entity, IModuleEntity { public enum PMStatus { Not_Ready, Ready_For_Pick, Ready_For_Place, Exchange_Ready, } public enum MSG { Home, Transfer, PrepareTransfer, PostTransfer, Reset, Abort, Error, LaunchPump, LaunchTurboPump, Pump, Vent, PumpLoadLock, VentLoadLock, PurgeLoadLock, LoadLockLeakCheck, CyclePurge, GasLinePurge, Heat, TransferHandoff, StartTransfer, LeakCheck, GasLeakCheck, MoveLiftPin, MoveGuidePin, PartialPressure, VATPerformance, LLPlace, LLPick, Process, RunRecipe, PostProcess, RecipeSkipStep, RecipeUpdate, RecipeResume, RecipePause, RecipeAbort, PreProcess, AutoMode, ManualMode, LockLid, Clean, Online, Offline, GasFlow, StopGasFlow, RfPower, MFCVerification, // exchange wafer with TM PreparePick, PreparePlace, LiftUpWafer, DropDownWafer, PickReady, PlaceReady, MaxMsg } private readonly JetPMBase _chamber; public ModuleName Module { get; } public PMStatus Status { get; private set; } private readonly PMHomeRoutine _home; private readonly StartDryPumpRoutine _startDryPumpRoutine; private readonly StartTurboPumpRoutine _startTurboPumpRoutine; private readonly VentRoutine _ventRoutine; private readonly PumpDownRoutine _pumpRoutine; private readonly LoadLockVentRoutine _ventLoadLockRoutine; private readonly LoadLockPumpRoutine _pumpLoadLockRoutine; private readonly LoadLockPurgeRoutine _purgeLoadLockRoutine; private readonly LoadLockLeakCheckRoutine _loadLockLeakCheckRoutine; private readonly PMPurgeRoutine _purgeRoutine; private readonly PMGaslinePurgeRoutine _gaslinePurgeRoutine; private readonly PMLeakCheckRoutine _leakCheckRoutine; private readonly GasBoxLeakCheckRoutine _gasBoxLeakCheckRoutine; private readonly LLPlaceRoutine _llPlaceRoutine; private readonly LLPickRoutine _llPickRoutine; private readonly PMProcessRoutine _processRoutine; private readonly GasFlowRoutine _gasFlowRoutine; private readonly RFPowerSwitchRoutine _rfPowerRoutine; private readonly PMGasVerificationRoutine _gasVerificationRoutine; private readonly PMPartialPressureRoutine _pmPartialPressureRoutine; private readonly PMVATPerformanceRoutine _pmVATPerformanceRoutine; private readonly PMHeatRoutine _pmHeatRoutine; private AutoFlag _AutoMode; private bool _isOnline = false; //private bool _isAlarm; //private DateTime _pumpStartTime; //private TimeSpan _pumpElapsedTime; //private DateTime _rfStartTime; //private DateTime _tcStartTime; //private TimeSpan _rfElapsedTime; //private TimeSpan _tcElapsedTime; //private MovementPosition _goalLiftPin; //private ushort _ActivatedActionID; //private Stopwatch _LifpinSleepTimer; private bool startControlPressureFlag = true; //private bool stopControlPressureFlag = false; private int _controlPressureSetPoint = 90; private int _controlFlowSetPoint = 90; public JetChamber ChamberType => _chamber.ChamberType; public bool IsIdle { get { return fsm.State == (int)PMState.Idle; } } public bool IsError { get { return fsm.State == (int)PMState.Error; } } public bool IsInit { get { return fsm.State == (int)PMState.Init; } } public bool IsBusy { get { return !IsInit && !IsError && !IsIdle; } } public bool IsProcessing { get { return fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess; } } public bool IsOnline { get { return _isOnline; } } public bool IsInclude { get; private set; } = true; private Dictionary _dictRecipeTime = new Dictionary(); public override int TimeToReady { get { switch ((PMState)fsm.State) { case PMState.Processing: case PMState.Clean: if (Singleton.Instance.IsAutoMode && IsOnline) { if (_dictRecipeTime.ContainsKey(_processRoutine.currentRecipeResult.RecipeName)) { return Math.Max(_dictRecipeTime[_processRoutine.currentRecipeResult.RecipeName] - fsm.ElapsedTime, 0); } } break; } return int.MaxValue; } } public bool IsAutoMode => _AutoMode == AutoFlag.Auto; public bool IsSlitDoorOpen => _chamber.CheckSlitDoorOpen(); public bool IsSlitDoorClose => _chamber.CheckSlitDoorClose(); public bool LiftPinIsDown => _chamber.LiftPinIsDown; public bool LiftPinIsUp => _chamber.LiftPinIsUp; public double ChamberPressure => _chamber.ChamberPressure; public bool IsVac => _chamber.IsVAC; public bool IsAtm => _chamber.IsATM; public float ChamberTemperature => _chamber.ChamberTemperature; public bool Check(int msg, out string reason, object[] objs) { reason = ""; return true; } // private bool CheckToPostMessage(int msg, params object[] args) { if (!fsm.FindTransition(fsm.State, msg)) { EV.PostWarningLog(Module.ToString(), eEvent.WARN_State, $"{Module} is in {(PMState)fsm.State} state，can not do {(MSG)msg}"); return false; } fsm.PostMsg(msg, args); return true; } public int Invoke(string function, params object[] args) { switch (function) { case "Home": CheckToPostMessage((int)MSG.Home); return (int)MSG.Home; } return (int)FSM_MSG.NONE; } public bool CheckAcked(int msg) { return fsm.CheckExecuted(msg); } public void ResetRecipeTime() { _dictRecipeTime.Clear(); } public bool IsPrepareTransferReady(ModuleName robot, EnumTransferType type, int slot, Hand blade) { //if (type == EnumTransferType.Pick) //{ // return _chamber.CheckEnableTransfer(type, WaferManager.Instance.GetWafer(_chamber.Module, 0).Size); //} //else if (type == EnumTransferType.Place) //{ // return _chamber.CheckEnableTransfer(type, WaferManager.Instance.GetWafer(robot, (int)blade).Size); //} return false; } public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot) { if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString())) return (int)MSG.PrepareTransfer; return (int)FSM_MSG.NONE; } public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp) { if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString(), temp)) return (int)MSG.PrepareTransfer; return (int)FSM_MSG.NONE; } public int InvokePrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp, WaferSize size) { if (CheckToPostMessage((int)MSG.PrepareTransfer, type.ToString(), temp, size)) return (int)MSG.PrepareTransfer; return (int)FSM_MSG.NONE; } public int InvokePostTransfer(ModuleName robot, EnumTransferType type, int slot) { if (CheckToPostMessage((int)MSG.PostTransfer, type.ToString())) return (int)MSG.PostTransfer; return (int)FSM_MSG.NONE; } public int InvokeClean(string recipeName, string waferID, RecipeType recipeType) { if (CheckToPostMessage((int)MSG.Clean, recipeName, waferID, recipeType)) { return (int)MSG.Clean; } return (int)FSM_MSG.NONE; } public int InvokeProcess(string recipeName, string waferID, RecipeType recipeType) { if (CheckToPostMessage((int)MSG.RunRecipe, recipeName, waferID, recipeType)) return (int)MSG.RunRecipe; return (int)FSM_MSG.NONE; } public int InvokePreHeat(float temperature) { if (CheckToPostMessage((int)MSG.Heat, (double)temperature)) return (int)MSG.Heat; return (int)FSM_MSG.NONE; } public void InvokeReset() { PostMsg((int)MSG.Reset); } public void SetAuto() { this._AutoMode = AutoFlag.Auto; } private bool FnSetManual(object[] param) { if (fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess) { EV.PostWarningLog(Module.ToString(), $"{Module} is in {(PMState)fsm.State}，can not do SetAutoMode"); return false; } this._AutoMode = AutoFlag.Manual; if (IsOnline) { EV.PostWarningLog(Module.ToString(), $"{Module} is online，change to offline due to the chamber change to manual mode"); this._isOnline = false; } return true; } private bool FnSetInclude() { if (IsOnline == true) { LOG.Write(eEvent.WARN_PM, Module, $"{Module} is online，can not set Include"); return false; } IsInclude = true; LOG.Write(eEvent.INFO_PM, Module, $"{Module} Set Include Success"); return true; } private bool FnSetExclude() { if (IsOnline == true) { LOG.Write(eEvent.WARN_PM, Module, $"{Module} is online，can not set Exclude"); return false; } IsInclude = false; LOG.Write(eEvent.INFO_PM, Module, $"{Module} Set Exclude Success"); return true; } private bool FnSetOnline(object[] param) { //if (!IsAutoMode) //{ // EV.PostWarningLog(Module.ToString(), $"{Module} in manual mode，can not set online."); // return false; //} if (!IsInclude) { LOG.Write(eEvent.WARN_PM, Module, $"{Module} is excluded，can not be put online"); return false; } if (!_chamber.CheckSlitDoorClose()) { EV.PostWarningLog(Module.ToString(), $"{Module} slit door is open，can not set online."); return false; } this._isOnline = true; return true; } private bool FnSetOffline(object[] param) { this._isOnline = false; return true; } public PMEntity(ModuleName module) { Module = module; _chamber = DEVICE.GetDevice(Module.ToString()); _home = new PMHomeRoutine(_chamber); _startDryPumpRoutine = new StartDryPumpRoutine(_chamber); _startTurboPumpRoutine = new StartTurboPumpRoutine(_chamber); _ventRoutine = new VentRoutine(_chamber); _pumpRoutine = new PumpDownRoutine(_chamber); _ventLoadLockRoutine = new LoadLockVentRoutine(_chamber); _pumpLoadLockRoutine = new LoadLockPumpRoutine(_chamber); _purgeLoadLockRoutine = new LoadLockPurgeRoutine(_chamber); _loadLockLeakCheckRoutine = new LoadLockLeakCheckRoutine(_chamber); _purgeRoutine = new PMPurgeRoutine(_chamber); _gaslinePurgeRoutine = new PMGaslinePurgeRoutine(_chamber); _leakCheckRoutine = new PMLeakCheckRoutine(_chamber); _gasBoxLeakCheckRoutine = new GasBoxLeakCheckRoutine(_chamber); _llPlaceRoutine = new LLPlaceRoutine(_chamber); _llPickRoutine = new LLPickRoutine(_chamber, _ventLoadLockRoutine); _processRoutine = new PMProcessRoutine(_chamber, _pumpRoutine); _gasFlowRoutine = new GasFlowRoutine(_chamber); _rfPowerRoutine = new RFPowerSwitchRoutine(_chamber, true); _gasVerificationRoutine = new PMGasVerificationRoutine(_chamber, _pumpRoutine); _pmPartialPressureRoutine = new PMPartialPressureRoutine(_chamber); _pmVATPerformanceRoutine = new PMVATPerformanceRoutine(_chamber); //_pmControlPressureRoutine = new PMControlPressureRoutine(_chamber); _pmHeatRoutine = new PMHeatRoutine(_chamber); fsm = new StateMachine(Module.ToString(), (int)PMState.Init, 50); //Idle EnterExitTransition((int)PMState.Idle, FnIdle, (int)FSM_MSG.NONE, null); EnterExitTransition(PMState.Error, fEnterError, FSM_MSG.NONE, null); EnterExitTransition(PMState.ReadyForPick, fnEnterPickReady, FSM_MSG.NONE, fnExitPickReady); EnterExitTransition(PMState.ReadyForPlace, fnEnterPlaceReady, FSM_MSG.NONE, fnExitPlaceReady); EnterExitTransition(PMState.DropDownReady, fnEnterDropDownReady, FSM_MSG.NONE, fnExitDropDownReady); EnterExitTransition(PMState.LiftUpReady, fnEnterLiftUpReady, FSM_MSG.NONE, fnExitLiftUpReady); //Home //EnterExitTransition((int)PMState.Homing, FnEnterHome, (int)FSM_MSG.NONE, FnExitHome); AnyStateTransition(MSG.Error, FnError, PMState.Error); AnyStateTransition(MSG.Online, FnSetOnline, FSM_STATE.SAME); AnyStateTransition(MSG.Offline, FnSetOffline, FSM_STATE.SAME); Transition(PMState.Init, FSM_MSG.TIMER, FnTimeout, PMState.Init); Transition(PMState.Init, MSG.Home, FnStartHome, PMState.Homing); Transition(PMState.Error, MSG.Home, FnStartHome, PMState.Homing); Transition(PMState.Idle, MSG.Home, FnStartHome, PMState.Homing); Transition(PMState.Homing, MSG.Home, FnStartHome, PMState.Homing); Transition(PMState.Homing, FSM_MSG.TIMER, FnMonitorHome, PMState.Idle); Transition(PMState.Idle, FSM_MSG.TIMER, FnIdleTimeout, PMState.Idle); Transition(PMState.Error, FSM_MSG.TIMER, FnErrorTimeout, PMState.Error); //Launch DryPump sequence Transition(PMState.Idle, MSG.LaunchPump, FnLaunchPump, PMState.LaunchingPump); Transition(PMState.LaunchingPump, FSM_MSG.TIMER, FnLaunchPumpTimeout, PMState.Idle); Transition(PMState.LaunchingPump, MSG.Abort, FnAbortStartPumping, PMState.Idle); //Launch TurboPump sequence Transition(PMState.Idle, MSG.LaunchTurboPump, FnLaunchTurboPump, PMState.LaunchingTurboPump); Transition(PMState.LaunchingTurboPump, FSM_MSG.TIMER, FnLaunchTurboPumpTimeout, PMState.Idle); Transition(PMState.LaunchingTurboPump, MSG.Abort, FnAbortStartTurboPumping, PMState.Idle); //vent sequence Transition(PMState.Idle, MSG.Vent, FnStartVent, PMState.Venting); Transition(PMState.Pumping, MSG.Vent, FnVentToPumping, PMState.Venting); Transition(PMState.Venting, FSM_MSG.TIMER, FnVentTimeout, PMState.Idle); Transition(PMState.Venting, MSG.Abort, FnAbortVent, PMState.Idle); //Pump sequence Transition(PMState.Idle, MSG.Pump, FnStartPumpDown, PMState.Pumping); Transition(PMState.Venting, MSG.Pump, FnVentToPumping, PMState.Pumping); Transition(PMState.Pumping, FSM_MSG.TIMER, FnPumpDownTimeout, PMState.Idle); Transition(PMState.Pumping, MSG.Abort, FnAbortPumping, PMState.Idle); //Pump Loadlock sequence Transition(PMState.Idle, MSG.PumpLoadLock, FnStartPumpDownLoadLock, PMState.PumpingLoadLock); Transition(PMState.VentingLoadLock, MSG.PumpLoadLock, FnVentLoadLockToPumpingLoadLock, PMState.PumpingLoadLock); Transition(PMState.PumpingLoadLock, FSM_MSG.TIMER, FnPumpDownLoadLockTimeout, PMState.Idle); Transition(PMState.PumpingLoadLock, MSG.Abort, FnAbortPumpingLoadLock, PMState.Idle); //Vent Loadlock sequence Transition(PMState.Idle, MSG.VentLoadLock, FnStartVentLoadlock, PMState.VentingLoadLock); Transition(PMState.PumpingLoadLock, MSG.VentLoadLock, FnPumpingLoadLockToVentLoadLock, PMState.VentingLoadLock); Transition(PMState.VentingLoadLock, FSM_MSG.TIMER, FnVentLoadLockTimeout, PMState.Idle); Transition(PMState.VentingLoadLock, MSG.Abort, FnAbortVentLoadLock, PMState.Idle); // Purge LoadLock sequence Transition(PMState.Idle, MSG.PurgeLoadLock, FnStartPurgeLoadlock, PMState.PurgingLoadLock); Transition(PMState.PurgingLoadLock, FSM_MSG.TIMER, FnPurgeLoadLockTimeout, PMState.Idle); Transition(PMState.PurgingLoadLock, MSG.Abort, FnAbortPurgeLoadLock, PMState.Idle); //LoadLock Leak check sequence Transition(PMState.Idle, MSG.LoadLockLeakCheck, FnStartLoadLockLeakCheck, PMState.LoadLockLeakCheck); Transition(PMState.LoadLockLeakCheck, FSM_MSG.TIMER, FnLoadLockLeakCheckTimeout, PMState.Idle); Transition(PMState.LoadLockLeakCheck, MSG.Abort, FnAbortLoadLockLeakCheck, PMState.Idle); // PM Purge sequence Transition(PMState.Idle, MSG.CyclePurge, FnStartPurge, PMState.Purging); Transition(PMState.Purging, FSM_MSG.TIMER, FnPurgeTimeout, PMState.Idle); Transition(PMState.Purging, MSG.Abort, FnAbortPurge, PMState.Idle); // PM GasLine Purge sequence Transition(PMState.Idle, MSG.GasLinePurge, FnStartGasLinePurge, PMState.GasLinePurge); Transition(PMState.GasLinePurge, FSM_MSG.TIMER, FnGasLinePurgeTimeout, PMState.Idle); Transition(PMState.GasLinePurge, MSG.Abort, FnAbortGasLinePurge, PMState.Idle); //PM Leak check sequence Transition(PMState.Idle, MSG.LeakCheck, FnStartPMLeakCheck, PMState.LeakCheck); Transition(PMState.LeakCheck, FSM_MSG.TIMER, FnPMLeakCheckTimeout, PMState.Idle); Transition(PMState.LeakCheck, MSG.Abort, FnAbortPMLeakCheck, PMState.Idle); //PM GasBox Leak check sequence Transition(PMState.Idle, MSG.GasLeakCheck, FnStartGasBoxLeakCheck, PMState.GasBoxLeakCheck); Transition(PMState.GasBoxLeakCheck, FSM_MSG.TIMER, FnGasBoxLeakCheckTimeout, PMState.Idle); Transition(PMState.GasBoxLeakCheck, MSG.Abort, FnAbortGasBoxLeakCheck, PMState.Idle); // PlaceWafer from LoadLock Arm sequence Transition(PMState.Idle, MSG.LLPlace, FnStartLLPlace, PMState.LLPlacing); Transition(PMState.LLPlacing, FSM_MSG.TIMER, FnLLPlaceTimeout, PMState.Idle); Transition(PMState.LLPlacing, MSG.Abort, FnAbortLLPlace, PMState.Idle); // PickWafer to LoadLock Arm sequence Transition(PMState.Idle, MSG.LLPick, FnStartLLPick, PMState.LLPicking); Transition(PMState.LLPicking, FSM_MSG.TIMER, FnLLPickTimeout, PMState.Idle); Transition(PMState.LLPicking, MSG.Abort, FnAbortLLPick, PMState.Idle); // Process Transition(PMState.Idle, MSG.RunRecipe, FnRunRecipe, PMState.Processing); Transition(PMState.Processing, FSM_MSG.TIMER, FnProcessTimeout, PMState.Idle); Transition(PMState.Processing, MSG.Abort, FnAbortProcess, PMState.Idle); // Clean Transition(PMState.Idle, MSG.Clean, FnRunRecipe, PMState.Clean); Transition(PMState.Clean, FSM_MSG.TIMER, FnProcessTimeout, PMState.Idle); Transition(PMState.Clean, MSG.Abort, FnAbortProcess, PMState.Idle); // Gas Flow sequence Transition(PMState.Idle, MSG.GasFlow, FnStartGasFlow, PMState.GasFlowing); Transition(PMState.GasFlowing, MSG.GasFlow, FnAbortGasFlow, PMState.Idle); Transition(PMState.GasFlowing, FSM_MSG.TIMER, FnGasFlowTimeout, PMState.Idle); Transition(PMState.GasFlowing, MSG.StopGasFlow, FnStopGasFlow, PMState.Idle); Transition(PMState.GasFlowing, MSG.Abort, FnAbortGasFlow, PMState.Idle); //RF Power sequence Transition(PMState.Idle, MSG.RfPower, FnStartRfPower, PMState.RfPowering); Transition(PMState.GasFlowing, MSG.RfPower, FnStartRfPower, PMState.RfPowering); Transition(PMState.RfPowering, FSM_MSG.TIMER, FnRfPowerTimeout, PMState.Idle); Transition(PMState.RfPowering, MSG.Abort, FnAbortRfPower, PMState.Idle); //MFC verification Transition(PMState.Idle, MSG.MFCVerification, FnStartMFCVerification, PMState.MFCVerification); Transition(PMState.MFCVerification, FSM_MSG.TIMER, FnMFCVerificationTimeout, PMState.Idle); Transition(PMState.MFCVerification, MSG.Abort, FnAbortMFCVerification, PMState.Idle); //////////////////////// Exchange Wafer with TM /////////////////////////////////////////////////////// // Pick Wafer from PM Transition(PMState.Idle, MSG.PreparePick, FnStartPreparePick, PMState.PreparePick); Transition(PMState.PreparePick, MSG.Abort, FnAbortPreparePick, PMState.Idle); Transition(PMState.PreparePick, FSM_MSG.TIMER, FnPreparePickTimeout, PMState.ReadyForPick); Transition(PMState.PreparePick, MSG.PreparePick, null, PMState.PreparePick); Transition(PMState.ReadyForPick, MSG.Abort, FnAbortPick, PMState.Idle); Transition(PMState.ReadyForPick, MSG.DropDownWafer, FnStartDropDownWafer, PMState.DropDownWafer); Transition(PMState.ReadyForPick, MSG.PreparePick, null, PMState.ReadyForPick); Transition(PMState.DropDownWafer, FSM_MSG.TIMER, FnDropDownTimeout, PMState.DropDownReady); Transition(PMState.DropDownReady, MSG.PickReady, FnStartFinishPick, PMState.FinishPick); Transition(PMState.ReadyForPick, MSG.PickReady, FnStartFinishPick, PMState.FinishPick); Transition(PMState.FinishPick, FSM_MSG.TIMER, FnFinishPickTimeout, PMState.Idle); // Place Wafer to PM Transition(PMState.Idle, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace); Transition(PMState.Heating, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace); Transition(PMState.PreparePlace, MSG.Abort, FnAbortPreparePlace, PMState.Idle); Transition(PMState.PreparePlace, FSM_MSG.TIMER, FnPreparePlaceTimeout, PMState.ReadyForPlace); Transition(PMState.PreparePlace, MSG.PreparePlace, null, PMState.PreparePlace); Transition(PMState.ReadyForPlace, MSG.LiftUpWafer, FnStartLiftUpWafer, PMState.LiftUpWafer); Transition(PMState.LiftUpWafer, FSM_MSG.TIMER, FnLiftUpTimeout, PMState.LiftUpReady); Transition(PMState.LiftUpReady, MSG.PlaceReady, FnStartFinishPlace, PMState.FinishPlace); Transition(PMState.ReadyForPlace, MSG.PlaceReady, FnStartFinishPlace, PMState.FinishPlace); Transition(PMState.PreparePlace, MSG.Abort, FnAortPlace, PMState.Idle); Transition(PMState.ReadyForPlace, MSG.Abort, FnAortPlace, PMState.Idle); Transition(PMState.ReadyForPlace, MSG.PreparePlace, null, PMState.ReadyForPlace); Transition(PMState.LiftUpReady, MSG.Abort, FnAortPlace, PMState.Idle); Transition(PMState.FinishPlace, FSM_MSG.TIMER, FnFinishPlaceTimeout, PMState.Idle); // Swap Wafer With PM Transition(PMState.DropDownReady, MSG.PreparePlace, FnStartSwapPlace, PMState.PreparePlace); Transition(PMState.ReadyForPick, MSG.PreparePlace, FnStartPreparePlace, PMState.PreparePlace); Transition(PMState.Idle, MSG.PartialPressure, FnStartPartialPressure, PMState.PartialPressureTesting); Transition(PMState.PartialPressureTesting, FSM_MSG.TIMER, FnPartialPressureTimeout, PMState.Idle); Transition(PMState.PartialPressureTesting, MSG.Abort, FnAbortPartialPressure, PMState.Idle); Transition(PMState.Idle, MSG.VATPerformance, FnStartVATPerformance, PMState.VATPerformanceTesting); Transition(PMState.VATPerformanceTesting, FSM_MSG.TIMER, FnVATPerformanceTimeout, PMState.Idle); Transition(PMState.VATPerformanceTesting, MSG.Abort, FnAbortVATPerformance, PMState.Idle); //Transition(PMState.Idle, MSG.Heat, FnStartHeat, PMState.Heating); AnyStateTransition(FSM_MSG.TIMER, FnControlPressure, FSM_STATE.SAME); Running = true; WaferManager.Instance.SubscribeLocation(Module, 1); } protected override bool Init() { DATA.Subscribe($"{Module}.FsmState", () => (((PMState)fsm.State)), SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.FsmPrevState", () => (((PMState)fsm.PrevState).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.FsmLastMessage", () => (((MSG)fsm.LastMsg).ToString()), SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.LoadLockPurge.PurgeCounter", () => _purgeLoadLockRoutine.PurgeCounter, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.PartialPressureCounter", () => _pmPartialPressureRoutine.counter, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.VATPerformanceCounter", () => _pmVATPerformanceRoutine.counter, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.VATPerformanceResult", () => _pmVATPerformanceRoutine?.m_sb.ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.PartialPressureResult", () => _pmPartialPressureRoutine?.m_sb.ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.MFCCalibrationDatas", () => _gasVerificationRoutine?._MFCCalibrationDatas, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsIdle", () => IsIdle, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsAlarm", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsBusy", () => IsBusy, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsInit", () => IsInit, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsOnline", () => _isOnline, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.VentingFlag", () => _ventRoutine.VentingFlag, SubscriptionAttribute.FLAG.IgnoreSaveDB); //DATA.Subscribe($"{Module}.GetLeakCheckDatas", () => LeakCheckDataRecorder.GetAllLeakCheckData(Module.ToString())); DATA.Subscribe($"{Module}.CurrentRecipeResult", () => _processRoutine.currentRecipeResult, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.LeakCheck.Step", () => _leakCheckRoutine.CurrentStep, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.GasLeakCheck.Step", () => _gasBoxLeakCheckRoutine.CurrentStep, SubscriptionAttribute.FLAG.IgnoreSaveDB); DATA.Subscribe($"{Module}.IsInclude", () => IsInclude, SubscriptionAttribute.FLAG.IgnoreSaveDB); OP.Subscribe($"{Module}.{RtOperation.GasFlow}", (cmd, args) => CheckToPostMessage((int)MSG.GasFlow, args)); OP.Subscribe($"{Module}.{RtOperation.LeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck, args)); OP.Subscribe($"{Module}.{RtOperation.GasLeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.GasLeakCheck, args)); OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home)); OP.Subscribe($"{Module}.{RtOperation.StartPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchPump)); OP.Subscribe($"{Module}.{RtOperation.StartTurboPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchTurboPump)); OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump)); OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.CyclePurge)); OP.Subscribe($"{Module}.{RtOperation.RfPower}", (cmd, args) => CheckToPostMessage((int)MSG.RfPower)); OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent)); OP.Subscribe($"{Module}.{RtOperation.VentLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.VentLoadLock)); OP.Subscribe($"{Module}.{RtOperation.PurgeLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PurgeLoadLock)); OP.Subscribe($"{Module}.{RtOperation.PumpLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PumpLoadLock)); OP.Subscribe($"{Module}.{RtOperation.Reset}", (cmd, args) => CheckToPostMessage((int)MSG.Reset)); OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort)); OP.Subscribe($"{Module}.{RtOperation.LLPick}", (cmd, args) => CheckToPostMessage((int)MSG.LLPick)); OP.Subscribe($"{Module}.{RtOperation.LLPlace}", (cmd, args) => CheckToPostMessage((int)MSG.LLPlace)); OP.Subscribe($"{Module}.{RtOperation.MFCVerification}", (cmd, args) => CheckToPostMessage((int)MSG.MFCVerification, args)); OP.Subscribe($"{Module}.{RtOperation.RunRecipe}", (cmd, args) => CheckToPostMessage((int)MSG.RunRecipe, args)); OP.Subscribe($"{Module}.{RtOperation.RunCleanRecipe}", (cmd, args) => CheckToPostMessage((int)MSG.Clean, args)); OP.Subscribe($"{Module}.PartialPressureTest", (cmd, args) => CheckToPostMessage((int)MSG.PartialPressure, args[0], args[1])); OP.Subscribe($"{Module}.VATPerformanceTest", (cmd, args) => CheckToPostMessage((int)MSG.VATPerformance, args[0], args[1], args[2])); OP.Subscribe($"{Module}.GasLinePurge", (cmd, args) => CheckToPostMessage((int)MSG.GasLinePurge)); OP.Subscribe($"{Module}.ManualEndStep", (cmd, args) => ManualEndStep()); OP.Subscribe($"{Module}.{RtOperation.Online}", (cmd, args) => CheckToPostMessage((int)MSG.Online)); OP.Subscribe($"{Module}.{RtOperation.Offline}", (cmd, args) => CheckToPostMessage((int)MSG.Offline)); OP.Subscribe($"{Module}.{RtOperation.PmError}", (cmd, args) => CheckToPostMessage((int)MSG.Error)); OP.Subscribe($"{Module}.{RtOperation.Include}", (cmd, args) => FnSetInclude()); OP.Subscribe($"{Module}.{RtOperation.Exclude}", (cmd, args) => FnSetExclude()); if (ChamberType == JetChamber.Kepler2200A && ChamberType == JetChamber.Kepler2200B) { LOG.PMErrorInterrupt += (pmname) => PMErrorInterrupt(pmname); } return true; } private void PMErrorInterrupt(ModuleName pmname) { if (pmname == Module) { LOG.Write(eEvent.ERR_PM, Module, $"Device Error Happend! {Module} Crash!"); CheckToPostMessage((int)MSG.Error); } } private bool ManualEndStep() { _processRoutine.isMaualEndStep = true; return true; } private bool FnIdle(object[] objs) { Running = false; return true; } private bool fEnterError(object[] objs) { return true; } private bool fnEnterPickReady(object[] objs) { Status = PMStatus.Ready_For_Pick; return true; } private bool fnExitPickReady(object[] objs) { Status = PMStatus.Not_Ready; return true; } private bool fnEnterPlaceReady(object[] objs) { Status = PMStatus.Ready_For_Place; return true; } private bool fnExitPlaceReady(object[] objs) { Status = PMStatus.Not_Ready; return true; } private bool fnEnterDropDownReady(object[] objs) { Status = PMStatus.Exchange_Ready; return true; } private bool fnExitDropDownReady(object[] objs) { Status = PMStatus.Not_Ready; return true; } private bool fnEnterLiftUpReady(object[] objs) { Status = PMStatus.Exchange_Ready; return true; } private bool fnExitLiftUpReady(object[] objs) { Status = PMStatus.Not_Ready; return true; } private bool FnError(object[] objs) { Running = false; _isOnline = false; //if (((PMState)fsm.State == PMState.Processing) || ((PMState)fsm.State == PMState.PreProcess) // || ((PMState)fsm.State == PMState.Homing) || ((PMState)fsm.State == PMState.LoadProcessRecipe)) // return false; _chamber.CloseValves(); _chamber.GeneratorPowerOn(false); _chamber.GeneratorBiasPowerOn(false); _chamber.OpenValve(ValveType.TurboPumpPumping, true); _chamber.OpenValve(ValveType.TurboPumpPurge, true); _chamber.OnOffSetESCHV(false); if (IsProcessing) { WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed); } return true; } private bool FnTimeout(object[] objs) { _debugRoutine(); return true; } private bool FnIdleTimeout(object[] objs) { _chamber.CheckIdleInterlock(); //_debugRoutine(); return true; } private bool FnErrorTimeout(object[] objs) { //_debugRoutine(); return true; } private bool FnStartHome(object[] objs) { return _home.Start() == RState.Running; } private bool FnMonitorHome(object[] objs) { RState ret = _home.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnLaunchPump(object[] param) { return _startDryPumpRoutine.Start() == RState.Running; } private bool FnLaunchPumpTimeout(object[] param) { RState ret = _startDryPumpRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortStartPumping(object[] param) { _startDryPumpRoutine.Abort(); return true; } private bool FnLaunchTurboPump(object[] param) { return _startTurboPumpRoutine.Start() == RState.Running; } private bool FnLaunchTurboPumpTimeout(object[] param) { RState ret = _startTurboPumpRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortStartTurboPumping(object[] param) { _startTurboPumpRoutine.Abort(); return true; } private bool FnStartVent(object[] param) { return _ventRoutine.Start() == RState.Running; } private bool FnVentTimeout(object[] param) { RState ret = _ventRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnVentToPumping(object[] param) { _ventRoutine.Abort(); return true; // FnStartPumpDown(param); } private bool FnAbortVent(object[] param) { _ventRoutine.Abort(); return true; } private bool FnStartPumpDown(object[] param) { return _pumpRoutine.Start() == RState.Running; } private bool FnPumpDownTimeout(object[] param) { RState ret = _pumpRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortPumping(object[] param) { _pumpRoutine.Abort(); return true; } private bool FnStartVentLoadlock(object[] param) { return _ventLoadLockRoutine.Start() == RState.Running; } private bool FnVentLoadLockTimeout(object[] param) { RState ret = _ventLoadLockRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnVentLoadLockToPumpingLoadLock(object[] param) { _ventLoadLockRoutine.Abort(); return FnStartPumpDownLoadLock(param); } private bool FnAbortVentLoadLock(object[] param) { _ventLoadLockRoutine.Abort(); return true; } private bool FnStartPumpDownLoadLock(object[] param) { return _pumpLoadLockRoutine.Start() == RState.Running; } private bool FnPumpDownLoadLockTimeout(object[] param) { RState ret = _pumpLoadLockRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnPumpingToVent(object[] param) { _pumpRoutine.Abort(); return FnStartVent(param); } private bool FnPumpingLoadLockToVentLoadLock(object[] param) { _pumpLoadLockRoutine.Abort(); return FnStartVentLoadlock(param); } private bool FnAbortPumpingLoadLock(object[] param) { _pumpLoadLockRoutine.Abort(); return true; } private bool FnStartPurgeLoadlock(object[] param) { return _purgeLoadLockRoutine.Start() == RState.Running; } private bool FnPurgeLoadLockTimeout(object[] param) { RState ret = _purgeLoadLockRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortPurgeLoadLock(object[] param) { _purgeLoadLockRoutine.Abort(); return true; } private bool FnStartLoadLockLeakCheck(object[] param) { return _loadLockLeakCheckRoutine.Start() == RState.Running; } private bool FnLoadLockLeakCheckTimeout(object[] param) { RState ret = _loadLockLeakCheckRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortLoadLockLeakCheck(object[] param) { _loadLockLeakCheckRoutine.Abort(); return true; } private bool FnStartPurge(object[] param) { return _purgeRoutine.Start() == RState.Running; } private bool FnPurgeTimeout(object[] param) { RState ret = _purgeRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortPurge(object[] param) { _purgeRoutine.Abort(); return true; } private bool FnStartGasLinePurge(object[] param) { return _gaslinePurgeRoutine.Start() == RState.Running; } private bool FnGasLinePurgeTimeout(object[] param) { RState ret = _gaslinePurgeRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortGasLinePurge(object[] param) { _gaslinePurgeRoutine.Abort(); return true; } private bool FnStartPMLeakCheck(object[] param) { return _leakCheckRoutine.Start(param) == RState.Running; } private bool FnPMLeakCheckTimeout(object[] param) { RState ret = _leakCheckRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortPMLeakCheck(object[] param) { _leakCheckRoutine.Abort(); return true; } private bool FnStartGasBoxLeakCheck(object[] param) { return _gasBoxLeakCheckRoutine.Start(param) == RState.Running; } private bool FnGasBoxLeakCheckTimeout(object[] param) { RState ret = _gasBoxLeakCheckRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortGasBoxLeakCheck(object[] param) { _gasBoxLeakCheckRoutine.Abort(); return true; } private bool FnStartLLPlace(object[] param) { return _llPlaceRoutine.Start() == RState.Running; } private bool FnLLPlaceTimeout(object[] param) { RState ret = _llPlaceRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortLLPlace(object[] param) { _llPlaceRoutine.Abort(); return true; } private bool FnStartLLPick(object[] param) { return _llPickRoutine.Start() == RState.Running; } private bool FnLLPickTimeout(object[] param) { RState ret = _llPickRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortLLPick(object[] param) { _llPickRoutine.Abort(); return true; } private bool FnRunRecipe(object[] param) { RState ret = _processRoutine.Start(param); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.Running; } private bool FnProcessTimeout(object[] param) { _chamber.CheckIdleInterlock(); RState ret = _processRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } if (ret == RState.End) { _dictRecipeTime[_processRoutine.currentRecipeResult.RecipeName] = fsm.ElapsedTime; return true; } return false; } private bool FnAbortProcess(object[] param) { _processRoutine.Abort(); return true; } private bool FnStartGasFlow(object[] param) { return _gasFlowRoutine.Start(param) == RState.Running; } private bool FnGasFlowTimeout(object[] param) { RState ret = _gasFlowRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnStopGasFlow(object[] param) { _gasFlowRoutine.Abort(); return true; } private bool FnAbortGasFlow(object[] param) { _gasFlowRoutine.Abort(); return true; } private bool FnStartRfPower(object[] param) { return _rfPowerRoutine.Start(param) == RState.Running; } private bool FnRfPowerTimeout(object[] param) { RState ret = _rfPowerRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortRfPower(object[] param) { _rfPowerRoutine.Abort(); if (_gasFlowRoutine._gasStatus) { _gasFlowRoutine.StopFlow(); } return true; } private bool FnStartMFCVerification(object[] param) { _gasVerificationRoutine.Init((string)param[0], Convert.ToDouble(param[1]), (int)param[2]); return _gasVerificationRoutine.Start(param) == RState.Running; } private bool FnMFCVerificationTimeout(object[] param) { RState ret = _gasVerificationRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortMFCVerification(object[] param) { _gasVerificationRoutine.Abort(); return true; } private bool FnControlPressure(object[] param) { if (RouteManager.IsATMMode) { return true; } if (IsOnline == true && fsm.State != (int)PMState.Processing && fsm.State != (int)PMState.Clean) { if (startControlPressureFlag == true) { startControlPressureFlag = false; if (_chamber.GetPVPosition() <= 0) { LOG.Write(eEvent.WARN_PM, Module, $"{Module} control pressure fail,due to pendulum valve is not Open"); return false; } if (_chamber.IsTurboPumpRunning == false) { LOG.Write(eEvent.WARN_PM, Module, $"{Module} control pressure fail,due to turbo pump is not Open"); return false; } _controlPressureSetPoint = SC.GetValue($"{Module}.ControlPressureSetPoint"); _controlFlowSetPoint = SC.GetValue($"{Module}.ControlPressureN2FlowSetPoint"); _chamber.StartControlPressure(_controlPressureSetPoint, _controlFlowSetPoint); } } else { if (startControlPressureFlag == false) { _chamber.AbortControlPressure(); startControlPressureFlag = true; } } return true; } #region Exchange wafer with TM private bool FnStartPreparePick(object[] param) { if (!_chamber.PreparePick()) { LOG.Write(eEvent.ERR_PM, Module, $"Prepare Pick failed"); return false; } return true; } private bool FnPreparePickTimeout(object[] param) { // return _chamber.WaferIsDown && IsSlitDoorOpen; return _chamber.PreparePickIsOK(); } private bool FnAbortPreparePick(object[] param) { return true; } private bool FnStartFinishPick(object[] param) { //if (!_chamber.SetSlitDoor(false, out string reason)) //{ // LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}"); // return false; //} //return true; return _chamber.EndPick(); } private bool FnAbortPick(object[] param) { return true; } private bool FnFinishPickTimeout(object[] param) { //return IsSlitDoorClose; return _chamber.EndPickIsOK(); } private bool FnStartDropDownWafer(object[] param) { if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason)) { LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Down failed:{reason}"); return false; } return _chamber.SetLiftPin(MovementPosition.Down, out string _); } private bool FnDropDownTimeout(object[] param) { return _chamber.LiftPinIsDown; } private bool FnStartPreparePlace(object[] param) { //if (_chamber.ChamberType == JetChamber.Venus || _chamber.ChamberType == JetChamber.Kepler2300) //{ // if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason)) // { // LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin down failed:{reason}"); // return false; // } //} if (!_chamber.PreparePlace()) { LOG.Write(eEvent.ERR_PM, Module, $"Set Wafer Down failed"); return false; } //string reason = ""; //if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason)) //{ // LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin down failed:{reason}"); // return false; //} return true; } private bool FnPreparePlaceTimeout(object[] param) { return _chamber.PreparePlaceIsOK(); } private bool FnAbortPreparePlace(object[] param) { return true; } private bool FnStartLiftUpWafer(object[] param) { if (!_chamber.SetLiftPin(MovementPosition.Up, out string reason)) { LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Up failed:{reason}"); return false; } return true; } private bool FnLiftUpTimeout(object[] param) { return _chamber.LiftPinIsUp; } private bool FnStartFinishPlace(object[] param) { //if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason)) //{ // LOG.Write(eEvent.ERR_PM, Module, $"Set Lift Pin Down failed:{reason}"); // return false; //} //if (!_chamber.SetSlitDoor(false, out reason)) //{ // LOG.Write(eEvent.ERR_PM, Module, $"Set Slit Door Close failed:{reason}"); // return false; //} //return true; return _chamber.EndPlace(); } private bool FnAortPlace(object[] param) { return true; } private bool FnFinishPlaceTimeout(object[] param) { //return _chamber.LiftPinIsDown && IsSlitDoorClose; return _chamber.EndPlaceIsOK(); } private bool FnStartSwapPlace(object[] param) { return true; } private bool FnStartPartialPressure(object[] param) { return _pmPartialPressureRoutine.Start(param) == RState.Running; } private bool FnPartialPressureTimeout(object[] param) { RState ret = _pmPartialPressureRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortPartialPressure(object[] param) { _pmPartialPressureRoutine.Abort(); return true; } private bool FnStartVATPerformance(object[] param) { return _pmVATPerformanceRoutine.Start(param) == RState.Running; } private bool FnVATPerformanceTimeout(object[] param) { RState ret = _pmVATPerformanceRoutine.Monitor(); if (ret == RState.Failed || ret == RState.Timeout) { PostMsg(MSG.Error); return false; } return ret == RState.End; } private bool FnAbortVATPerformance(object[] param) { _pmVATPerformanceRoutine.Abort(); return true; } private bool FnStartHeat(object[] param) { if (ChamberType == JetChamber.Kepler2200A || ChamberType == JetChamber.Kepler2200B) { _pmHeatRoutine.Start(); } return true; } #endregion private void _debugRoutine() { int flag = 0; // Test Home routine if (flag == 1) { PostMsg(MSG.Home); } else if (flag == 2) { PostMsg(MSG.Vent); } else if (flag == 3) { PostMsg(MSG.Pump); } else if (flag == 4) { PostMsg(MSG.PumpLoadLock); } else if (flag == 5) { PostMsg(MSG.VentLoadLock); } else if (flag == 6) { PostMsg(MSG.PurgeLoadLock); } else if (flag == 7) { PostMsg(MSG.LaunchPump); } else if (flag == 8) { PostMsg(MSG.LaunchTurboPump); } else if (flag == 9) { PostMsg(MSG.LoadLockLeakCheck); } else if (flag == 10) { PostMsg(MSG.CyclePurge); } else if (flag == 11) { PostMsg(MSG.GasLinePurge); } else if (flag == 12) { PostMsg(MSG.LeakCheck); } else if (flag == 13) { PostMsg(MSG.GasLeakCheck); } else if (flag == 14) { PostMsg(MSG.LLPlace); } else if (flag == 15) { PostMsg(MSG.LLPick); } else if (flag == 16) { PostMsg(MSG.RunRecipe, "7777"); } else if (flag == 17) { PostMsg(MSG.MFCVerification, "MFC2", (double)50, 10); } } } }