LLEntity.cs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478
  1. using System;
  2. using Aitex.Core.Util;
  3. using Aitex.Core.RT.Fsm;
  4. using Aitex.Core.RT.Log;
  5. using MECF.Framework.Common.Equipment;
  6. using MECF.Framework.Common.SubstrateTrackings;
  7. using Venus_RT.Modules.TM;
  8. using Venus_RT.Devices;
  9. using Venus_Core;
  10. using Aitex.Core.RT.DataCenter;
  11. using Aitex.Core.RT.OperationCenter;
  12. using Aitex.Core.RT.Device;
  13. using Aitex.Core.RT.SCCore;
  14. namespace Venus_RT.Modules
  15. {
  16. class LLEntity : Entity, IEntity, IModuleEntity
  17. {
  18. public enum LLStatus
  19. {
  20. Not_Ready,
  21. Ready_For_TM,
  22. Ready_For_EFEM,
  23. }
  24. public enum STATE
  25. {
  26. Unknown,
  27. Init,
  28. Initializing,
  29. Idle,
  30. Error,
  31. Pumping,
  32. Venting,
  33. Purging,
  34. LeakCheck,
  35. Prepare_For_TM,
  36. Prepare_For_EFEM,
  37. Ready_For_TM,
  38. Ready_For_EFEM,
  39. }
  40. public enum MSG
  41. {
  42. Home,
  43. Online,
  44. Offline,
  45. Pump,
  46. Vent,
  47. Purge,
  48. CyclePurge,
  49. LeakCheck,
  50. Prepare_TM,
  51. Prepare_EFEM,
  52. TM_Exchange_Ready,
  53. EFEM_Exchange_Ready,
  54. Error,
  55. Abort,
  56. }
  57. public ModuleName Module { get; private set; }
  58. public LLStatus Status { get; private set; }
  59. public bool Check(int msg, out string reason, params object[] args)
  60. {
  61. throw new NotImplementedException();
  62. }
  63. public bool IsIdle
  64. {
  65. get { return fsm.State == (int)STATE.Idle; }
  66. }
  67. public bool IsError
  68. {
  69. get { return fsm.State == (int)STATE.Error; }
  70. }
  71. public bool IsInit
  72. {
  73. get { return fsm.State == (int)STATE.Unknown || fsm.State == (int)STATE.Init; }
  74. }
  75. public bool IsBusy
  76. {
  77. get { return !IsInit && !IsError && !IsIdle; }
  78. }
  79. public bool IsOnline { get; internal set; }
  80. private readonly JetTM _JetTM;
  81. private readonly MFPumpRoutine _pumpingRoutine;
  82. private readonly MFVentRoutine _ventingRoutine;
  83. private readonly MFLeakCheckRoutine _leakCheckRoutine;
  84. private readonly MFPurgeRoutine _purgeRoutine;
  85. public LLEntity(ModuleName module)
  86. {
  87. Module = module;
  88. //_JetTM = Singleton<JetTM>.Instance;
  89. _JetTM= DEVICE.GetDevice<JetTM>("TM");
  90. _pumpingRoutine = new MFPumpRoutine(_JetTM, Module);
  91. _ventingRoutine = new MFVentRoutine(_JetTM, Module);
  92. _leakCheckRoutine = new MFLeakCheckRoutine(_JetTM, Module);
  93. _purgeRoutine = new MFPurgeRoutine(_JetTM, Module);
  94. var soltCount= SC.GetValue<int>($"{module.ToString()}.SlotNumber");
  95. WaferManager.Instance.SubscribeLocation(Module, soltCount);
  96. InitFsmMap();
  97. }
  98. protected override bool Init()
  99. {
  100. OP.Subscribe($"{Module}.Home", (cmd, args) => CheckToPostMessage((int)MSG.Home));
  101. OP.Subscribe($"{Module}.{RtOperation.Pump}", (cmd, args) => CheckToPostMessage((int)MSG.Pump));
  102. OP.Subscribe($"{Module}.{RtOperation.Vent}", (cmd, args) => CheckToPostMessage((int)MSG.Vent));
  103. OP.Subscribe($"{Module}.{RtOperation.Purge}", (cmd, args) => CheckToPostMessage((int)MSG.Purge));
  104. OP.Subscribe($"{Module}.{RtOperation.Abort}", (cmd, args) => CheckToPostMessage((int)MSG.Abort));
  105. DATA.Subscribe($"{Module}.FsmState", () => (((STATE)fsm.State).ToString()));
  106. DATA.Subscribe($"{Module}.FsmPrevState", () => (((PMState)fsm.PrevState).ToString()));
  107. DATA.Subscribe($"{Module}.FsmLastMessage", () => (((MSG)fsm.LastMsg).ToString()));
  108. return true;
  109. }
  110. private void InitFsmMap()
  111. {
  112. fsm = new StateMachine<LLEntity>(Module.ToString(), (int)STATE.Init, 50);
  113. fsm.EnableRepeatedMsg(true);
  114. EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_TM, fnEnterTMReady, FSM_MSG.NONE, fnExitTMReady);
  115. EnterExitTransition<STATE, FSM_MSG>(STATE.Ready_For_EFEM, fnEnterEFEMReady, FSM_MSG.NONE, fnExitEFEMReady);
  116. //AnyStateTransition(FSM_MSG.TIMER, fnMonitor, FSM_STATE.SAME);
  117. AnyStateTransition(MSG.Error, fnError, STATE.Error);
  118. AnyStateTransition(MSG.Online, fnOnline, FSM_STATE.SAME);
  119. AnyStateTransition(MSG.Offline, fnOffline, FSM_STATE.SAME);
  120. AnyStateTransition(MSG.Home, fnHome, STATE.Initializing);
  121. // Home
  122. Transition(STATE.Initializing, FSM_MSG.TIMER, fnHoming, STATE.Idle);
  123. Transition(STATE.Idle, FSM_MSG.TIMER, fnMonitor, STATE.Idle);
  124. Transition(STATE.Init, FSM_MSG.TIMER, fnMonitor, STATE.Init);
  125. //vent sequence
  126. Transition(STATE.Idle, MSG.Vent, FnStartVent, STATE.Venting);
  127. Transition(STATE.Venting, FSM_MSG.TIMER, FnVentTimeout, STATE.Idle);
  128. Transition(STATE.Venting, MSG.Abort, FnAbortVent, STATE.Idle);
  129. //Pump sequence
  130. Transition(STATE.Idle, MSG.Pump, FnStartPump, STATE.Pumping);
  131. Transition(STATE.Pumping, FSM_MSG.TIMER, FnPumpTimeout, STATE.Idle);
  132. Transition(STATE.Pumping, MSG.Abort, FnAbortPump, STATE.Idle);
  133. // Purge sequence
  134. Transition(STATE.Idle, MSG.Purge, FnStartPurge, STATE.Purging);
  135. Transition(STATE.Purging, FSM_MSG.TIMER, FnPurgeTimeout, STATE.Idle);
  136. Transition(STATE.Purging, MSG.Abort, FnAbortPurge, STATE.Idle);
  137. // Leak check sequence
  138. Transition(STATE.Idle, MSG.LeakCheck, FnStartLeakCheck, STATE.LeakCheck);
  139. Transition(STATE.LeakCheck, FSM_MSG.TIMER, FnLeakCheckTimeout, STATE.Idle);
  140. Transition(STATE.LeakCheck, MSG.Abort, FnAbortLeakCheck, STATE.Idle);
  141. // Prepare TM Transfer
  142. Transition(STATE.Idle, MSG.Prepare_TM, FnStartPrepareTM, STATE.Prepare_For_TM);
  143. Transition(STATE.Prepare_For_TM, FSM_MSG.TIMER, FnPreparaTMTimeout, STATE.Ready_For_TM);
  144. Transition(STATE.Ready_For_TM, MSG.TM_Exchange_Ready, null, STATE.Idle);
  145. // Prepare EFEM Transfer
  146. Transition(STATE.Idle, MSG.Prepare_EFEM, FnStartPrepareEFEM, STATE.Prepare_For_EFEM);
  147. Transition(STATE.Prepare_For_EFEM, FSM_MSG.TIMER, FnPrepareEFEMTimeout, STATE.Ready_For_EFEM);
  148. Transition(STATE.Ready_For_EFEM, MSG.EFEM_Exchange_Ready, null, STATE.Idle);
  149. Running = true;
  150. }
  151. public int Invoke(string function, params object[] args)
  152. {
  153. switch (function)
  154. {
  155. case "Home":
  156. CheckToPostMessage((int)MSG.Home);
  157. return (int)MSG.Home;
  158. }
  159. return (int)FSM_MSG.NONE;
  160. }
  161. public bool CheckAcked(int msg)
  162. {
  163. return fsm.CheckExecuted(msg);
  164. }
  165. public bool CheckToPostMessage(int msg, params object[] args)
  166. {
  167. if (!fsm.FindTransition(fsm.State, msg))
  168. {
  169. LOG.Write(eEvent.WARN_FSM_WARN, Module, $"{Module} is in {(STATE)fsm.State} state,can not do {(MSG)msg}");
  170. return false;
  171. }
  172. Running = true;
  173. fsm.PostMsg(msg, args);
  174. return true;
  175. }
  176. private bool fnEnterTMReady(object[] param)
  177. {
  178. Status = LLStatus.Ready_For_TM;
  179. return true;
  180. }
  181. private bool fnExitTMReady(object[] param)
  182. {
  183. Status = LLStatus.Not_Ready;
  184. return true;
  185. }
  186. private bool fnEnterEFEMReady(object[] param)
  187. {
  188. Status = LLStatus.Ready_For_EFEM;
  189. return true;
  190. }
  191. private bool fnExitEFEMReady(object[] param)
  192. {
  193. Status = LLStatus.Not_Ready;
  194. return true;
  195. }
  196. private bool fnMonitor(object[] param)
  197. {
  198. _debugRoutine();
  199. return true;
  200. }
  201. private bool fnError(object[] param)
  202. {
  203. IsOnline = false;
  204. return true;
  205. }
  206. private bool fnOnline(object[] param)
  207. {
  208. IsOnline = true;
  209. return true;
  210. }
  211. private bool fnOffline(object[] param)
  212. {
  213. IsOnline = false;
  214. return true;
  215. }
  216. private bool fnAbort(object[] param)
  217. {
  218. return true;
  219. }
  220. private bool fnHome(object[] param)
  221. {
  222. return true;
  223. }
  224. private bool fnHoming(object[] param)
  225. {
  226. return true;
  227. }
  228. private bool FnStartVent(object[] param)
  229. {
  230. return _ventingRoutine.Start() == RState.Running;
  231. }
  232. private bool FnVentTimeout(object[] param)
  233. {
  234. RState ret = _ventingRoutine.Monitor();
  235. if (ret == RState.Failed || ret == RState.Timeout)
  236. {
  237. PostMsg(MSG.Error);
  238. return false;
  239. }
  240. return ret == RState.End;
  241. }
  242. private bool FnAbortVent(object[] param)
  243. {
  244. _ventingRoutine.Abort();
  245. return true;
  246. }
  247. private bool FnStartPump(object[] param)
  248. {
  249. return _pumpingRoutine.Start() == RState.Running;
  250. }
  251. private bool FnPumpTimeout(object[] param)
  252. {
  253. RState ret = _pumpingRoutine.Monitor();
  254. if (ret == RState.Failed || ret == RState.Timeout)
  255. {
  256. PostMsg(MSG.Error);
  257. return false;
  258. }
  259. return ret == RState.End;
  260. }
  261. private bool FnAbortPump(object[] param)
  262. {
  263. _pumpingRoutine.Abort();
  264. return true;
  265. }
  266. private bool FnStartPurge(object[] param)
  267. {
  268. return _purgeRoutine.Start() == RState.Running;
  269. }
  270. private bool FnPurgeTimeout(object[] param)
  271. {
  272. RState ret = _purgeRoutine.Monitor();
  273. if (ret == RState.Failed || ret == RState.Timeout)
  274. {
  275. PostMsg(MSG.Error);
  276. return false;
  277. }
  278. return ret == RState.End;
  279. }
  280. private bool FnAbortPurge(object[] param)
  281. {
  282. _purgeRoutine.Abort();
  283. return true;
  284. }
  285. private bool FnStartLeakCheck(object[] param)
  286. {
  287. return _leakCheckRoutine.Start() == RState.Running;
  288. }
  289. private bool FnLeakCheckTimeout(object[] param)
  290. {
  291. RState ret = _leakCheckRoutine.Monitor();
  292. if (ret == RState.Failed || ret == RState.Timeout)
  293. {
  294. PostMsg(MSG.Error);
  295. return false;
  296. }
  297. return ret == RState.End;
  298. }
  299. private bool FnAbortLeakCheck(object[] param)
  300. {
  301. _leakCheckRoutine.Abort();
  302. return true;
  303. }
  304. private bool FnStartPrepareTM(object[] param)
  305. {
  306. return _pumpingRoutine.Start() == RState.Running;
  307. }
  308. private bool FnPreparaTMTimeout(object[] param)
  309. {
  310. RState ret = _pumpingRoutine.Monitor();
  311. if (ret == RState.Failed || ret == RState.Timeout)
  312. {
  313. PostMsg(MSG.Error);
  314. return false;
  315. }
  316. return ret == RState.End;
  317. }
  318. private bool FnStartPrepareEFEM(object[] param)
  319. {
  320. return _ventingRoutine.Start() == RState.Running;
  321. }
  322. private bool FnPrepareEFEMTimeout(object[] param)
  323. {
  324. RState ret = _ventingRoutine.Monitor();
  325. if (ret == RState.Failed || ret == RState.Timeout)
  326. {
  327. PostMsg(MSG.Error);
  328. return false;
  329. }
  330. return ret == RState.End;
  331. }
  332. private void _debugRoutine()
  333. {
  334. int flag = 0;
  335. // Test Home routine
  336. if (flag == 1)
  337. {
  338. PostMsg(MSG.Home);
  339. }
  340. else if (flag == 2)
  341. {
  342. PostMsg(MSG.Vent);
  343. }
  344. else if (flag == 3)
  345. {
  346. PostMsg(MSG.Pump);
  347. }
  348. //else if (flag == 4)
  349. //{
  350. // PostMsg(MSG.PumpLoadLock);
  351. //}
  352. //else if (flag == 5)
  353. //{
  354. // PostMsg(MSG.VentLoadLock);
  355. //}
  356. //else if (flag == 6)
  357. //{
  358. // PostMsg(MSG.PurgeLoadLock);
  359. //}
  360. //else if (flag == 7)
  361. //{
  362. // PostMsg(MSG.LaunchPump);
  363. //}
  364. //else if (flag == 8)
  365. //{
  366. // PostMsg(MSG.LaunchTurboPump);
  367. //}
  368. //else if (flag == 9)
  369. //{
  370. // PostMsg(MSG.LoadLockLeakCheck);
  371. //}
  372. else if (flag == 10)
  373. {
  374. PostMsg(MSG.CyclePurge);
  375. }
  376. //else if (flag == 11)
  377. //{
  378. // PostMsg(MSG.GasLinePurge);
  379. //}
  380. //else if (flag == 12)
  381. //{
  382. // PostMsg(MSG.LeakCheck);
  383. //}
  384. //else if (flag == 13)
  385. //{
  386. // PostMsg(MSG.GasLeakCheck);
  387. //}
  388. //else if (flag == 14)
  389. //{
  390. // PostMsg(MSG.LLPlace);
  391. //}
  392. //else if (flag == 15)
  393. //{
  394. // PostMsg(MSG.LLPick);
  395. //}
  396. //else if (flag == 16)
  397. //{
  398. // PostMsg(MSG.RunRecipe, "7777");
  399. //}
  400. //else if (flag == 17)
  401. //{
  402. // PostMsg(MSG.MFCVerification, "MFC2", (double)50, 10);
  403. //}
  404. }
  405. }
  406. }