880 lines
31 KiB
C#
880 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Aitex.Core.RT.DataCenter;
|
|
using Aitex.Core.RT.Device;
|
|
using Aitex.Core.RT.Device.Unit;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.OperationCenter;
|
|
using Aitex.Core.RT.Routine;
|
|
using Aitex.Core.RT.SCCore;
|
|
using Mainframe.LLs;
|
|
using MECF.Framework.Common.Equipment;
|
|
using MECF.Framework.Common.SubstrateTrackings;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadLocks;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Servo.NAIS;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.TMs;
|
|
using SicPM.Devices;
|
|
|
|
namespace Mainframe.TMs
|
|
{
|
|
public class TMSlitValveRoutine : TMBaseRoutine
|
|
{
|
|
enum RoutineStep
|
|
{
|
|
ChamberBalance,
|
|
OpenTMToLLVent,
|
|
OpenTMToPMV70,
|
|
CheckPressureCondition,
|
|
|
|
SetSlitValve,
|
|
|
|
SetSlowVentValve,
|
|
SetM40,
|
|
|
|
LLRoutine,
|
|
|
|
Delay,
|
|
Delay1, Delay2, Delay3, Delay4,
|
|
CloseTMToLLVent,
|
|
CloseTMToPMV70,
|
|
PumpDownToBase,
|
|
CheckConfinementIsDown,
|
|
|
|
SetConfinementRingUp,
|
|
SetConfinementRingDown,
|
|
SetPostTransfer,
|
|
SetPmPreTrasfer,
|
|
SetV77,
|
|
SetV77Close,
|
|
SetTmMfc,
|
|
WaitTempBelow900,
|
|
WaitPVTempBelowSet,
|
|
CheckPressureCondition1,
|
|
WaitPMIdle
|
|
}
|
|
|
|
|
|
private int _timeout;
|
|
|
|
private SicTM _tm;
|
|
private LoadLock _ll;
|
|
private IoValve PMToTm_V70;
|
|
private IoPressure _pmPT1;
|
|
private IoConfinementRing _confinementRing;
|
|
private SicPM.Devices.SicServo _sicServo;
|
|
private NAISServo _naisServo;
|
|
SicPM.Devices.IoInterLock _pmIoInterLock;
|
|
SicPM.Devices.IoTC _tc1;
|
|
|
|
private string _paramTarget;
|
|
private bool _paramIsOpen;
|
|
private bool _confinementIsDown = false;
|
|
|
|
|
|
//private TMPumpWithTurboRoutine _pumpDownRoutine;
|
|
|
|
private TMPressureBalanceRoutine _balanceRoutine;
|
|
private TMPressureBalancePidRoutine _pidBalanceRoutine;
|
|
private TMPressureBalancePidRoutine _pidAwaysRoutine;
|
|
private LoadLockServoTo _llVentTo;
|
|
private IoMFC _m40;
|
|
|
|
private bool _needPressureBalance;
|
|
private bool _userPidBalance;
|
|
|
|
private int _timeOutV70;
|
|
private int _timeOutV85;
|
|
private int _rotationStopTimeout = 120;
|
|
|
|
private double _maxPressureDiffOpenSlitValve;
|
|
private bool _isAtmMode;
|
|
private bool _isLockLock;
|
|
private bool _isPMA;
|
|
private int _tmV77DelayTime = 5;
|
|
private double _tmMfcFlow = 10;
|
|
|
|
private bool _pmPostTrasferNeedEnableHeat = true;
|
|
private bool _preTransferPSUEnable = false;
|
|
|
|
//private SCConfigItem _scPVInnerTempLimit;
|
|
//private SCConfigItem _scPVMiddleTempLimit;
|
|
//private SCConfigItem _scPVOuterTempLimit;
|
|
|
|
private double _pmPVInnerTempLimit = 0;
|
|
private double _pmPVMiddleTempLimit = 0;
|
|
private double _pmPVOuterTempLimit = 0;
|
|
|
|
public TMSlitValveRoutine()
|
|
{
|
|
Module = ModuleName.TM.ToString();
|
|
Name = "Slit Valve";
|
|
_tm = DEVICE.GetDevice<SicTM>($"{ ModuleName.System.ToString()}.{ ModuleName.TM.ToString()}");
|
|
_ll = DEVICE.GetDevice<SicLoadLock>($"{ModuleName.LoadLock}.{ModuleName.LoadLock}");
|
|
|
|
PMToTm_V70 = DEVICE.GetDevice<IoValve>("PM1.V70");
|
|
_m40 = DEVICE.GetDevice<IoMFC>($"TM.Mfc40");
|
|
|
|
_confinementRing = DEVICE.GetDevice<IoConfinementRing>("PM1.ConfinementRing");
|
|
_sicServo= DEVICE.GetDevice<SicPM.Devices.SicServo>("PM1.PMServo");
|
|
_pmIoInterLock = DEVICE.GetDevice<SicPM.Devices.IoInterLock>($"PM1.PMInterLock");
|
|
_tc1= DEVICE.GetDevice<SicPM.Devices.IoTC>($"PM1.TC1");
|
|
|
|
if (SC.GetConfigItem("NAISServo.EnableDevice").BoolValue)
|
|
{
|
|
_naisServo = DEVICE.GetDevice<NAISServo>($"PM1.NAISServo");
|
|
}
|
|
}
|
|
|
|
public void Init(string module,bool isOpen,bool needEnableHeat)
|
|
{
|
|
_pmPostTrasferNeedEnableHeat = needEnableHeat;
|
|
Init(module, isOpen);
|
|
}
|
|
|
|
public void Init(string module, bool isOpen)
|
|
{
|
|
_paramTarget = module;
|
|
_paramIsOpen = isOpen;
|
|
Name = isOpen ? "Open Slit Valve" : "Close Slit Valve";
|
|
|
|
//_pumpDownRoutine = new TMPumpWithTurboRoutine();
|
|
|
|
_balanceRoutine = new TMPressureBalanceRoutine();
|
|
_pidBalanceRoutine = new TMPressureBalancePidRoutine();
|
|
_pidAwaysRoutine = new TMPressureBalancePidRoutine();
|
|
_llVentTo = new LoadLockServoTo(ModuleName.LoadLock);
|
|
_balanceRoutine.Init(ModuleHelper.Converter(module));
|
|
_pidBalanceRoutine.Init(ModuleHelper.Converter(module));
|
|
_pidAwaysRoutine.Init(ModuleHelper.Converter(module), true);
|
|
|
|
_needPressureBalance = SC.GetValue<bool>("TM.NeedPressureBalance");
|
|
_userPidBalance= SC.GetValue<bool>("TM.PressureBalanceUsePid");
|
|
}
|
|
|
|
public override Result Start(params object[] objs)
|
|
{
|
|
Reset();
|
|
|
|
if ((_paramIsOpen && TMDevice.CheckSlitValveOpen(ModuleHelper.Converter(_paramTarget)))
|
|
|| (!_paramIsOpen && TMDevice.CheckSlitValveClose(ModuleHelper.Converter(_paramTarget))))
|
|
{
|
|
string message = _paramIsOpen ? "open" : "close";
|
|
if (TMDevice.GetSlitValve(ModuleHelper.Converter(_paramTarget)) != null)
|
|
EV.PostWarningLog(Module, $"{_paramTarget} slit valve already {message}");
|
|
return Result.DONE;
|
|
}
|
|
|
|
_tm.CloseAllVentPumpValue();
|
|
|
|
_isLockLock = ModuleHelper.IsLoadLock(_paramTarget);
|
|
_isPMA = ModuleHelper.Converter(_paramTarget) == ModuleName.PM1 || ModuleHelper.Converter(_paramTarget) == ModuleName.PMA;
|
|
|
|
|
|
if (_paramIsOpen)
|
|
{
|
|
bool isAtmMode = SC.GetValue<bool>("System.IsATMMode");
|
|
if (ModuleHelper.IsLoadLock(_paramTarget))
|
|
{
|
|
LoadLock ll = DEVICE.GetDevice<LoadLock>($"{_paramTarget}.{_paramTarget}");
|
|
|
|
if (isAtmMode)
|
|
{
|
|
if (!ll.CheckAtm())
|
|
{
|
|
EV.PostWarningLog(Module, $"can not open slit valve, running in ATM mode, but {_paramTarget} not in ATM");
|
|
return Result.FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!ll.CheckVacuum())
|
|
{
|
|
EV.PostWarningLog(Module, $"can not open slit valve, {_paramTarget} not in vacuum");
|
|
return Result.FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ModuleHelper.IsPm(_paramTarget))
|
|
{
|
|
//PM pm = DEVICE.GetDevice<PM>(_paramTarget);
|
|
|
|
_pmPT1 = DEVICE.GetDevice<IoPressure>($"{_paramTarget}.PT1");
|
|
double atmBase = SC.GetValue<double>($"PM.AtmPressureBase");
|
|
double vacBase = SC.GetValue<double>($"PM.VacuumPressureBase");
|
|
|
|
if (WaferManager.Instance.CheckHasWafer(ModuleName.PM1, 0))
|
|
{
|
|
_pmPVInnerTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PickPVInnerTempLimit");
|
|
_pmPVMiddleTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PickPVMiddleTempLimit");
|
|
_pmPVOuterTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PickPVOuterTempLimit");
|
|
}
|
|
else
|
|
{
|
|
_pmPVInnerTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PlacePVInnerTempLimit");
|
|
_pmPVMiddleTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PlacePVMiddleTempLimit");
|
|
_pmPVOuterTempLimit = SC.GetValue<double>($"PM.PM1.Heater.PlacePVOuterTempLimit");
|
|
}
|
|
|
|
if (isAtmMode)
|
|
{
|
|
//if (!pm.CheckAtm())
|
|
if (_pmPT1.FeedBack < atmBase)
|
|
{
|
|
EV.PostWarningLog(Module, $"can not open slit valve, running in ATM mode, but {_paramTarget} not in ATM");
|
|
return Result.FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//if (!pm.CheckVacuum())
|
|
if (_pmPT1.FeedBack > vacBase)
|
|
{
|
|
EV.PostWarningLog(Module, $"can not open slit valve, {_paramTarget} not in vacuum");
|
|
return Result.FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
ModuleName[] slitValveModules = new ModuleName[]
|
|
{
|
|
//ModuleName.LLA, ModuleName.LLB, ModuleName.PM1,
|
|
// ModuleName.PM2, ModuleName.PM3, ModuleName.PM4
|
|
ModuleName.LoadLock,ModuleName.PM1,
|
|
};
|
|
foreach (var slitValveModule in slitValveModules)
|
|
{
|
|
if (slitValveModule.ToString() == _paramTarget)
|
|
continue;
|
|
|
|
if (!_tm.CheckSlitValveClose(slitValveModule))
|
|
{
|
|
EV.PostWarningLog(Module, $"can not open slit valve {_paramTarget}, {slitValveModule} slit valve not closed, can not open at same time");
|
|
return Result.FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ModuleHelper.IsLoadLock(_paramTarget))
|
|
{
|
|
_needPressureBalance = SC.GetValue<bool>("TM.PressureBalance.EnableLL");
|
|
}
|
|
else if (ModuleHelper.IsPm(_paramTarget))
|
|
{
|
|
_needPressureBalance = SC.GetValue<bool>($"TM.PressureBalance.Enable{_paramTarget}");
|
|
}
|
|
else
|
|
{
|
|
EV.PostAlarmLog(Module, $"did not define balance enable option for {_paramTarget}");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
_maxPressureDiffOpenSlitValve = SC.GetValue<double>("TM.MaxPressureDiffOpenSlitValve");
|
|
_timeout = SC.GetValue<int>("System.SlitValveMotionTimeout");
|
|
_isAtmMode = SC.GetValue<bool>("System.IsATMMode");
|
|
|
|
_timeOutV70 = SC.GetValue<int>($"TM.V70Timeout");
|
|
_timeOutV85 = SC.GetValue<int>($"TM.V85Timeout");
|
|
_tmV77DelayTime= SC.GetValue<int>($"TM.OpenSlitValveDelayTimeAfterV77");
|
|
_tmMfcFlow = SC.GetValue<double>($"TM.MFCFlowWhenV77Open");
|
|
_preTransferPSUEnable = SC.GetValue<bool>($"PM.PM1.PreTransferPSUEnable");
|
|
|
|
Notify("Start");
|
|
|
|
return Result.RUN;
|
|
}
|
|
|
|
|
|
public override Result Monitor()
|
|
{
|
|
try
|
|
{
|
|
if (_isLockLock)
|
|
{
|
|
if (_paramIsOpen)
|
|
{
|
|
if (_userPidBalance)
|
|
{
|
|
ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
|
|
}
|
|
else
|
|
{
|
|
ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
|
|
}
|
|
|
|
if (_needPressureBalance && !_isAtmMode)
|
|
{
|
|
TimeDelay((int)RoutineStep.Delay2, 1);
|
|
ExecuteRoutine((int)RoutineStep.LLRoutine, _llVentTo);
|
|
SetTmToLoadLockVent((int)RoutineStep.OpenTMToLLVent, true, _tm, _paramTarget, _timeOutV85);
|
|
}
|
|
|
|
CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
|
|
}
|
|
SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
|
|
SetTmToLoadLockVent((int)RoutineStep.CloseTMToLLVent, false, _tm, _paramTarget, _timeOutV85);
|
|
}
|
|
else if (_isPMA)
|
|
{
|
|
if (_paramIsOpen)
|
|
{
|
|
SetPreTransfer((int)RoutineStep.SetPmPreTrasfer, _rotationStopTimeout);//旋转停止,加热停止
|
|
|
|
if (!_preTransferPSUEnable)
|
|
{
|
|
WaitPVTempratureBelowSet((int)RoutineStep.WaitPVTempBelowSet, 600);
|
|
}
|
|
WaitTempratureBelow900((int)RoutineStep.WaitTempBelow900, 600);
|
|
|
|
if (_needPressureBalance && !_isAtmMode)
|
|
{
|
|
if (_userPidBalance)
|
|
{
|
|
ExecuteRoutine((int)RoutineStep.ChamberBalance, _pidBalanceRoutine);
|
|
}
|
|
else
|
|
{
|
|
ExecuteRoutine((int)RoutineStep.ChamberBalance, _balanceRoutine);
|
|
}
|
|
|
|
SetTmMfc((int)RoutineStep.SetTmMfc, _tmMfcFlow);
|
|
SetPmToTmV70((int)RoutineStep.OpenTMToPMV70, true, _tm, _paramTarget, _timeOutV70);
|
|
SetSlowVentValve((int)RoutineStep.SetV77, _tm, _paramIsOpen, _timeout);
|
|
TimeDelay((int)RoutineStep.Delay1, _tmV77DelayTime); //5秒可配置
|
|
}
|
|
CheckPressureCondition((int)RoutineStep.CheckPressureCondition, _tm, _paramTarget);
|
|
}
|
|
|
|
SetSlitValve((int)RoutineStep.SetSlitValve, TMDevice, _paramTarget, _paramIsOpen, _timeout);
|
|
if (!_paramIsOpen)
|
|
{
|
|
//关闭闸板阀需要关闭V77
|
|
SetSlowVentValve((int)RoutineStep.SetV77Close, _tm, _paramIsOpen, _timeout);
|
|
}
|
|
SetPmToTmV70((int)RoutineStep.CloseTMToPMV70, false, _tm, _paramTarget, _timeOutV70);
|
|
TimeDelay((int)RoutineStep.Delay2, 2);
|
|
|
|
if (_paramIsOpen)
|
|
{
|
|
WaitPMIdle((int)RoutineStep.WaitPMIdle, 20);
|
|
SetConfinementRingDown((int)RoutineStep.SetConfinementRingDown, 80); //隔热罩下降
|
|
TimeDelay((int)RoutineStep.Delay3, 2);
|
|
}
|
|
|
|
|
|
if (!_paramIsOpen)
|
|
{
|
|
SetPostTransfer((int)RoutineStep.SetPostTransfer, _pmPostTrasferNeedEnableHeat);
|
|
TimeDelay((int)RoutineStep.Delay4, 2);
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (RoutineBreakException)
|
|
{
|
|
return Result.RUN;
|
|
}
|
|
catch (RoutineFaildException)
|
|
{
|
|
return Result.FAIL;
|
|
}
|
|
|
|
|
|
Notify("Finished");
|
|
|
|
return Result.DONE;
|
|
}
|
|
|
|
public override void Abort()
|
|
{
|
|
PMToTm_V70.TurnValve(false, out string reason);
|
|
_tm.CloseAllVentPumpValue();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 打开或关闭V85
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="isOpen"></param>
|
|
/// <param name="timeDelay"></param>
|
|
private void SetTmToLoadLockVent(int id,bool isOpen, TM tm, string module, int timeDelay)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify((isOpen ? "Open" : "Close") + " TM to LoadLock Vent");
|
|
|
|
if (!_tm.SetTmToLLVent(isOpen, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
double tmPressure = tm.ChamberPressure;
|
|
double targetPressure = 0.0;
|
|
if (ModuleHelper.IsLoadLock(_paramTarget))
|
|
{
|
|
targetPressure = _ll.ChamberPressure;
|
|
}
|
|
else
|
|
{
|
|
Stop($"{module} not define pressure condition");
|
|
return false;
|
|
}
|
|
|
|
return Math.Abs(tmPressure - targetPressure) <= _maxPressureDiffOpenSlitValve;
|
|
},
|
|
timeDelay * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"can not complete in {timeDelay} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetPmToTmV70(int id, bool isOpen, TM tm, string module, int timeDelay)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"set V70 " + (isOpen ? "Open" : "Close"));
|
|
|
|
if (!PMToTm_V70.TurnValve(isOpen, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
double tmPressure = tm.ChamberPressure;
|
|
double targetPressure = 0.0;
|
|
|
|
if (ModuleHelper.IsPm(_paramTarget))
|
|
{
|
|
targetPressure = DEVICE.GetDevice<SicPM.Devices.IoPressure>($"{module}.PT1").FeedBack;
|
|
}
|
|
else
|
|
{
|
|
Stop($"{module} not define pressure condition");
|
|
return false;
|
|
}
|
|
|
|
return Math.Abs(tmPressure - targetPressure) <= _maxPressureDiffOpenSlitValve;
|
|
},
|
|
timeDelay * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"can not complete in {timeDelay} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetSlitValve(int id, TM tm, string module, bool isOpen, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"set slit valve {module} " + (isOpen ? "Open" : "Close"));
|
|
|
|
if (!tm.SetSlitValve(ModuleHelper.Converter(module), isOpen, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return isOpen ? tm.CheckSlitValveOpen(ModuleHelper.Converter(module)) : tm.CheckSlitValveClose(ModuleHelper.Converter(module));
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"can not complete in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void CheckPressureCondition(int id, TM tm, string target)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"check pressure condition to open {target} slit valve");
|
|
|
|
double tmPressure = tm.ChamberPressure;
|
|
double targetPressure = 0.0;
|
|
if (ModuleHelper.IsLoadLock(_paramTarget))
|
|
{
|
|
targetPressure = _ll.ChamberPressure;
|
|
}
|
|
else if (ModuleHelper.IsPm(_paramTarget))
|
|
{
|
|
targetPressure = DEVICE.GetDevice<SicPM.Devices.IoPressure>($"{target}.PT1").FeedBack;
|
|
}
|
|
else
|
|
{
|
|
Stop($"{target} not define pressure condition");
|
|
return false;
|
|
}
|
|
|
|
double pressureDiff = Math.Abs(tmPressure - targetPressure);
|
|
if (pressureDiff > _maxPressureDiffOpenSlitValve)
|
|
{
|
|
Stop($"pressure difference {pressureDiff:F3} between TM and {target} exceed tolerance {_maxPressureDiffOpenSlitValve}");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetSlowVentValve(int id, SicTM tm, bool isOpen, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
string op = isOpen ? "Open" : "Close";
|
|
|
|
Notify($"{op} Slow Vent Valve");
|
|
|
|
if (!tm.SetSlowVentValve(isOpen, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return tm.CheckSlowVentValve(isOpen);
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"Set Slow Vent Valve timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetTmMfc(int id, double flow)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"Set TM MFC flow to {flow} ");
|
|
|
|
_tm.SetVentMfc(flow, out string reason);
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetConfinementRingUp(int id, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Set Confinement RingUp");
|
|
|
|
OP.DoOperation($"{_paramTarget}.ServoUp");
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
if (_naisServo != null)
|
|
{
|
|
return _confinementRing.IsUp && _naisServo.IsStbOff;
|
|
}
|
|
else
|
|
{
|
|
return _confinementRing.IsUp;
|
|
}
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"Set Confinement RingUp timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void WaitPMIdle(int id,int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
return true;
|
|
}, () =>
|
|
{
|
|
string pm1Status= DATA.Poll($"PM1.Status") == null ? "" : DATA.Poll($"PM1.Status").ToString();
|
|
return pm1Status == "ProcessIdle" || pm1Status == "Idle";
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"Wait PM Idle timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetConfinementRingDown(int id, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Set Confinement RingDown");
|
|
|
|
OP.DoOperation($"{_paramTarget}.ServoDown");
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return _confinementRing.IsDown;
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"Set Confinement RingDown timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void CheckConfinementIsDown(int id)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
_confinementIsDown = _confinementRing.IsDown;
|
|
|
|
Notify("Servo Statue is " + (_confinementIsDown ? "Down" : "Up"));
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
public void SetPostTransfer(int id,bool postTransferEnableHeat)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"Set PostTransfer");
|
|
|
|
OP.DoOperation($"{_paramTarget}.PostTransfer",new object[] { postTransferEnableHeat });
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void SetPreTransfer(int id, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Set PreTransfer");
|
|
OP.DoOperation($"{_paramTarget}.PreTransfer");
|
|
return true;
|
|
}, () =>
|
|
{
|
|
|
|
return _sicServo.ActualSpeedFeedback == 0;
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"Set PreTransfer timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
private void WaitTempratureBelow900(int id, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Wait DiHeaterTempBelow900CSW");
|
|
return true;
|
|
},
|
|
() =>
|
|
{
|
|
if (_pmIoInterLock != null)
|
|
{
|
|
return _pmIoInterLock.DiHeaterTempBelow900CSW;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
},
|
|
timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT)
|
|
{
|
|
Stop($"Wait PM Temprature below 900 timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
private void WaitPVTempratureBelowSet(int id, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Wait PV1Temp below{_pmPVInnerTempLimit}℃ and PV2Temp below{_pmPVMiddleTempLimit}℃ and PV3Temp below{_pmPVOuterTempLimit}℃");
|
|
return true;
|
|
},() =>
|
|
{
|
|
if (_tc1 != null && _pmPVOuterTempLimit>0 && _pmPVMiddleTempLimit>0 && _pmPVOuterTempLimit>0)
|
|
{
|
|
return _tc1.L1PVFeedBack < _pmPVInnerTempLimit && _tc1.L2PVFeedBack < _pmPVMiddleTempLimit && _tc1.L3PVFeedBack < _pmPVOuterTempLimit;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
},
|
|
timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT)
|
|
{
|
|
Stop($"Wait PM Temprature below 900 timeout, over {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|