VceEntity.cs 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611
  1. using Aitex.Core.RT.DataCenter;
  2. using Aitex.Core.RT.Device;
  3. using Aitex.Core.RT.Fsm;
  4. using Aitex.Core.RT.Log;
  5. using Aitex.Core.RT.OperationCenter;
  6. using Aitex.Core.Utilities;
  7. using MECF.Framework.Common.Equipment;
  8. using MECF.Framework.Common.Schedulers;
  9. using MECF.Framework.Common.SubstrateTrackings;
  10. using MECF.Framework.RT.ModuleLibrary.VceModules;
  11. using System;
  12. using System.Collections.Generic;
  13. using System.Linq;
  14. using System.Reflection;
  15. using System.Text;
  16. using System.Threading.Tasks;
  17. using System.Windows;
  18. using Venus_Core;
  19. using Venus_RT.Devices;
  20. using Venus_RT.Devices.SMIF;
  21. using Venus_RT.Devices.VCE;
  22. using Venus_RT.Modules.PMs;
  23. using Venus_RT.Modules.TM;
  24. using Venus_RT.Modules.TM.VenusEntity;
  25. namespace Venus_RT.Modules.VCE
  26. {
  27. #region 状态和消息
  28. public enum VceMSG
  29. {
  30. Home,
  31. Error,
  32. DoorOpen,
  33. DoorClose,
  34. Map,
  35. ReadMap,
  36. Load,
  37. UnLoad,
  38. LoadPrepare,
  39. LoadWithSMIF,
  40. UnLoadWithSMIF,
  41. Reset,
  42. Goto,
  43. GotoLP,
  44. SafeLoad,
  45. SafeUnload,
  46. Pump,
  47. Vent,
  48. Abort,
  49. None,
  50. ClearError
  51. }
  52. #endregion
  53. public class VceEntity : Entity, IEntity, IModuleEntity
  54. {
  55. private ModuleName _modulename;
  56. private readonly VceModuleBase _vce;
  57. private readonly ISMIF _smif;
  58. private bool _CassetteArrive;
  59. public bool IsIdle => fsm.State == (int)VceSTATE.Idle;
  60. public bool IsInit => fsm.State == (int)VceSTATE.Init || fsm.State == (int)VceSTATE.Unknown;
  61. public bool IsBusy => !IsInit && !IsError && !IsIdle;
  62. public bool IsError => fsm.State == (int)VceSTATE.Error;
  63. public bool VCEOutDoorClosed => !_vce.OutDoorIsOpen;
  64. public bool CassetteArrive => _CassetteArrive;
  65. public int CurrentSlot => currentSlot;
  66. private int currentSlot;
  67. private int targetSlot;
  68. private LoadRoutine _loadRoutine;
  69. private LoadPrepareRoutine _prepareRoutine;
  70. private UnloadRoutine _unloadRoutine;
  71. private LoadWithSMIFRoutine _loadwithSMIFRoutine;
  72. private UnloadWithSMIFRoutine _unloadwithSMIFRoutine;
  73. private readonly SEMFPumpRoutine _pumpRoutine;
  74. private readonly SEMFVentRoutine _ventRoutine;
  75. public VceEntity(ModuleName moduleName)
  76. {
  77. currentSlot = 0;
  78. _modulename = moduleName;
  79. _vce = new HongHuVce(25, _modulename);
  80. _smif = new FortrendPLUS500(_modulename);
  81. _loadRoutine = new LoadRoutine(_modulename, _vce);
  82. _prepareRoutine = new LoadPrepareRoutine(_modulename, _vce);
  83. _unloadRoutine = new UnloadRoutine(_modulename, _vce);
  84. _loadwithSMIFRoutine = new LoadWithSMIFRoutine(_modulename, _vce, _smif);
  85. _unloadwithSMIFRoutine = new UnloadWithSMIFRoutine(_modulename, _vce, _smif);
  86. _pumpRoutine = new SEMFPumpRoutine(DEVICE.GetDevice<HongHuTM>("SETM"), _modulename);
  87. _ventRoutine = new SEMFVentRoutine(DEVICE.GetDevice<HongHuTM>("SETM"), _modulename);
  88. InitFsmMap();
  89. }
  90. protected override bool Init()
  91. {
  92. DATA.Subscribe($"{_modulename}.VCEOutDoorClosed", () => !VCEOutDoorClosed);
  93. DATA.Subscribe($"{_modulename}.CurrentSlot", () => currentSlot);
  94. DATA.Subscribe($"{_modulename}.FsmState", () => ((VceSTATE)fsm.State).ToString());
  95. DATA.Subscribe($"{_modulename}.CassetteArrive", () => CassetteArrive);
  96. //DATA.Subscribe($"{_modulename}.IsRunning", () => IsIdle);
  97. OP.Subscribe($"{_modulename}.HOME", (cmd, args) => { PostMsg(VceMSG.Home); return true; });
  98. OP.Subscribe($"{_modulename}.DoorOpen", (cmd, args) => { PostMsg(VceMSG.DoorOpen); return true; });
  99. OP.Subscribe($"{_modulename}.DoorClose", (cmd, args) => { PostMsg(VceMSG.DoorClose); return true; });
  100. OP.Subscribe($"{_modulename}.Map", (cmd, args) => { PostMsg(VceMSG.Map); return true; });
  101. OP.Subscribe($"{_modulename}.ReadMap", (cmd, args) => { PostMsg(VceMSG.ReadMap); return true; });
  102. OP.Subscribe($"{_modulename}.Load", (cmd, args) => { PostMsg(VceMSG.Load); return true; });
  103. OP.Subscribe($"{_modulename}.UnLoad", (cmd, args) => { PostMsg(VceMSG.UnLoad); return true; });
  104. OP.Subscribe($"{_modulename}.Reset", (cmd, args) => { PostMsg(VceMSG.Reset); return true; });
  105. OP.Subscribe($"{_modulename}.Goto", (cmd, args) => { PostMsg(VceMSG.Goto, args[0]); return true; });
  106. OP.Subscribe($"{_modulename}.GotoLP", (cmd, args) => { PostMsg(VceMSG.GotoLP); return true; });
  107. OP.Subscribe($"{_modulename}.Abort", (cmd, args) => { PostMsg(VceMSG.Abort); return true; });
  108. OP.Subscribe($"{_modulename}.PumpDown", (cmd, args) => { PostMsg(VceMSG.Pump); return true; });
  109. OP.Subscribe($"{_modulename}.Vent", (cmd, args) => { PostMsg(VceMSG.Vent); return true; });
  110. OP.Subscribe($"{_modulename}.ClearError", (cmd, args) => { PostMsg(VceMSG.ClearError); return true; });
  111. OP.Subscribe($"{_modulename}.LoadPrepare", (cmd, args) => { PostMsg(VceMSG.LoadPrepare); return true; });
  112. OP.Subscribe($"{_modulename}.SafeLoad", (cmd, args) => { PostMsg(VceMSG.SafeLoad); return true; });
  113. OP.Subscribe($"{_modulename}.SafeUnload", (cmd, args) => { PostMsg(VceMSG.SafeUnload); return true; });
  114. OP.Subscribe($"{_modulename}.LoadWithSMIF", (cmd, args) => { PostMsg(VceMSG.LoadWithSMIF); return true; });
  115. OP.Subscribe($"{_modulename}.UnLoadWithSMIF", (cmd, args) => { PostMsg(VceMSG.UnLoadWithSMIF); return true; });
  116. return true;
  117. }
  118. /// <summary>
  119. /// 定义状态机的迁移表
  120. /// </summary>
  121. private void InitFsmMap()
  122. {
  123. fsm = new StateMachine<VceEntity>(_modulename.ToString(), (int)VceSTATE.Init, 50);
  124. fsm.EnableRepeatedMsg(true);
  125. AnyStateTransition(VceMSG.Error, fnError, VceSTATE.Error);
  126. AnyStateTransition(VceMSG.Abort, fnAbort, VceSTATE.Idle);
  127. AnyStateTransition(VceMSG.Home, fnStartHome, VceSTATE.Homing);
  128. //HOME init->homing idle->homing
  129. Transition(VceSTATE.Init, VceMSG.Home, fnStartHome, VceSTATE.Homing);
  130. Transition(VceSTATE.Idle, VceMSG.Home, fnStartHome, VceSTATE.Homing);
  131. Transition(VceSTATE.Error, VceMSG.Home, fnStartHome, VceSTATE.Homing);
  132. Transition(VceSTATE.Homing, FSM_MSG.TIMER, fnHomeTimeout, VceSTATE.Idle);
  133. //clear Error
  134. Transition(VceSTATE.Error, VceMSG.ClearError, fnStartClearError,VceSTATE.ClearError);
  135. Transition(VceSTATE.ClearError, FSM_MSG.TIMER, fnClearErrorTimeout, VceSTATE.Idle);
  136. //Open Door 开门
  137. Transition(VceSTATE.Idle, VceMSG.DoorOpen, fnStartOpenDoor, VceSTATE.DoorOpenning);
  138. Transition(VceSTATE.DoorOpenning, FSM_MSG.TIMER, fnOpenDoorTimeout, VceSTATE.Idle);
  139. //Close Door 关门
  140. Transition(VceSTATE.Idle, VceMSG.DoorClose, fnStartCloseDoor, VceSTATE.DoorClosing);
  141. Transition(VceSTATE.DoorClosing, FSM_MSG.TIMER, fnCloseDoorTimeout, VceSTATE.Idle);
  142. //Map 扫片
  143. Transition(VceSTATE.Idle, VceMSG.Map, fnStartMapping, VceSTATE.Mapping);
  144. Transition(VceSTATE.Mapping, FSM_MSG.TIMER, fnMappingTimeout, VceSTATE.Idle);
  145. //Load 取cassette
  146. Transition(VceSTATE.Idle, VceMSG.Load, fnStartLoading, VceSTATE.Loading);
  147. Transition(VceSTATE.Loading, FSM_MSG.TIMER, fnLoadingTimeout, VceSTATE.Idle);
  148. //UnLoad 放cassette
  149. Transition(VceSTATE.Idle, VceMSG.UnLoad, fnStartUnLoading, VceSTATE.UnLoading);
  150. Transition(VceSTATE.UnLoading, FSM_MSG.TIMER, fnUnLoadingTimeout, VceSTATE.Idle);
  151. //Goto 指定槽对准窗口
  152. Transition(VceSTATE.Idle, VceMSG.Goto, fnStartGoto, VceSTATE.Goting);
  153. Transition(VceSTATE.Goting, FSM_MSG.TIMER, fnGotingTimeout, VceSTATE.Idle);
  154. //ReadMap
  155. Transition(VceSTATE.Idle, VceMSG.ReadMap, fnStartReadingMap, VceSTATE.ReadingMap);
  156. Transition(VceSTATE.ReadingMap, FSM_MSG.TIMER, fnReadingMapTimeout, VceSTATE.Idle);
  157. //Load Prepare
  158. Transition(VceSTATE.Idle, VceMSG.LoadPrepare, fnStartLoadPrepare, VceSTATE.LoadPreparing);
  159. Transition(VceSTATE.LoadPreparing, FSM_MSG.TIMER, fnLoadingPrepareTimeout, VceSTATE.Idle);
  160. //Safe Load
  161. Transition(VceSTATE.Idle, VceMSG.SafeLoad, fnStartSafeLoad, VceSTATE.SafeLoading);
  162. Transition(VceSTATE.SafeLoading, FSM_MSG.TIMER, fnSafeLoadTimeout, VceSTATE.Idle);
  163. //LoadWithSMIF => LoadPrepare & SMIF Load & Load
  164. Transition(VceSTATE.Idle, VceMSG.LoadWithSMIF, fnStartLoadWithSMIF, VceSTATE.LoadingWithSMIF);
  165. Transition(VceSTATE.LoadingWithSMIF, FSM_MSG.TIMER, fnLoadWithSMIFTimeout, VceSTATE.Idle);
  166. //Safe UnLoad
  167. Transition(VceSTATE.Idle, VceMSG.SafeUnload, fnStartSafeUnLoad, VceSTATE.SafeUnloading);
  168. Transition(VceSTATE.SafeUnloading, FSM_MSG.TIMER, fnSafeUnLoadTimeout, VceSTATE.Idle);
  169. //UnLoad With SMIF => UnLoad with smif
  170. Transition(VceSTATE.Idle, VceMSG.UnLoadWithSMIF, fnStartUnLoadWithSMIF, VceSTATE.UnLoadingWithSMIF);
  171. Transition(VceSTATE.UnLoadingWithSMIF, FSM_MSG.TIMER, fnUnLoadWithSMIFTimeout, VceSTATE.Idle);
  172. //Goto LP
  173. Transition(VceSTATE.Idle, VceMSG.GotoLP, fnStartGotoLP, VceSTATE.GotingLP);
  174. Transition(VceSTATE.GotingLP, FSM_MSG.TIMER, fnGotoLPTimeout, VceSTATE.Idle);
  175. //Pump
  176. Transition(VceSTATE.Idle, VceMSG.Pump, fnStartPump, VceSTATE.Pumping);
  177. Transition(VceSTATE.Pumping, FSM_MSG.TIMER, fnPumpTimeout, VceSTATE.Idle);
  178. Transition(VceSTATE.Pumping, VceMSG.Abort, fnAbortPump, VceSTATE.Idle);
  179. //Vent
  180. Transition(VceSTATE.Idle, VceMSG.Vent, fnStartVent, VceSTATE.Venting);
  181. Transition(VceSTATE.Venting, FSM_MSG.TIMER, fnVentTimeout, VceSTATE.Idle);
  182. Transition(VceSTATE.Venting, VceMSG.Abort, fnAbortVent, VceSTATE.Idle);
  183. EnumLoop<VceSTATE>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });
  184. EnumLoop<VceMSG>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
  185. Running = true;
  186. }
  187. private bool fnAbortVent(object[] param)
  188. {
  189. _ventRoutine.Abort();
  190. return true;
  191. }
  192. private bool fnVentTimeout(object[] param)
  193. {
  194. RState ret = _ventRoutine.Monitor();
  195. if (ret == RState.Timeout || ret == RState.Failed)
  196. {
  197. PostMsg(VceMSG.Error);
  198. return false;
  199. }
  200. return ret == RState.End;
  201. }
  202. private bool fnStartVent(object[] param)
  203. {
  204. return _ventRoutine.Start(param) == RState.Running;
  205. }
  206. private bool fnAbortPump(object[] param)
  207. {
  208. _pumpRoutine.Abort();
  209. return true;
  210. }
  211. private bool fnPumpTimeout(object[] param)
  212. {
  213. RState ret = _pumpRoutine.Monitor();
  214. if (ret == RState.Timeout || ret == RState.Failed)
  215. {
  216. PostMsg(VceMSG.Error);
  217. return false;
  218. }
  219. return ret == RState.End;
  220. }
  221. private bool fnStartPump(object[] param)
  222. {
  223. return _pumpRoutine.Start(param) == RState.Running;
  224. }
  225. private bool fnGotoLPTimeout(object[] param)
  226. {
  227. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  228. {
  229. PostMsg(VceMSG.Error);
  230. return false;
  231. }
  232. if (_vce.Status == RState.End)
  233. {
  234. currentSlot = targetSlot;
  235. }
  236. return _vce.Status == RState.End;
  237. }
  238. private bool fnStartGotoLP(object[] param)
  239. {
  240. if (_vce.GotoLP())
  241. {
  242. targetSlot = -1;
  243. return true;
  244. }
  245. else
  246. return false;
  247. }
  248. private bool fnSafeUnLoadTimeout(object[] param)
  249. {
  250. RState ret = _unloadRoutine.Monitor();
  251. if (ret == RState.Timeout || ret == RState.Failed)
  252. {
  253. PostMsg(VceMSG.Error);
  254. return false;
  255. }
  256. if (ret == RState.End)
  257. {
  258. _CassetteArrive = false;
  259. WaferManager.Instance.DeleteWafer(_modulename, 0, 25);
  260. }
  261. return ret == RState.End;
  262. }
  263. private bool fnStartClearError(object[] param)
  264. {
  265. if (_vce.ClearError())
  266. {
  267. return true;
  268. }
  269. else
  270. return false;
  271. }
  272. private bool fnClearErrorTimeout(object[] param)
  273. {
  274. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  275. {
  276. PostMsg(VceMSG.Error);
  277. return false;
  278. }
  279. if (_vce.Status == RState.End)
  280. {
  281. currentSlot = targetSlot;
  282. }
  283. return _vce.Status == RState.End;
  284. }
  285. private bool fnStartSafeUnLoad(object[] param)
  286. {
  287. return _unloadRoutine.Start(param) == RState.Running;
  288. }
  289. private bool fnSafeLoadTimeout(object[] param)
  290. {
  291. RState ret = _loadRoutine.Monitor();
  292. if (ret == RState.Timeout || ret == RState.Failed)
  293. {
  294. PostMsg(VceMSG.Error);
  295. return false;
  296. }
  297. if (ret == RState.End)
  298. {
  299. _CassetteArrive = true;
  300. }
  301. return ret == RState.End;
  302. }
  303. private bool fnStartLoadWithSMIF(object[] param)
  304. {
  305. return _loadwithSMIFRoutine.Start(param) == RState.Running;
  306. }
  307. private bool fnLoadWithSMIFTimeout(object[] param)
  308. {
  309. RState ret = _loadwithSMIFRoutine.Monitor();
  310. if (ret == RState.Timeout || ret == RState.Failed)
  311. {
  312. PostMsg(VceMSG.Error);
  313. return false;
  314. }
  315. if (ret == RState.End)
  316. {
  317. _CassetteArrive = true;
  318. }
  319. return ret == RState.End;
  320. }
  321. private bool fnStartUnLoadWithSMIF(object[] param)
  322. {
  323. return _unloadwithSMIFRoutine.Start(param) == RState.Running;
  324. }
  325. private bool fnUnLoadWithSMIFTimeout(object[] param)
  326. {
  327. RState ret = _unloadwithSMIFRoutine.Monitor();
  328. if (ret == RState.Timeout || ret == RState.Failed)
  329. {
  330. PostMsg(VceMSG.Error);
  331. return false;
  332. }
  333. if (ret == RState.End)
  334. {
  335. _CassetteArrive = false;
  336. WaferManager.Instance.DeleteWafer(_modulename, 0, 25);
  337. }
  338. return ret == RState.End;
  339. }
  340. private bool fnStartSafeLoad(object[] param)
  341. {
  342. return _loadRoutine.Start(param) == RState.Running;
  343. }
  344. private bool fnLoadingPrepareTimeout(object[] param)
  345. {
  346. RState ret = _prepareRoutine.Monitor();
  347. if (ret == RState.Timeout || ret == RState.Failed)
  348. {
  349. PostMsg(VceMSG.Error);
  350. return false;
  351. }
  352. return ret == RState.End;
  353. }
  354. private bool fnStartLoadPrepare(object[] param)
  355. {
  356. return _prepareRoutine.Start(param) == RState.Running;
  357. }
  358. private bool fnReadingMapTimeout(object[] param)
  359. {
  360. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  361. {
  362. PostMsg(VceMSG.Error);
  363. return false;
  364. }
  365. return _vce.Status == RState.End;
  366. }
  367. private bool fnStartReadingMap(object[] param)
  368. {
  369. return _vce.ReadMap();
  370. }
  371. //急停
  372. private bool fnAbort(object[] param)
  373. {
  374. return true;
  375. }
  376. //升降到槽位
  377. private bool fnStartGoto(object[] param)
  378. {
  379. if (_vce.Goto(Convert.ToInt32(param[0])))
  380. {
  381. targetSlot = Convert.ToInt32(param[0]);
  382. return true;
  383. }
  384. else
  385. return false;
  386. }
  387. private bool fnGotingTimeout(object[] param)
  388. {
  389. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  390. {
  391. PostMsg(VceMSG.Error);
  392. return false;
  393. }
  394. if(_vce.Status == RState.End)
  395. currentSlot = targetSlot;
  396. return _vce.Status == RState.End;
  397. }
  398. private bool fnError(object[] param)
  399. {
  400. return true;
  401. }
  402. private bool fnStartHome(object[] param)
  403. {
  404. return _vce.HomeALL();
  405. }
  406. private bool fnHomeTimeout(object[] param)
  407. {
  408. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  409. {
  410. PostMsg(VceMSG.Error);
  411. return false;
  412. }
  413. return _vce.Status == RState.End;
  414. }
  415. private bool fnStartOpenDoor(object[] param)
  416. {
  417. return _vce.OpenDoor();
  418. }
  419. private bool fnOpenDoorTimeout(object[] param)
  420. {
  421. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  422. {
  423. PostMsg(VceMSG.Error);
  424. return false;
  425. }
  426. return _vce.Status == RState.End;
  427. }
  428. private bool fnStartCloseDoor(object[] param)
  429. {
  430. return _vce.CloseDoor();
  431. }
  432. private bool fnCloseDoorTimeout(object[] param)
  433. {
  434. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  435. {
  436. PostMsg(VceMSG.Error);
  437. return false;
  438. }
  439. return _vce.Status == RState.End;
  440. }
  441. private bool fnStartMapping(object[] param)
  442. {
  443. return _vce.Map();
  444. }
  445. private bool fnMappingTimeout(object[] param)
  446. {
  447. if(_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  448. {
  449. PostMsg(VceMSG.Error);
  450. return false;
  451. }
  452. return _vce.Status == RState.End;
  453. }
  454. private bool fnStartLoading(object[] param)
  455. {
  456. return _vce.Load();
  457. }
  458. private bool fnLoadingTimeout(object[] param)
  459. {
  460. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  461. {
  462. PostMsg(VceMSG.Error);
  463. return false;
  464. }
  465. return _vce.Status == RState.End;
  466. }
  467. private bool fnStartUnLoading(object[] param)
  468. {
  469. return _vce.UnLoad();
  470. }
  471. private bool fnUnLoadingTimeout(object[] param)
  472. {
  473. if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
  474. {
  475. PostMsg(VceMSG.Error);
  476. return false;
  477. }
  478. return _vce.Status == RState.End;
  479. }
  480. public bool Check(int msg, out string reason, params object[] args)
  481. {
  482. reason = "";
  483. return true;
  484. }
  485. public int Invoke(string function, params object[] args)
  486. {
  487. switch (function)
  488. {
  489. case "Home":
  490. CheckToPostMessage((int)VceMSG.Home);
  491. return (int)VceMSG.Home;
  492. }
  493. return (int)VceMSG.None;
  494. }
  495. public bool CheckToPostMessage(int msg, params object[] args)
  496. {
  497. if (!fsm.FindTransition(fsm.State, msg))
  498. {
  499. LOG.Write(eEvent.WARN_FSM_WARN, _modulename, $"{_modulename} is in {(VceSTATE)fsm.State} state,can not do {(VceMSG)msg}");
  500. return false;
  501. }
  502. Running = true;
  503. fsm.PostMsg(msg, args);
  504. return true;
  505. }
  506. public bool CheckAcked(int msg)
  507. {
  508. return fsm.CheckExecuted(msg);
  509. }
  510. public bool IsPrepareTransferReady(ModuleName module, EnumTransferType transferType, int slot)
  511. {
  512. return false;
  513. }
  514. }
  515. }