412 lines
12 KiB
C#
412 lines
12 KiB
C#
using System;
|
|
using Aitex.Core.RT.Device;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.Routine;
|
|
using Aitex.Core.RT.SCCore;
|
|
using MECF.Framework.Common.Equipment;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.TMs;
|
|
|
|
namespace Mainframe.TMs
|
|
{
|
|
public class TMPumpWithTurboRoutine : ModuleRoutine, IRoutine
|
|
{
|
|
enum RoutineStep
|
|
{
|
|
CheckForelinePressure,
|
|
|
|
CheckPressureCondition,
|
|
|
|
RequestPumpDelay,
|
|
DryPump,
|
|
DryPumpDelay,
|
|
|
|
CloseDryPumpValve,
|
|
|
|
CloseDryPumpValveDelay,
|
|
|
|
OpenBackingValue,
|
|
|
|
TurboPumpOn,
|
|
|
|
WaitTurboPumpStable,
|
|
|
|
TurboPump,
|
|
TurboPumpDelay,
|
|
}
|
|
|
|
private double _pumpBasePressure;
|
|
private double _forelineBasePressure;
|
|
|
|
private int _waitForelineTimeout;
|
|
private int _pumpTimeout;
|
|
|
|
private int _pumpDelayTime;
|
|
private int _waitPumpTimeout;
|
|
|
|
private int _waitStableTimeout;
|
|
private int _turboCommandTimeout;
|
|
|
|
private double _turboPumpSwitchPressure;
|
|
|
|
private TM _tm;
|
|
|
|
private bool _isUnderDryPumpSwitchPressure;
|
|
|
|
public TMPumpWithTurboRoutine( )
|
|
{
|
|
Module = ModuleName.TM.ToString();
|
|
Name = "Pump";
|
|
_tm = DEVICE.GetDevice<TM>($"{ ModuleName.System.ToString()}.{ Module}");
|
|
}
|
|
|
|
public void Init()
|
|
{
|
|
|
|
}
|
|
|
|
public Result Start(params object[] objs)
|
|
{
|
|
Reset();
|
|
|
|
if (!SC.GetValue<bool>("TM.IsTurboPumpEnabled"))
|
|
{
|
|
EV.PostWarningLog(Module, $"do not support turbo pump function, please check the system config TM.IsTurboPumpEnabled");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
string reason;
|
|
if (!_tm.SetFastPumpValve(false, out reason) || !_tm.SetTurboPumpIsoValve(false, out reason)
|
|
|| !_tm.SetFastVentValve(false, out reason) || !_tm.SetTurboPumpBackingValve(false, out reason)
|
|
)
|
|
{
|
|
EV.PostAlarmLog(Module, $"Can not turn off valves, {reason}");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
_pumpBasePressure = SC.GetValue<double>("TM.PumpBasePressure");
|
|
_forelineBasePressure = SC.GetValue<double>("TM.ForelinePressureBase");
|
|
_turboPumpSwitchPressure = SC.GetValue<double>("TM.TurboPumpSwitchPressure");
|
|
_waitForelineTimeout = SC.GetValue<int>("TM.WaitForelinePressureTimeout");
|
|
_pumpTimeout = SC.GetValue<int>("TM.PumpTimeout");
|
|
_pumpDelayTime = SC.GetValue<int>("TM.PumpDelayTime");
|
|
_waitPumpTimeout = SC.GetValue<int>("TM.WaitPumpTimeout");
|
|
_waitStableTimeout = SC.GetValue<int>("TM.TurboPumpWaitStableTimeout");
|
|
_turboCommandTimeout = SC.GetValue<int>("TM.TurboPumpCommandTimeout");
|
|
|
|
_isUnderDryPumpSwitchPressure = false;
|
|
|
|
Notify("Start");
|
|
return Result.RUN;
|
|
}
|
|
|
|
|
|
public Result Monitor()
|
|
{
|
|
try
|
|
{
|
|
CheckPressureCondition((int) RoutineStep.CheckPressureCondition);
|
|
|
|
if (!_isUnderDryPumpSwitchPressure)
|
|
{
|
|
CheckForelinePressure((int)RoutineStep.CheckForelinePressure, _tm, _forelineBasePressure, _waitForelineTimeout);
|
|
|
|
//RequestPump((int)RoutineStep.RequestPump, _tm, _waitPumpTimeout);
|
|
|
|
//TimeDelay((int)RoutineStep.RequestPumpDelay, 1);
|
|
|
|
DryPumping((int)RoutineStep.DryPump, _tm, _turboPumpSwitchPressure, _pumpTimeout);
|
|
|
|
TimeDelay((int)RoutineStep.DryPumpDelay, _pumpDelayTime);
|
|
|
|
CloseDryPumpValve((int)RoutineStep.CloseDryPumpValve, _tm);
|
|
|
|
TimeDelay((int)RoutineStep.CloseDryPumpValveDelay, 2);
|
|
}
|
|
|
|
OpenBackingValue((int)RoutineStep.OpenBackingValue, _tm);
|
|
|
|
TurboPumpOn((int)RoutineStep.TurboPumpOn, _tm, _turboCommandTimeout);
|
|
|
|
WaitTurboPumpStable((int)RoutineStep.WaitTurboPumpStable, _tm, _waitStableTimeout);
|
|
|
|
TurboPumping((int)RoutineStep.TurboPump, _tm, _pumpBasePressure, _pumpTimeout);
|
|
|
|
TimeDelay((int)RoutineStep.TurboPumpDelay, _pumpDelayTime);
|
|
}
|
|
catch (RoutineBreakException)
|
|
{
|
|
return Result.RUN;
|
|
}
|
|
catch (RoutineFaildException)
|
|
{
|
|
return Result.FAIL;
|
|
}
|
|
|
|
|
|
Notify("Finished");
|
|
|
|
return Result.DONE;
|
|
}
|
|
|
|
public void Abort()
|
|
{
|
|
_tm.SetFastPumpValve(false, out _);
|
|
}
|
|
|
|
|
|
|
|
public void CheckPressureCondition(int id )
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"Check pressure under switch pressure");
|
|
|
|
_isUnderDryPumpSwitchPressure = _tm.ChamberPressure <= _turboPumpSwitchPressure;
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void CheckForelinePressure(int id, TM tm, double basePressure, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Check {tm.Name} foreline pressure ");
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return tm.ForelinePressure <= basePressure;
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
Stop($"{tm.Name} foreline pressure can not lower than {basePressure} in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
|
|
public void DryPumping(int id, TM tm, double basePressure, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Open {tm.Name} pump valve");
|
|
|
|
if (!tm.SetFastPumpValve(true, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return tm.ChamberPressure <= basePressure;
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
tm.SetFastPumpValve(false, out string _);
|
|
|
|
Stop($"{tm.Name} pressure can not pump to {basePressure} in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void TurboPumpOn(int id, TM tm, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"turn on {tm.Name} turbo pump");
|
|
|
|
if (!tm.TurboPumpOn())
|
|
{
|
|
Stop("Can not turn on turbo pump");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
if (tm.CheckTurboPumpError())
|
|
{
|
|
Stop($"{tm.Name} can not turn on turbo pump, pump error");
|
|
return null;
|
|
}
|
|
return tm.CheckTurboPumpOn() && (Elapsed > 2);
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
tm.TurboPumpOff();
|
|
|
|
Stop($"{tm.Name} can not turn on turbo pump in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void WaitTurboPumpStable(int id, TM tm, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"waiting {tm.Name} turbo pump stable");
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
if (tm.CheckTurboPumpError())
|
|
{
|
|
Stop($"{tm.Name} can not turn on turbo pump, pump error");
|
|
return null;
|
|
}
|
|
return tm.CheckTurboPumpOn() && tm.CheckTurboPumpStable();
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
tm.TurboPumpOff();
|
|
|
|
Stop($"{tm.Name} can not stable turbo pump in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void CloseDryPumpValve(int id, TM tm)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"Close {tm.Name} pump valves");
|
|
|
|
if (!_tm.SetFastPumpValve(false, out string reason) )
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void TurboPumping(int id, TM tm, double basePressure, int timeout)
|
|
{
|
|
Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
|
|
{
|
|
Notify($"Open {tm.Name} turbo pump valve");
|
|
|
|
if (!tm.SetTurboPumpIsoValve(true, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}, () =>
|
|
{
|
|
return tm.ChamberPressure <= basePressure;
|
|
|
|
}, timeout * 1000);
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else if (ret.Item2 == Result.TIMEOUT) //timeout
|
|
{
|
|
//tm.SetTurboPumpIsoValve(false, out string _);
|
|
|
|
Stop($"{tm.Name} pressure can not pump to {basePressure} in {timeout} seconds");
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
|
|
public void OpenBackingValue(int id, TM tm)
|
|
{
|
|
Tuple<bool, Result> ret = Execute(id, () =>
|
|
{
|
|
Notify($"Open {tm.Name} backing valve");
|
|
|
|
if (!_tm.SetTurboPumpBackingValve(true, out string reason))
|
|
{
|
|
Stop(reason);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
if (ret.Item1)
|
|
{
|
|
if (ret.Item2 == Result.FAIL)
|
|
{
|
|
throw (new RoutineFaildException());
|
|
}
|
|
else
|
|
throw (new RoutineBreakException());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|