PMEntity.cs 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Threading;
  4. using System.Diagnostics;
  5. using System.Linq;
  6. using Aitex.Core.Common;
  7. using Aitex.Core.RT.DataCenter;
  8. using Aitex.Core.RT.Device;
  9. using Aitex.Core.RT.Event;
  10. using Aitex.Core.RT.Fsm;
  11. using Aitex.Core.RT.OperationCenter;
  12. using Aitex.Core.RT.Routine;
  13. using Aitex.Core.RT.SCCore;
  14. using Aitex.Core.Util;
  15. using Aitex.Sorter.Common;
  16. using MECF.Framework.Common.DataCenter;
  17. using MECF.Framework.Common.Equipment;
  18. using MECF.Framework.Common.Schedulers;
  19. using MECF.Framework.Common.SubstrateTrackings;
  20. using Venus_Core;
  21. using Venus_RT.Devices;
  22. using Venus_RT.Modules;
  23. using Venus_RT.Modules.PMs;
  24. using MECF.Framework.Common.Routine;
  25. namespace Venus_RT.Modules.PMs
  26. {
  27. public class RecipeRunningInfo
  28. {
  29. public Guid InnerId { get; set; }
  30. public RecipeHead Head { get; set; }
  31. public List<RecipeStep> RecipeStepList { get; set; }
  32. public string RecipeName { get; set; }
  33. public DateTime BeginTime { get; set; }
  34. public DateTime EndTime { get; set; }
  35. public int StepNumber { get; set; }
  36. public string StepName { get; set; }
  37. public double StepTime { get; set; }
  38. public double StepElapseTime { get; set; }
  39. public double TotalTime { get; set; }
  40. public double TotalElapseTime { get; set; }
  41. }
  42. public class PMEntity : Entity, IModuleEntity
  43. {
  44. public enum MSG
  45. {
  46. Home,
  47. Transfer,
  48. PrepareTransfer,
  49. PostTransfer,
  50. Reset,
  51. Abort,
  52. Error,
  53. LaunchPump,
  54. LaunchTurboPump,
  55. Pump,
  56. Vent,
  57. PumpLoadLock,
  58. VentLoadLock,
  59. PurgeLoadLock,
  60. LoadLockLeakCheck,
  61. CyclePurge,
  62. GasLinePurge,
  63. Heat,
  64. TransferHandoff,
  65. StartTransfer,
  66. LeakCheck,
  67. GasLeakCheck,
  68. MoveLiftPin,
  69. MoveGuidePin,
  70. LLPlace,
  71. LLPick,
  72. Process,
  73. RunRecipe,
  74. PostProcess,
  75. RecipeSkipStep,
  76. RecipeUpdate,
  77. RecipeResume,
  78. RecipePause,
  79. RecipeAbort,
  80. PreProcess,
  81. AutoMode,
  82. ManualMode,
  83. LockLid,
  84. Online,
  85. Offline,
  86. GasFlow,
  87. StopGasFlow,
  88. RfPower,
  89. MFCVerification,
  90. MaxMsg
  91. }
  92. private readonly JetPM _chamber;
  93. public ModuleName Module { get; }
  94. public Action<bool, bool> TransferPrepared;
  95. private readonly PMHomeRoutine _home;
  96. private readonly StartDryPumpRoutine _startDryPumpRoutine;
  97. private readonly StartTurboPumpRoutine _startTurboPumpRoutine;
  98. private readonly VentRoutine _ventRoutine;
  99. private readonly PumpDownRoutine _pumpRoutine;
  100. private readonly LoadLockVentRoutine _ventLoadLockRoutine;
  101. private readonly LoadLockPumpRoutine _pumpLoadLockRoutine;
  102. private readonly LoadLockPurgeRoutine _purgeLoadLockRoutine;
  103. private readonly LoadLockLeakCheckRoutine _loadLockLeakCheckRoutine;
  104. private readonly PMPurgeRoutine _purgeRoutine;
  105. private readonly PMGaslinePurgeRoutine _gaslinePurgeRoutine;
  106. private readonly PMLeakCheckRoutine _leakCheckRoutine;
  107. private readonly GasBoxLeakCheckRoutine _gasBoxLeakCheckRoutine;
  108. private readonly LLPlaceRoutine _llPlaceRoutine;
  109. private readonly LLPickRoutine _llPickRoutine;
  110. private readonly PMProcessRoutine _processRoutine;
  111. private readonly GasFlowRoutine _gasFlowRoutine;
  112. private readonly RFPowerSwitchRoutine _rfPowerRoutine;
  113. private readonly PMGasVerificationRoutine _gasVerificationRoutine;
  114. public bool IsIdle
  115. {
  116. get { return fsm.State == (int)PMState.Idle; }
  117. }
  118. public bool IsError
  119. {
  120. get { return fsm.State == (int)PMState.Error; }
  121. }
  122. public bool IsInit
  123. {
  124. get { return fsm.State == (int)PMState.Init; }
  125. }
  126. public bool IsBusy
  127. {
  128. get { return !IsInit && !IsError && !IsIdle; }
  129. }
  130. public bool IsProcessing
  131. {
  132. get { return fsm.State == (int)PMState.PreProcess || fsm.State == (int)PMState.Processing || fsm.State == (int)PMState.PostProcess; }
  133. }
  134. public bool Check(int msg, out string reason, object[] objs)
  135. {
  136. reason = "";
  137. return true;
  138. }
  139. //
  140. private bool CheckToPostMessage(int msg, params object[] args)
  141. {
  142. if (!fsm.FindTransition(fsm.State, msg))
  143. {
  144. EV.PostWarningLog(Module.ToString(), $"{Module} is in { (PMState)fsm.State} state,can not do {(MSG)msg}");
  145. return false;
  146. }
  147. fsm.PostMsg(msg, args);
  148. return true;
  149. }
  150. public int Invoke(string function, params object[] args)
  151. {
  152. switch (function)
  153. {
  154. case "Home":
  155. CheckToPostMessage((int)MSG.Home);
  156. return (int)MSG.Home;
  157. }
  158. return (int)FSM_MSG.NONE;
  159. }
  160. public bool CheckAcked(int msg)
  161. {
  162. return fsm.CheckExecuted(msg);
  163. }
  164. public PMEntity(ModuleName module)
  165. {
  166. Module = module;
  167. _chamber = DEVICE.GetDevice<JetPM>(Module.ToString());
  168. _home = new PMHomeRoutine(_chamber);
  169. _startDryPumpRoutine = new StartDryPumpRoutine(_chamber);
  170. _startTurboPumpRoutine = new StartTurboPumpRoutine(_chamber);
  171. _ventRoutine = new VentRoutine(_chamber);
  172. _pumpRoutine = new PumpDownRoutine(_chamber);
  173. _ventLoadLockRoutine = new LoadLockVentRoutine(_chamber);
  174. _pumpLoadLockRoutine = new LoadLockPumpRoutine(_chamber);
  175. _purgeLoadLockRoutine = new LoadLockPurgeRoutine(_chamber);
  176. _loadLockLeakCheckRoutine = new LoadLockLeakCheckRoutine(_chamber);
  177. _purgeRoutine = new PMPurgeRoutine(_chamber);
  178. _gaslinePurgeRoutine = new PMGaslinePurgeRoutine(_chamber);
  179. _leakCheckRoutine = new PMLeakCheckRoutine(_chamber);
  180. _gasBoxLeakCheckRoutine = new GasBoxLeakCheckRoutine(_chamber);
  181. _llPlaceRoutine = new LLPlaceRoutine(_chamber);
  182. _llPickRoutine = new LLPickRoutine(_chamber, _ventLoadLockRoutine);
  183. _processRoutine = new PMProcessRoutine(_chamber, _pumpRoutine);
  184. _gasFlowRoutine = new GasFlowRoutine(_chamber);
  185. _rfPowerRoutine = new RFPowerSwitchRoutine(_chamber, true);
  186. _gasVerificationRoutine = new PMGasVerificationRoutine(_chamber);
  187. fsm = new StateMachine<PMEntity>(Module.ToString(), (int)PMState.Init, 50);
  188. //Idle
  189. EnterExitTransition((int)PMState.Idle, FnIdle, (int)FSM_MSG.NONE, null);
  190. EnterExitTransition<PMState, FSM_MSG>(PMState.Error, fEnterError, FSM_MSG.NONE, null);
  191. //Home
  192. //EnterExitTransition((int)PMState.Homing, FnEnterHome, (int)FSM_MSG.NONE, FnExitHome);
  193. AnyStateTransition(MSG.Error, FnError, PMState.Error);
  194. Transition(PMState.Init, FSM_MSG.TIMER, FnTimeout, PMState.Init);
  195. Transition(PMState.Init, MSG.Home, FnStartHome, PMState.Homing);
  196. Transition(PMState.Error, MSG.Home, FnStartHome, PMState.Homing);
  197. Transition(PMState.Idle, MSG.Home, FnStartHome, PMState.Homing);
  198. Transition(PMState.Homing, FSM_MSG.TIMER, FnMonitorHome, PMState.Idle);
  199. Transition(PMState.Idle, FSM_MSG.TIMER, FnIdleTimeout, PMState.Idle);
  200. Transition(PMState.Error, FSM_MSG.TIMER, FnErrorTimeout, PMState.Error);
  201. //Launch DryPump sequence
  202. Transition(PMState.Idle, MSG.LaunchPump, FnLaunchPump, PMState.LaunchingPump);
  203. Transition(PMState.LaunchingPump, FSM_MSG.TIMER, FnLaunchPumpTimeout, PMState.Idle);
  204. Transition(PMState.LaunchingPump, MSG.Abort, FnAbortStartPumping, PMState.Idle);
  205. //Launch TurboPump sequence
  206. Transition(PMState.Idle, MSG.LaunchTurboPump, FnLaunchTurboPump, PMState.LaunchingTurboPump);
  207. Transition(PMState.LaunchingTurboPump, FSM_MSG.TIMER, FnLaunchTurboPumpTimeout, PMState.Idle);
  208. Transition(PMState.LaunchingTurboPump, MSG.Abort, FnAbortStartTurboPumping, PMState.Idle);
  209. //vent sequence
  210. Transition(PMState.Idle, MSG.Vent, FnStartVent, PMState.Venting);
  211. Transition(PMState.Pumping, MSG.Vent, FnVentToPumping, PMState.Venting);
  212. Transition(PMState.Venting, FSM_MSG.TIMER, FnVentTimeout, PMState.Idle);
  213. Transition(PMState.Venting, MSG.Abort, FnAbortVent, PMState.Idle);
  214. //Pump sequence
  215. Transition(PMState.Idle, MSG.Pump, FnStartPumpDown, PMState.Pumping);
  216. Transition(PMState.Venting, MSG.Pump, FnVentToPumping, PMState.Pumping);
  217. Transition(PMState.Pumping, FSM_MSG.TIMER, FnPumpDownTimeout, PMState.Idle);
  218. Transition(PMState.Pumping, MSG.Abort, FnAbortPumping, PMState.Idle);
  219. //Pump Loadlock sequence
  220. Transition(PMState.Idle, MSG.PumpLoadLock, FnStartPumpDownLoadLock, PMState.PumpingLoadLock);
  221. Transition(PMState.VentingLoadLock, MSG.PumpLoadLock, FnVentLoadLockToPumpingLoadLock, PMState.PumpingLoadLock);
  222. Transition(PMState.PumpingLoadLock, FSM_MSG.TIMER, FnPumpDownLoadLockTimeout, PMState.Idle);
  223. Transition(PMState.PumpingLoadLock, MSG.Abort, FnAbortPumpingLoadLock, PMState.Idle);
  224. //Vent Loadlock sequence
  225. Transition(PMState.Idle, MSG.VentLoadLock, FnStartVentLoadlock, PMState.VentingLoadLock);
  226. Transition(PMState.PumpingLoadLock, MSG.VentLoadLock, FnPumpingLoadLockToVentLoadLock, PMState.VentingLoadLock);
  227. Transition(PMState.VentingLoadLock, FSM_MSG.TIMER, FnVentLoadLockTimeout, PMState.Idle);
  228. Transition(PMState.VentingLoadLock, MSG.Abort, FnAbortVentLoadLock, PMState.Idle);
  229. // Purge LoadLock sequence
  230. Transition(PMState.Idle, MSG.PurgeLoadLock, FnStartPurgeLoadlock, PMState.PurgingLoadLock);
  231. Transition(PMState.PurgingLoadLock, FSM_MSG.TIMER, FnPurgeLoadLockTimeout, PMState.Idle);
  232. Transition(PMState.PurgingLoadLock, MSG.Abort, FnAbortPurgeLoadLock, PMState.Idle);
  233. //LoadLock Leak check sequence
  234. Transition(PMState.Idle, MSG.LoadLockLeakCheck, FnStartLoadLockLeakCheck, PMState.LoadLockLeakCheck);
  235. Transition(PMState.LoadLockLeakCheck, FSM_MSG.TIMER, FnLoadLockLeakCheckTimeout, PMState.Idle);
  236. Transition(PMState.LoadLockLeakCheck, MSG.Abort, FnAbortLoadLockLeakCheck, PMState.Idle);
  237. // PM Purge sequence
  238. Transition(PMState.Idle, MSG.CyclePurge, FnStartPurge, PMState.Purging);
  239. Transition(PMState.Purging, FSM_MSG.TIMER, FnPurgeTimeout, PMState.Idle);
  240. Transition(PMState.Purging, MSG.Abort, FnAbortPurge, PMState.Idle);
  241. // PM GasLine Purge sequence
  242. Transition(PMState.Idle, MSG.GasLinePurge, FnStartGasLinePurge, PMState.GasLinePurge);
  243. Transition(PMState.GasLinePurge, FSM_MSG.TIMER, FnGasLinePurgeTimeout, PMState.Idle);
  244. Transition(PMState.GasLinePurge, MSG.Abort, FnAbortGasLinePurge, PMState.Idle);
  245. //PM Leak check sequence
  246. Transition(PMState.Idle, MSG.LeakCheck, FnStartPMLeakCheck, PMState.LeakCheck);
  247. Transition(PMState.LeakCheck, FSM_MSG.TIMER, FnPMLeakCheckTimeout, PMState.Idle);
  248. Transition(PMState.LeakCheck, MSG.Abort, FnAbortPMLeakCheck, PMState.Idle);
  249. //PM Leak check sequence
  250. Transition(PMState.Idle, MSG.GasLeakCheck, FnStartGasBoxLeakCheck, PMState.GasBoxLeakCheck);
  251. Transition(PMState.GasBoxLeakCheck, FSM_MSG.TIMER, FnGasBoxLeakCheckTimeout, PMState.Idle);
  252. Transition(PMState.GasBoxLeakCheck, MSG.Abort, FnAbortGasBoxLeakCheck, PMState.Idle);
  253. // PlaceWafer from LoadLock Arm sequence
  254. Transition(PMState.Idle, MSG.LLPlace, FnStartLLPlace, PMState.LLPlacing);
  255. Transition(PMState.LLPlacing, FSM_MSG.TIMER, FnLLPlaceTimeout, PMState.Idle);
  256. Transition(PMState.LLPlacing, MSG.Abort, FnAbortLLPlace, PMState.Idle);
  257. // PickWafer to LoadLock Arm sequence
  258. Transition(PMState.Idle, MSG.LLPick, FnStartLLPick, PMState.LLPicking);
  259. Transition(PMState.LLPicking, FSM_MSG.TIMER, FnLLPickTimeout, PMState.Idle);
  260. Transition(PMState.LLPicking, MSG.Abort, FnAbortLLPick, PMState.Idle);
  261. // Process
  262. Transition(PMState.Idle, MSG.RunRecipe, FnRunRecipe, PMState.Processing);
  263. Transition(PMState.Processing, FSM_MSG.TIMER, FnProcessTimeout, PMState.Idle);
  264. Transition(PMState.Processing, MSG.Abort, FnAbortProcess, PMState.Idle);
  265. // Gas Flow sequence
  266. Transition(PMState.Idle, MSG.GasFlow, FnStartGasFlow, PMState.GasFlowing);
  267. Transition(PMState.GasFlowing, MSG.GasFlow, FnStartGasFlow, PMState.GasFlowing);
  268. Transition(PMState.GasFlowing, FSM_MSG.TIMER, FnGasFlowTimeout, PMState.Idle);
  269. Transition(PMState.GasFlowing, MSG.StopGasFlow, FnStopGasFlow, PMState.Idle);
  270. Transition(PMState.GasFlowing, MSG.Abort, FnAbortGasFlow, PMState.Idle);
  271. //RF Power sequence
  272. Transition(PMState.Idle, MSG.RfPower, FnStartRfPower, PMState.RfPowering);
  273. Transition(PMState.GasFlowing, MSG.RfPower, FnStartRfPower, PMState.RfPowering);
  274. Transition(PMState.RfPowering, FSM_MSG.TIMER, FnRfPowerTimeout, PMState.Idle);
  275. Transition(PMState.RfPowering, MSG.Abort, FnAbortRfPower, PMState.Idle);
  276. //MFC verification
  277. Transition(PMState.Idle, MSG.MFCVerification, FnStartMFCVerification, PMState.MFCVerification);
  278. Transition(PMState.MFCVerification, FSM_MSG.TIMER, FnMFCVerificationTimeout, PMState.Idle);
  279. Transition(PMState.MFCVerification, MSG.Abort, FnAbortMFCVerification, PMState.Idle);
  280. Running = true;
  281. WaferManager.Instance.SubscribeLocation(ModuleName.PMA, 1);
  282. WaferManager.Instance.SubscribeLocation(ModuleName.LLA, 1);
  283. }
  284. protected override bool Init()
  285. {
  286. DATA.Subscribe($"{Module}.FsmState", () => ((PMState)fsm.State).ToString());
  287. DATA.Subscribe($"{Module}.LoadLockPurge.PurgeCounter", () => _purgeLoadLockRoutine.PurgeCounter);
  288. OP.Subscribe($"{Module}.{RtOperation.LeakCheck}", (cmd, args) => CheckToPostMessage((int)MSG.LeakCheck, args));
  289. OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home));
  290. OP.Subscribe($"{Module}.{RtOperation.StartPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchPump));
  291. OP.Subscribe($"{Module}.{RtOperation.StartTurboPump}", (cmd, args) => CheckToPostMessage((int)MSG.LaunchTurboPump));
  292. OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump));
  293. OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.CyclePurge));
  294. OP.Subscribe($"{Module}.{RtOperation.RfPower}", (cmd, args) => CheckToPostMessage((int)MSG.RfPower));
  295. OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent));
  296. OP.Subscribe($"{Module}.{RtOperation.VentLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.VentLoadLock));
  297. OP.Subscribe($"{Module}.{RtOperation.PurgeLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PurgeLoadLock));
  298. OP.Subscribe($"{Module}.{RtOperation.PumpLoadLock}", (cmd, args) => CheckToPostMessage((int)MSG.PumpLoadLock));
  299. OP.Subscribe($"{Module}.{RtOperation.Reset}", (cmd, args) => CheckToPostMessage((int)MSG.Reset));
  300. OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort));
  301. return true;
  302. }
  303. private bool FnIdle(object[] objs)
  304. {
  305. Running = false;
  306. return true;
  307. }
  308. private bool fEnterError(object[] objs)
  309. {
  310. return true;
  311. }
  312. private bool FnError(object[] objs)
  313. {
  314. Running = false;
  315. if (((PMState)fsm.State == PMState.Processing) || ((PMState)fsm.State == PMState.PreProcess)
  316. || ((PMState)fsm.State == PMState.Homing) || ((PMState)fsm.State == PMState.LoadProcessRecipe))
  317. return false;
  318. if (IsProcessing)
  319. {
  320. WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Failed);
  321. }
  322. return true;
  323. }
  324. private bool FnTimeout(object[] objs)
  325. {
  326. _debugRoutine();
  327. return true;
  328. }
  329. private bool FnIdleTimeout(object[] objs)
  330. {
  331. _debugRoutine();
  332. return true;
  333. }
  334. private bool FnErrorTimeout(object[] objs)
  335. {
  336. _debugRoutine();
  337. return true;
  338. }
  339. private bool FnStartHome(object[] objs)
  340. {
  341. return _home.Start() == RState.Running;
  342. }
  343. private bool FnMonitorHome(object[] objs)
  344. {
  345. RState ret = _home.Monitor();
  346. if (ret == RState.Failed || ret == RState.Timeout)
  347. {
  348. PostMsg(MSG.Error);
  349. return false;
  350. }
  351. return ret == RState.End;
  352. }
  353. private bool FnLaunchPump(object[] param)
  354. {
  355. return _startDryPumpRoutine.Start() == RState.Running;
  356. }
  357. private bool FnLaunchPumpTimeout(object[] param)
  358. {
  359. RState ret = _startDryPumpRoutine.Monitor();
  360. if (ret == RState.Failed || ret == RState.Timeout)
  361. {
  362. PostMsg(MSG.Error);
  363. return false;
  364. }
  365. return ret == RState.End;
  366. }
  367. private bool FnAbortStartPumping(object[] param)
  368. {
  369. _startDryPumpRoutine.Abort();
  370. return true;
  371. }
  372. private bool FnLaunchTurboPump(object[] param)
  373. {
  374. return _startTurboPumpRoutine.Start() == RState.Running;
  375. }
  376. private bool FnLaunchTurboPumpTimeout(object[] param)
  377. {
  378. RState ret = _startTurboPumpRoutine.Monitor();
  379. if (ret == RState.Failed || ret == RState.Timeout)
  380. {
  381. PostMsg(MSG.Error);
  382. return false;
  383. }
  384. return ret == RState.End;
  385. }
  386. private bool FnAbortStartTurboPumping(object[] param)
  387. {
  388. _startTurboPumpRoutine.Abort();
  389. return true;
  390. }
  391. private bool FnStartVent(object[] param)
  392. {
  393. return _ventRoutine.Start() == RState.Running;
  394. }
  395. private bool FnVentTimeout(object[] param)
  396. {
  397. RState ret = _ventRoutine.Monitor();
  398. if (ret == RState.Failed || ret == RState.Timeout)
  399. {
  400. PostMsg(MSG.Error);
  401. return false;
  402. }
  403. return ret == RState.End;
  404. }
  405. private bool FnVentToPumping(object[] param)
  406. {
  407. _ventRoutine.Abort();
  408. return true; // FnStartPumpDown(param);
  409. }
  410. private bool FnAbortVent(object[] param)
  411. {
  412. _ventRoutine.Abort();
  413. return true;
  414. }
  415. private bool FnStartPumpDown(object[] param)
  416. {
  417. return _pumpRoutine.Start() == RState.Running;
  418. }
  419. private bool FnPumpDownTimeout(object[] param)
  420. {
  421. RState ret = _pumpRoutine.Monitor();
  422. if (ret == RState.Failed || ret == RState.Timeout)
  423. {
  424. PostMsg(MSG.Error);
  425. return false;
  426. }
  427. return ret == RState.End;
  428. }
  429. private bool FnAbortPumping(object[] param)
  430. {
  431. _pumpRoutine.Abort();
  432. return true;
  433. }
  434. private bool FnStartVentLoadlock(object[] param)
  435. {
  436. return _ventLoadLockRoutine.Start() == RState.Running;
  437. }
  438. private bool FnVentLoadLockTimeout(object[] param)
  439. {
  440. RState ret = _ventLoadLockRoutine.Monitor();
  441. if (ret == RState.Failed || ret == RState.Timeout)
  442. {
  443. PostMsg(MSG.Error);
  444. return false;
  445. }
  446. return ret == RState.End;
  447. }
  448. private bool FnVentLoadLockToPumpingLoadLock(object[] param)
  449. {
  450. _ventLoadLockRoutine.Abort();
  451. return FnStartPumpDownLoadLock(param);
  452. }
  453. private bool FnAbortVentLoadLock(object[] param)
  454. {
  455. _ventLoadLockRoutine.Abort();
  456. return true;
  457. }
  458. private bool FnStartPumpDownLoadLock(object[] param)
  459. {
  460. return _pumpLoadLockRoutine.Start() == RState.Running;
  461. }
  462. private bool FnPumpDownLoadLockTimeout(object[] param)
  463. {
  464. RState ret = _pumpLoadLockRoutine.Monitor();
  465. if (ret == RState.Failed || ret == RState.Timeout)
  466. {
  467. PostMsg(MSG.Error);
  468. return false;
  469. }
  470. return ret == RState.End;
  471. }
  472. private bool FnPumpingToVent(object[] param)
  473. {
  474. _pumpRoutine.Abort();
  475. return FnStartVent(param);
  476. }
  477. private bool FnPumpingLoadLockToVentLoadLock(object[] param)
  478. {
  479. _pumpLoadLockRoutine.Abort();
  480. return FnStartVentLoadlock(param);
  481. }
  482. private bool FnAbortPumpingLoadLock(object[] param)
  483. {
  484. _pumpLoadLockRoutine.Abort();
  485. return true;
  486. }
  487. private bool FnStartPurgeLoadlock(object[] param)
  488. {
  489. return _purgeLoadLockRoutine.Start() == RState.Running;
  490. }
  491. private bool FnPurgeLoadLockTimeout(object[] param)
  492. {
  493. RState ret = _purgeLoadLockRoutine.Monitor();
  494. if (ret == RState.Failed || ret == RState.Timeout)
  495. {
  496. PostMsg(MSG.Error);
  497. return false;
  498. }
  499. return ret == RState.End;
  500. }
  501. private bool FnAbortPurgeLoadLock(object[] param)
  502. {
  503. _purgeLoadLockRoutine.Abort();
  504. return true;
  505. }
  506. private bool FnStartLoadLockLeakCheck(object[] param)
  507. {
  508. return _loadLockLeakCheckRoutine.Start() == RState.Running;
  509. }
  510. private bool FnLoadLockLeakCheckTimeout(object[] param)
  511. {
  512. RState ret = _loadLockLeakCheckRoutine.Monitor();
  513. if (ret == RState.Failed || ret == RState.Timeout)
  514. {
  515. PostMsg(MSG.Error);
  516. return false;
  517. }
  518. return ret == RState.End;
  519. }
  520. private bool FnAbortLoadLockLeakCheck(object[] param)
  521. {
  522. _loadLockLeakCheckRoutine.Abort();
  523. return true;
  524. }
  525. private bool FnStartPurge(object[] param)
  526. {
  527. return _purgeRoutine.Start() == RState.Running;
  528. }
  529. private bool FnPurgeTimeout(object[] param)
  530. {
  531. RState ret = _purgeRoutine.Monitor();
  532. if (ret == RState.Failed || ret == RState.Timeout)
  533. {
  534. PostMsg(MSG.Error);
  535. return false;
  536. }
  537. return ret == RState.End;
  538. }
  539. private bool FnAbortPurge(object[] param)
  540. {
  541. _purgeRoutine.Abort();
  542. return true;
  543. }
  544. private bool FnStartGasLinePurge(object[] param)
  545. {
  546. return _gaslinePurgeRoutine.Start() == RState.Running;
  547. }
  548. private bool FnGasLinePurgeTimeout(object[] param)
  549. {
  550. RState ret = _gaslinePurgeRoutine.Monitor();
  551. if (ret == RState.Failed || ret == RState.Timeout)
  552. {
  553. PostMsg(MSG.Error);
  554. return false;
  555. }
  556. return ret == RState.End;
  557. }
  558. private bool FnAbortGasLinePurge(object[] param)
  559. {
  560. _gaslinePurgeRoutine.Abort();
  561. return true;
  562. }
  563. private bool FnStartPMLeakCheck(object[] param)
  564. {
  565. return _leakCheckRoutine.Start() == RState.Running;
  566. }
  567. private bool FnPMLeakCheckTimeout(object[] param)
  568. {
  569. RState ret = _leakCheckRoutine.Monitor();
  570. if (ret == RState.Failed || ret == RState.Timeout)
  571. {
  572. PostMsg(MSG.Error);
  573. return false;
  574. }
  575. return ret == RState.End;
  576. }
  577. private bool FnAbortPMLeakCheck(object[] param)
  578. {
  579. _leakCheckRoutine.Abort();
  580. return true;
  581. }
  582. private bool FnStartGasBoxLeakCheck(object[] param)
  583. {
  584. return _gasBoxLeakCheckRoutine.Start() == RState.Running;
  585. }
  586. private bool FnGasBoxLeakCheckTimeout(object[] param)
  587. {
  588. RState ret = _gasBoxLeakCheckRoutine.Monitor();
  589. if (ret == RState.Failed || ret == RState.Timeout)
  590. {
  591. PostMsg(MSG.Error);
  592. return false;
  593. }
  594. return ret == RState.End;
  595. }
  596. private bool FnAbortGasBoxLeakCheck(object[] param)
  597. {
  598. _gasBoxLeakCheckRoutine.Abort();
  599. return true;
  600. }
  601. private bool FnStartLLPlace(object[] param)
  602. {
  603. return _llPlaceRoutine.Start() == RState.Running;
  604. }
  605. private bool FnLLPlaceTimeout(object[] param)
  606. {
  607. RState ret = _llPlaceRoutine.Monitor();
  608. if (ret == RState.Failed || ret == RState.Timeout)
  609. {
  610. PostMsg(MSG.Error);
  611. return false;
  612. }
  613. return ret == RState.End;
  614. }
  615. private bool FnAbortLLPlace(object[] param)
  616. {
  617. _llPlaceRoutine.Abort();
  618. return true;
  619. }
  620. private bool FnStartLLPick(object[] param)
  621. {
  622. return _llPickRoutine.Start() == RState.Running;
  623. }
  624. private bool FnLLPickTimeout(object[] param)
  625. {
  626. RState ret = _llPickRoutine.Monitor();
  627. if (ret == RState.Failed || ret == RState.Timeout)
  628. {
  629. PostMsg(MSG.Error);
  630. return false;
  631. }
  632. return ret == RState.End;
  633. }
  634. private bool FnAbortLLPick(object[] param)
  635. {
  636. _llPickRoutine.Abort();
  637. return true;
  638. }
  639. private bool FnRunRecipe(object[] param)
  640. {
  641. return _processRoutine.Start(param) == RState.Running;
  642. }
  643. private bool FnProcessTimeout(object[] param)
  644. {
  645. RState ret = _processRoutine.Monitor();
  646. if (ret == RState.Failed || ret == RState.Timeout)
  647. {
  648. PostMsg(MSG.Error);
  649. return false;
  650. }
  651. return ret == RState.End;
  652. }
  653. private bool FnAbortProcess(object[] param)
  654. {
  655. _processRoutine.Abort();
  656. return true;
  657. }
  658. private bool FnStartGasFlow(object[] param)
  659. {
  660. return _gasFlowRoutine.Start(param) == RState.Running;
  661. }
  662. private bool FnGasFlowTimeout(object[] param)
  663. {
  664. RState ret = _gasFlowRoutine.Monitor();
  665. if (ret == RState.Failed || ret == RState.Timeout)
  666. {
  667. PostMsg(MSG.Error);
  668. return false;
  669. }
  670. return ret == RState.End;
  671. }
  672. private bool FnStopGasFlow(object[] param)
  673. {
  674. _gasFlowRoutine.Abort();
  675. return true;
  676. }
  677. private bool FnAbortGasFlow(object[] param)
  678. {
  679. _gasFlowRoutine.Abort();
  680. return true;
  681. }
  682. private bool FnStartRfPower(object[] param)
  683. {
  684. return _rfPowerRoutine.Start(param) == RState.Running;
  685. }
  686. private bool FnRfPowerTimeout(object[] param)
  687. {
  688. RState ret = _rfPowerRoutine.Monitor();
  689. if (ret == RState.Failed || ret == RState.Timeout)
  690. {
  691. PostMsg(MSG.Error);
  692. return false;
  693. }
  694. return ret == RState.End;
  695. }
  696. private bool FnAbortRfPower(object[] param)
  697. {
  698. _rfPowerRoutine.Abort();
  699. if(_gasFlowRoutine._gasStatus)
  700. {
  701. _gasFlowRoutine.StopFlow();
  702. }
  703. return true;
  704. }
  705. private bool FnStartMFCVerification(object[] param)
  706. {
  707. _gasVerificationRoutine.Init((string)param[0], (double)param[1], (int)param[2]);
  708. return _gasVerificationRoutine.Start(param) == RState.Running;
  709. }
  710. private bool FnMFCVerificationTimeout(object[] param)
  711. {
  712. RState ret = _gasVerificationRoutine.Monitor();
  713. if (ret == RState.Failed || ret == RState.Timeout)
  714. {
  715. PostMsg(MSG.Error);
  716. return false;
  717. }
  718. return ret == RState.End;
  719. }
  720. private bool FnAbortMFCVerification(object[] param)
  721. {
  722. _gasVerificationRoutine.Abort();
  723. return true;
  724. }
  725. private void _debugRoutine()
  726. {
  727. int flag = 0;
  728. // Test Home routine
  729. if (flag == 1)
  730. {
  731. PostMsg(MSG.Home);
  732. }
  733. else if (flag == 2)
  734. {
  735. PostMsg(MSG.Vent);
  736. }
  737. else if (flag == 3)
  738. {
  739. PostMsg(MSG.Pump);
  740. }
  741. else if(flag == 4)
  742. {
  743. PostMsg(MSG.PumpLoadLock);
  744. }
  745. else if(flag == 5)
  746. {
  747. PostMsg(MSG.VentLoadLock);
  748. }
  749. else if(flag == 6)
  750. {
  751. PostMsg(MSG.PurgeLoadLock);
  752. }
  753. else if(flag == 7)
  754. {
  755. PostMsg(MSG.LaunchPump);
  756. }
  757. else if(flag == 8)
  758. {
  759. PostMsg(MSG.LaunchTurboPump);
  760. }
  761. else if(flag == 9)
  762. {
  763. PostMsg(MSG.LoadLockLeakCheck);
  764. }
  765. else if(flag == 10)
  766. {
  767. PostMsg(MSG.CyclePurge);
  768. }
  769. else if(flag == 11)
  770. {
  771. PostMsg(MSG.GasLinePurge);
  772. }
  773. else if(flag == 12)
  774. {
  775. PostMsg(MSG.LeakCheck);
  776. }
  777. else if(flag == 13)
  778. {
  779. PostMsg(MSG.GasLeakCheck);
  780. }
  781. else if(flag == 14)
  782. {
  783. PostMsg(MSG.LLPlace);
  784. }
  785. else if(flag == 15)
  786. {
  787. PostMsg(MSG.LLPick);
  788. }
  789. else if(flag == 16)
  790. {
  791. PostMsg(MSG.RunRecipe, "7777");
  792. }
  793. else if(flag == 17)
  794. {
  795. PostMsg(MSG.MFCVerification, "MFC2", (double)50, 10);
  796. }
  797. }
  798. }
  799. }