LoaderEntity.cs 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018
  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.RT.Routine;
  7. using Aitex.Core.RT.SCCore;
  8. using Aitex.Core.Util;
  9. using Aitex.Core.Utilities;
  10. using MECF.Framework.Common.Equipment;
  11. using MECF.Framework.Common.SubstrateTrackings;
  12. using MECF.Framework.Common.Utilities;
  13. using MECF.Framework.Common.WaferHolder;
  14. using CyberX8_Core;
  15. using CyberX8_RT.Devices.AXIS;
  16. using CyberX8_RT.Devices.Loader;
  17. using System;
  18. using System.Collections.Generic;
  19. using System.Linq;
  20. using System.Text;
  21. using System.Threading.Tasks;
  22. using MECF.Framework.Common.Alarm;
  23. using MECF.Framework.Common.CommonData;
  24. using MECF.Framework.Common.Routine;
  25. using System.Collections;
  26. using System.Windows.Markup;
  27. using MECF.Framework.Common.CommonData.Loader;
  28. using Aitex.Core.Common;
  29. using MECF.Framework.RT.Core.Equipments;
  30. using CyberX8_RT.Modules.Dryer;
  31. namespace CyberX8_RT.Modules.Loader
  32. {
  33. public class LoaderEntity : Entity, IEntity, IModuleEntity
  34. {
  35. public enum LotTrackDatasStatus
  36. {
  37. None,
  38. Half,
  39. Complete
  40. }
  41. #region 属性
  42. public ModuleName Module { get; private set; }
  43. public bool IsInit
  44. {
  45. get { return fsm.State == (int)LOADERSTATE.Init; }
  46. }
  47. public bool IsIdle
  48. {
  49. get
  50. {
  51. return fsm.State == (int)LOADERSTATE.Idle;
  52. }
  53. }
  54. public bool IsError
  55. {
  56. get { return fsm.State == (int)LOADERSTATE.Error; }
  57. }
  58. public bool IsBusy
  59. {
  60. get { return !IsInit && !IsError && !IsIdle; }
  61. }
  62. public bool IsAuto { get; } = true;
  63. /// <summary>
  64. /// 是否为工程模式
  65. /// </summary>
  66. public bool IsEngineering { get; } = false;
  67. /// <summary>
  68. /// 是否为产品模式
  69. /// </summary>
  70. public bool IsProduction { get; } = true;
  71. public bool IsHomed
  72. {
  73. get { return _isHomed; }
  74. }
  75. /// <summary>
  76. /// 当前状态机状态
  77. /// </summary>
  78. public int State { get { return fsm.State; } }
  79. /// <summary>
  80. /// 是否禁用
  81. /// </summary>
  82. public bool IsDisable { get; internal set; }
  83. /// <summary>
  84. /// Rotation是否SwitchOn
  85. /// </summary>
  86. public bool IsRotationSwitchOn
  87. {
  88. get { return _rotationAxis.IsSwitchOn; }
  89. }
  90. /// <summary>
  91. /// ShuttleA是否SwitchOn
  92. /// </summary>
  93. public bool IsShuttleASwitchOn
  94. {
  95. get { return _shuttleAAxis.IsSwitchOn; }
  96. }
  97. /// <summary>
  98. /// ShuttleB是否SwitchOn
  99. /// </summary>
  100. public bool IsShuttleBSwitchOn
  101. {
  102. get { return _shuttleBAxis.IsSwitchOn; }
  103. }
  104. /// <summary>
  105. /// TiltA是否SwitchOn
  106. /// </summary>
  107. public bool IsTiltASwitchOn
  108. {
  109. get { return _tiltAAxis.IsSwitchOn; }
  110. }
  111. /// <summary>
  112. /// TiltB是否SwitchOn
  113. /// </summary>
  114. public bool IsTiltBSwitchOn
  115. {
  116. get { return _tiltBAxis.IsSwitchOn; }
  117. }
  118. /// <summary>
  119. /// CrsA是否SwitchOn
  120. /// </summary>
  121. public bool IsCrsASwitchOn
  122. {
  123. get { return _crsAAxis.IsSwitchOn; }
  124. }
  125. /// <summary>
  126. /// CrsB是否SwitchOn
  127. /// </summary>
  128. public bool IsCrsBSwitchOn
  129. {
  130. get { return _crsBAxis.IsSwitchOn; }
  131. }
  132. /// <summary>
  133. /// WaferHolder信息
  134. /// </summary>
  135. public WaferHolderInfo WaferHolderInfo { get { return WaferHolderManager.Instance.GetWaferHolder("Loader"); } }
  136. /// <summary>
  137. /// A面Wafer尺寸
  138. /// </summary>
  139. public int SideAWaferSize { get { return _sideAWaferSize; } }
  140. /// <summary>
  141. /// B面Wafer尺寸
  142. /// </summary>
  143. public int SideBWaferSize { get { return _sideBWaferSize; } }
  144. #endregion
  145. #region 内部变量
  146. private bool _isHomed = false;
  147. private IRoutine _currentRoutine;
  148. /// <summary>
  149. /// Loader当前unload、load操作Slot
  150. /// </summary>
  151. private Dictionary<string, List<string>> _loaderOperatingWaferInfosList = new Dictionary<string, List<string>> { { "unload", new List<string>(new string[2]) }, { "load", new List<string>(new string[2]) } };
  152. #region Axis
  153. JetAxisBase _shuttleAAxis;
  154. JetAxisBase _shuttleBAxis;
  155. JetAxisBase _tiltAAxis;
  156. JetAxisBase _tiltBAxis;
  157. JetAxisBase _crsAAxis;
  158. JetAxisBase _crsBAxis;
  159. JetAxisBase _rotationAxis;
  160. LoaderSideDevice _sideA;
  161. LoaderSideDevice _sideB;
  162. LoaderCommonDevice _loaderCommon;
  163. int _sideAWaferSize;
  164. int _sideBWaferSize;
  165. #endregion
  166. #region routine
  167. private LoaderHomeAllRoutine _homeAllRoutine;
  168. private LoaderSwitchAllOnRoutine _switchAllOnRoutine;
  169. private LoaderSwitchAllOffRoutine _switchAllOffRoutine;
  170. private LoaderUnloadSideRoutine _unloadSideRoutine;
  171. private LoaderLoadSideRoutine _loadSideRoutine;
  172. #endregion
  173. #region LotTrackDatas
  174. /// <summary>
  175. /// Load LotTrackData
  176. /// </summary>
  177. private List<LoaderLotTrackData> _loadLotTrackDatas = new List<LoaderLotTrackData>();
  178. /// <summary>
  179. /// UnLoad LotTrackData
  180. /// </summary>
  181. private List<LoaderLotTrackData> _unloadLotTrackDatas = new List<LoaderLotTrackData>();
  182. /// <summary>
  183. /// UnLoad LotTrackDataBuffer
  184. /// </summary>
  185. private List<LoaderLotTrackData> _unloadLotTrackDatasBuffer = new List<LoaderLotTrackData>();
  186. /// <summary>
  187. /// LeakTest LotTrackData
  188. /// </summary>
  189. private List<LoaderFlowLotTrackData> _flowLotTrackdatas = new List<LoaderFlowLotTrackData>();
  190. /// <summary>
  191. /// LoadTime
  192. /// </summary>
  193. private List<DateTime> _loadTimeList = new List<DateTime>();
  194. /// <summary>
  195. /// LoadTime
  196. /// </summary>
  197. private List<DateTime> _unloadTimeList = new List<DateTime>();
  198. /// <summary>
  199. /// Unload Start Time
  200. /// </summary>
  201. private DateTime _unloadStartTime;
  202. /// <summary>
  203. /// LotTrackHead
  204. /// </summary>
  205. private LotTrackFileHeaderCommonData _headerdata;
  206. /// <summary>
  207. /// Load Datas Status
  208. private LotTrackDatasStatus _loadDatasStatus = LotTrackDatasStatus.None;
  209. /// <summary>
  210. /// Unload Datas Status
  211. /// </summary>
  212. private LotTrackDatasStatus _unloadDatasStatus = LotTrackDatasStatus.None;
  213. /// <summary>
  214. /// Unload Datas Buffer Status
  215. /// </summary>
  216. private LotTrackDatasStatus _unloadDatasBufferStatus = LotTrackDatasStatus.None;
  217. /// <summary>
  218. /// Flow Test Datas status
  219. /// </summary>
  220. private LotTrackDatasStatus _flowTestDatasStatus = LotTrackDatasStatus.None;
  221. #endregion
  222. #endregion
  223. /// <summary>
  224. /// 构造函数
  225. /// </summary>
  226. /// <param name="module"></param>
  227. public LoaderEntity(ModuleName module)
  228. {
  229. this.Module = module;
  230. _shuttleAAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.ShuttleA");
  231. _shuttleBAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.ShuttleB");
  232. _tiltAAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.TiltA");
  233. _tiltBAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.TiltB");
  234. _crsAAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.LSA");
  235. _crsBAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.LSB");
  236. _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{module}.Rotation");
  237. _sideA = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.SideA");
  238. _sideB = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.SideB");
  239. _loaderCommon = DEVICE.GetDevice<LoaderCommonDevice>($"{module}.Common");
  240. WaferManager.Instance.SubscribeLocation(Module, 2);
  241. _sideAWaferSize = SC.GetValue<int>("Loader1.SideAWaferSize");
  242. _sideBWaferSize = SC.GetValue<int>("Loader1.SideBWaferSize");
  243. InitialOperation();
  244. InitializeRoutine();
  245. InitialDATA();
  246. InitialFsm();
  247. }
  248. /// <summary>
  249. /// 初始化操作
  250. /// </summary>
  251. private void InitialOperation()
  252. {
  253. OP.Subscribe($"{Module}.Abort", (cmd, args) => { return CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.Abort); });
  254. OP.Subscribe($"{Module}.ClearError", (cmd, args) => { return CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.ClearError); });
  255. OP.Subscribe($"{Module}.Common.HomeAll", (cmd, args) => { PostMsg((int)LoaderMSG.HomeAll); return true; });
  256. OP.Subscribe($"{Module}.Common.SwitchOnAll", (cmd, args) => { PostMsg((int)LoaderMSG.SwitchOnAll); return true; });
  257. OP.Subscribe($"{Module}.Common.SwitchOffAll", (cmd, args) => { PostMsg((int)LoaderMSG.SwitchOffAll); return true; });
  258. }
  259. /// <summary>
  260. /// 初始化Routine
  261. /// </summary>
  262. private void InitializeRoutine()
  263. {
  264. _homeAllRoutine=new LoaderHomeAllRoutine(Module.ToString());
  265. _switchAllOnRoutine=new LoaderSwitchAllOnRoutine(Module.ToString());
  266. _switchAllOffRoutine=new LoaderSwitchAllOffRoutine(Module.ToString());
  267. _unloadSideRoutine = new LoaderUnloadSideRoutine(Module.ToString());
  268. _loadSideRoutine=new LoaderLoadSideRoutine(Module.ToString());
  269. }
  270. /// <summary>
  271. /// 初始化数据
  272. /// </summary>
  273. private void InitialDATA()
  274. {
  275. InitializeSvid();
  276. DATA.Subscribe($"{Module}.FsmState", () => ((LOADERSTATE)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
  277. DATA.Subscribe($"{Module}.IsHomed", () => _isHomed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  278. DATA.Subscribe($"{Module}.IsError", () => IsError, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  279. }
  280. /// <summary>
  281. /// 初始化SVID
  282. /// </summary>
  283. private void InitializeSvid()
  284. {
  285. DATA.Subscribe($"{Module}.State", () => ((LOADERSTATE)fsm.State).ToString(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
  286. DATA.Subscribe($"{Module}.LotID", () => WaferHolderInfo?.LotId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  287. DATA.Subscribe($"{Module}.WSID", () => WaferHolderInfo?.Id, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  288. DATA.Subscribe($"{Module}.LSAID", () => WaferHolderInfo?.CrsAId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  289. DATA.Subscribe($"{Module}.LSBID", () => WaferHolderInfo?.CrsBId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  290. DATA.Subscribe($"{Module}.SequenceRecipe", () => WaferHolderInfo?.SequenceId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  291. DATA.Subscribe($"{Module}.WaferAID", () => WaferHolderInfo?.WaferAId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  292. DATA.Subscribe($"{Module}.WaferBID", () => WaferHolderInfo?.WaferBId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  293. DATA.Subscribe($"{Module}.Task", () => WaferHolderInfo?.CurrentControlJobId, SubscriptionAttribute.FLAG.IgnoreSaveDB);
  294. }
  295. /// <summary>
  296. /// 初始化状态机
  297. /// </summary>
  298. private void InitialFsm()
  299. {
  300. fsm = new StateMachine<LoaderEntity>(Module.ToString(), (int)LOADERSTATE.Init, 100);
  301. fsm.EnableRepeatedMsg(true);
  302. AnyStateTransition(LoaderMSG.Error, EnterError, LOADERSTATE.Error);
  303. AnyStateTransition(LoaderMSG.ReturnInit, EnterInit, LOADERSTATE.Init);
  304. AnyStateTransition(LoaderMSG.ReturnIdle, NullFunc, LOADERSTATE.Idle);
  305. AnyStateTransition(LoaderMSG.Abort, Abort, LOADERSTATE.Init);
  306. //clear error
  307. Transition(LOADERSTATE.Error, LoaderMSG.ClearError, ResumeError, LOADERSTATE.Init);
  308. //HomeAll
  309. AnyStateTransition(LoaderMSG.HomeAll, HomeAll, LOADERSTATE.Homing);
  310. Transition(LOADERSTATE.Homing, FSM_MSG.TIMER, HomeAllMonitor, LOADERSTATE.Idle);
  311. //Switch On All
  312. Transition(LOADERSTATE.Error, LoaderMSG.SwitchOnAll, SwitchOnAll, LOADERSTATE.SwitchOning);
  313. Transition(LOADERSTATE.Init, LoaderMSG.SwitchOnAll, SwitchOnAll, LOADERSTATE.SwitchOning);
  314. Transition(LOADERSTATE.Idle, LoaderMSG.SwitchOnAll, SwitchOnAll, LOADERSTATE.SwitchOning);
  315. Transition(LOADERSTATE.SwitchOning, FSM_MSG.TIMER, SwitchOnAllMonitor, LOADERSTATE.Init);
  316. //Switch Off All
  317. Transition(LOADERSTATE.Error, LoaderMSG.SwitchOffAll, SwitchOffAll, LOADERSTATE.SwitchOffing);
  318. Transition(LOADERSTATE.Init, LoaderMSG.SwitchOffAll, SwitchOffAll, LOADERSTATE.SwitchOffing);
  319. Transition(LOADERSTATE.Idle, LoaderMSG.SwitchOffAll, SwitchOffAll, LOADERSTATE.SwitchOffing);
  320. Transition(LOADERSTATE.SwitchOffing, FSM_MSG.TIMER, SwitchOffAllMonitor, LOADERSTATE.Init);
  321. //Prepare for Place
  322. Transition(LOADERSTATE.Idle, LoaderMSG.PrepareForPlace, PrePareForPlace, LOADERSTATE.PrepreForPlacing);
  323. Transition(LOADERSTATE.PrepreForPlacing, FSM_MSG.TIMER, PrepareForPlaceMonitor, LOADERSTATE.WaitForUnload);
  324. Transition(LOADERSTATE.Idle, LoaderMSG.ReadyForPuf, NullFunc, LOADERSTATE.WaitForUnload);
  325. Transition(LOADERSTATE.WaitForUnload, LoaderMSG.UnloadSide, UnloadSide, LOADERSTATE.Unloading);
  326. Transition(LOADERSTATE.Unloading, FSM_MSG.TIMER, UnloadSideMonitor, LOADERSTATE.WaitForLoad);
  327. Transition(LOADERSTATE.WaitForLoad, LoaderMSG.LoadSide, LoadSide, LOADERSTATE.Loading);
  328. Transition(LOADERSTATE.Loading, FSM_MSG.TIMER, LoadSideMonitor, LOADERSTATE.Idle);
  329. //Flip
  330. Transition(LOADERSTATE.Idle, LoaderMSG.WaitFlip, NullFunc, LOADERSTATE.WaitForFlip);
  331. Transition(LOADERSTATE.WaitForFlip,LoaderMSG.PrepareForPlace, PrePareForPlace, LOADERSTATE.PrepreForPlacing);
  332. //Retry
  333. Transition(LOADERSTATE.Error, LoaderMSG.Retry, NullFunc, LOADERSTATE.Retrying);
  334. Transition(LOADERSTATE.Retrying,FSM_MSG.TIMER,LoaderRetry,LOADERSTATE.Retrying);
  335. Transition(LOADERSTATE.Retrying, LoaderMSG.UnloadSide, RetryUnloadSide, LOADERSTATE.Unloading);
  336. Transition(LOADERSTATE.Retrying, LoaderMSG.LoadSide, RetryLoadSide, LOADERSTATE.Loading);
  337. //ConfirmComplete
  338. Transition(LOADERSTATE.Init, LoaderMSG.ConfirmComplete, ClearModuleAlarm, LOADERSTATE.Init);
  339. Transition(LOADERSTATE.Idle, LoaderMSG.ConfirmComplete, ClearModuleAlarm, LOADERSTATE.Idle);
  340. Transition(LOADERSTATE.Error, LoaderMSG.ConfirmComplete, NullFunc, LOADERSTATE.ConfirmCompleting);
  341. Transition(LOADERSTATE.ConfirmCompleting,FSM_MSG.TIMER,ConfirmComplete, LOADERSTATE.ConfirmCompleting);
  342. Transition(LOADERSTATE.ConfirmCompleting, LoaderMSG.PrepareForPlace, NullFunc, LOADERSTATE.WaitForUnload);
  343. Transition(LOADERSTATE.ConfirmCompleting,LoaderMSG.UnloadSide,ConfirmUnloadSide, LOADERSTATE.WaitForLoad);
  344. Transition(LOADERSTATE.ConfirmCompleting, LoaderMSG.LoadSide, ConfirmLoadSide, LOADERSTATE.Idle);
  345. EnumLoop<LOADERSTATE>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });
  346. EnumLoop<LoaderMSG>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
  347. }
  348. /// <summary>
  349. /// 恢复错误
  350. /// </summary>
  351. /// <param name="param"></param>
  352. /// <returns></returns>
  353. private bool ResumeError(object[] param)
  354. {
  355. if (_isHomed)
  356. {
  357. PostMsg(LoaderMSG.ReturnIdle);
  358. return false;
  359. }
  360. return true;
  361. }
  362. /// <summary>
  363. /// 检验Loader两边waferSize不一致
  364. /// </summary>
  365. /// <returns></returns>
  366. public bool CheckLoaderWaferSizeNotEqual()
  367. {
  368. return _sideAWaferSize != _sideBWaferSize;
  369. }
  370. #region Abort
  371. private bool Abort(object parameter)
  372. {
  373. bool preHomed = IsHomed;
  374. _shuttleAAxis.StopPositionOperation();
  375. _shuttleBAxis.StopPositionOperation();
  376. _tiltAAxis.StopPositionOperation();
  377. _tiltBAxis.StopPositionOperation();
  378. _crsAAxis.StopPositionOperation();
  379. _crsBAxis.StopPositionOperation();
  380. _rotationAxis.StopPositionOperation();
  381. if (_currentRoutine != null)
  382. {
  383. _currentRoutine.Abort();
  384. _currentRoutine = null;
  385. }
  386. if (preHomed)
  387. {
  388. PostMsg(LoaderMSG.ReturnIdle);
  389. return false;
  390. }
  391. //Header信息
  392. if (_headerdata != null)
  393. {
  394. WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  395. _headerdata.SequenceRecipe = (info != null ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : null);
  396. _headerdata.ProcessTransferList = (info != null ? info.SchedulerModules : null);
  397. LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
  398. _loadTimeList, _unloadTimeList, _unloadStartTime, LotTrackDatasStatus.None, LotTrackDatasStatus.None, LotTrackDatasStatus.None, _unloadLotTrackDatasBuffer, LotTrackDatasStatus.None);
  399. }
  400. return true;
  401. }
  402. #endregion
  403. /// <summary>
  404. /// 进入错误状态
  405. /// </summary>
  406. /// <param name="param"></param>
  407. /// <returns></returns>
  408. private bool EnterError(object param)
  409. {
  410. return true;
  411. }
  412. /// <summary>
  413. /// 进入初始化状态
  414. /// </summary>
  415. /// <param name="param"></param>
  416. /// <returns></returns>
  417. private bool EnterInit(object param)
  418. {
  419. _isHomed = false;
  420. return true;
  421. }
  422. #region HomeAll
  423. /// <summary>
  424. /// Home All
  425. /// </summary>
  426. /// <param name="param"></param>
  427. /// <returns></returns>
  428. private bool HomeAll(object[] param)
  429. {
  430. _isHomed = false;
  431. bool result= _homeAllRoutine.Start(param) == RState.Running;
  432. if (result)
  433. {
  434. _currentRoutine = _homeAllRoutine;
  435. }
  436. return result;
  437. }
  438. /// <summary>
  439. /// Load All监控
  440. /// </summary>
  441. /// <param name="param"></param>
  442. /// <returns></returns>
  443. private bool HomeAllMonitor(object[] param)
  444. {
  445. RState state = _homeAllRoutine.Monitor();
  446. if (state==RState.Failed||state==RState.Timeout)
  447. {
  448. _currentRoutine = null;
  449. PostMsg(LoaderMSG.Error);
  450. return false;
  451. }
  452. bool result= state == RState.End;
  453. if(result)
  454. {
  455. _currentRoutine = null;
  456. _isHomed = true;
  457. }
  458. return result;
  459. }
  460. #endregion
  461. #region Switch On All
  462. private bool SwitchOnAll(object[] param)
  463. {
  464. return _switchAllOnRoutine.Start(param) == RState.Running;
  465. }
  466. private bool SwitchOnAllMonitor(object[] param)
  467. {
  468. RState state = _switchAllOnRoutine.Monitor();
  469. if (state == RState.Failed || state == RState.Timeout)
  470. {
  471. PostMsg(LoaderMSG.ReturnInit);
  472. return false;
  473. }
  474. bool result= state == RState.End;
  475. if(result)
  476. {
  477. _isHomed = false;
  478. }
  479. return result;
  480. }
  481. #endregion
  482. #region Switch Off All
  483. private bool SwitchOffAll(object[] param)
  484. {
  485. return _switchAllOffRoutine.Start(param) == RState.Running;
  486. }
  487. private bool SwitchOffAllMonitor(object[] param)
  488. {
  489. RState state = _switchAllOffRoutine.Monitor();
  490. if (state == RState.Failed || state == RState.Timeout)
  491. {
  492. PostMsg(LoaderMSG.ReturnInit);
  493. return false;
  494. }
  495. bool result = state == RState.End;
  496. if (result)
  497. {
  498. _isHomed = false;
  499. }
  500. return result;
  501. }
  502. #endregion
  503. #region Prepare for Place
  504. /// <summary>
  505. /// Prepare For Place
  506. /// </summary>
  507. /// <returns></returns>
  508. private bool PrePareForPlace(object[] param)
  509. {
  510. //默认"TRNPA"
  511. string str = (param==null||param.Length==0)? "TRNPA":param[0].ToString();
  512. return _rotationAxis.PositionStation(str);
  513. }
  514. /// <summary>
  515. /// Prepare For Place监控
  516. /// </summary>
  517. /// <param name="param"></param>
  518. /// <returns></returns>
  519. private bool PrepareForPlaceMonitor(object param)
  520. {
  521. RState ret = _rotationAxis.Status;
  522. if (ret == RState.End)
  523. {
  524. return true;
  525. }
  526. if (ret == RState.Failed || ret == RState.Timeout)
  527. {
  528. PostMsg(LoaderMSG.Error);
  529. }
  530. return false;
  531. }
  532. #endregion
  533. #region Unload Side
  534. /// <summary>
  535. /// Unload Side
  536. /// </summary>
  537. /// <param name="param"></param>
  538. /// <returns></returns>
  539. private bool UnloadSide(object[] param)
  540. {
  541. bool result= _unloadSideRoutine.Start(param) == RState.Running;
  542. if(result)
  543. {
  544. LotTrackDataClear();
  545. _currentRoutine = _unloadSideRoutine;
  546. _unloadLotTrackDatas.Clear();
  547. _unloadLotTrackDatasBuffer.Clear();
  548. _unloadTimeList.Clear();
  549. _unloadTimeList.Add(DateTime.Now);
  550. _unloadStartTime = DateTime.Now;
  551. _loaderOperatingWaferInfosList["unload"] = GetWaferInfo();
  552. //Header信息
  553. _headerdata = new LotTrackFileHeaderCommonData();
  554. _headerdata.SoftWareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
  555. if (SC.ContainsItem("System.ToolID")) _headerdata.ToolID = SC.GetStringValue("System.ToolID");
  556. _loadDatasStatus = LotTrackDatasStatus.None;
  557. _unloadDatasStatus = LotTrackDatasStatus.None;
  558. _flowTestDatasStatus = LotTrackDatasStatus.None;
  559. _headerdata.ProcessTransferList = new List<string>();
  560. }
  561. return result;
  562. }
  563. /// <summary>
  564. /// Retry UloadSide
  565. /// </summary>
  566. /// <param name="param"></param>
  567. /// <returns></returns>
  568. private bool RetryUnloadSide(object[] param)
  569. {
  570. int stepIndex = (int)param[0];
  571. bool result = _unloadSideRoutine.Retry(stepIndex)==RState.Running;
  572. if (result)
  573. {
  574. _unloadDatasStatus = LotTrackDatasStatus.Half;
  575. _unloadLotTrackDatas.Clear();
  576. _currentRoutine = _unloadSideRoutine;
  577. }
  578. return result;
  579. }
  580. /// <summary>
  581. /// Unload Side监控
  582. /// </summary>
  583. /// <param name="param"></param>
  584. /// <returns></returns>
  585. private bool UnloadSideMonitor(object param)
  586. {
  587. RState ret = _unloadSideRoutine.Monitor();
  588. if (ret == RState.End)
  589. {
  590. AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), LOADERSTATE.Unloading.ToString());
  591. _unloadLotTrackDatas = _unloadSideRoutine.UnloadLotTrackDatas;
  592. _unloadLotTrackDatasBuffer.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
  593. _unloadTimeList.Add(DateTime.Now);
  594. //Header信息
  595. WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  596. _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
  597. if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
  598. info.SchedulerModules.Clear();
  599. LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
  600. _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasStatus, true);
  601. return true;
  602. }
  603. if (ret == RState.Failed || ret == RState.Timeout)
  604. {
  605. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  606. {
  607. AlarmList alarmList = new AlarmList(Module.ToString(), ((LOADERSTATE)fsm.State).ToString(), (int)LoaderMSG.UnloadSide,
  608. _unloadSideRoutine.ErrorMsg, _unloadSideRoutine.ErrorStep, (int)AlarmType.Error);
  609. AlarmListManager.Instance.AddAlarm(alarmList);
  610. }
  611. PostMsg(LoaderMSG.Error);
  612. _unloadLotTrackDatas = _unloadSideRoutine.UnloadLotTrackDatas;
  613. _unloadLotTrackDatasBuffer.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
  614. ////Header信息
  615. WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  616. _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
  617. if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
  618. info.SchedulerModules.Clear();
  619. LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
  620. _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasStatus, true);
  621. }
  622. return false;
  623. }
  624. /// <summary>
  625. /// 确认UnloadAll是否完成
  626. /// </summary>
  627. /// <param name="param"></param>
  628. /// <returns></returns>
  629. private bool ConfirmUnloadSide(object[] param)
  630. {
  631. int stepIdex=(int)param[0];
  632. bool result = _unloadSideRoutine.CheckCompleteCondition(stepIdex);
  633. if(!result)
  634. {
  635. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  636. {
  637. AlarmList alarmList = new AlarmList(Module.ToString(), ((LOADERSTATE)fsm.State).ToString(), (int)LoaderMSG.UnloadSide,
  638. _unloadSideRoutine.ErrorMsg, _unloadSideRoutine.ErrorStep, (int)AlarmType.Error);
  639. AlarmListManager.Instance.AddAlarm(alarmList);
  640. }
  641. PostMsg(LoaderMSG.Error);
  642. }
  643. else
  644. {
  645. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  646. {
  647. AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), LOADERSTATE.Unloading.ToString());
  648. }
  649. }
  650. return result;
  651. }
  652. #endregion
  653. #region Load Side
  654. /// <summary>
  655. /// Load Side
  656. /// </summary>
  657. /// <param name="param"></param>
  658. /// <returns></returns>
  659. private bool LoadSide(object[] param)
  660. {
  661. bool result= _loadSideRoutine.Start(param) == RState.Running;
  662. if(result)
  663. {
  664. _currentRoutine = _loadSideRoutine;
  665. //_loadTimeList.Clear();
  666. _flowLotTrackdatas.Clear();
  667. _loadLotTrackDatas.Clear();
  668. _loadDatasStatus = LotTrackDatasStatus.None;
  669. _flowTestDatasStatus = LotTrackDatasStatus.None;
  670. _unloadDatasStatus = LotTrackDatasStatus.Complete;
  671. _unloadDatasBufferStatus = LotTrackDatasStatus.None;
  672. }
  673. return result;
  674. }
  675. /// <summary>
  676. /// Retry LoadSide
  677. /// </summary>
  678. /// <param name="param"></param>
  679. /// <returns></returns>
  680. private bool RetryLoadSide(object[] param)
  681. {
  682. int stepIndex = (int)param[0];
  683. bool result = _loadSideRoutine.Retry(stepIndex) == RState.Running;
  684. if (result)
  685. {
  686. _unloadDatasStatus = LotTrackDatasStatus.Complete;
  687. _unloadDatasBufferStatus = LotTrackDatasStatus.Complete;
  688. SetLotTrackDatasStatus(stepIndex);
  689. _currentRoutine = _loadSideRoutine;
  690. }
  691. return result;
  692. }
  693. /// <summary>
  694. /// 监控LoadSide
  695. /// </summary>
  696. /// <param name="param"></param>
  697. /// <returns></returns>
  698. private bool LoadSideMonitor(object param)
  699. {
  700. RState ret = _loadSideRoutine.Monitor();
  701. if (ret == RState.End)
  702. {
  703. AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), LOADERSTATE.Loading.ToString());
  704. _loadLotTrackDatas = _loadSideRoutine.LoadLotTrackDatas;
  705. _loadTimeList = _loadSideRoutine.LoadTimeList;
  706. _flowLotTrackdatas = _loadSideRoutine.FlowLotTrackDatas;
  707. bool clearFlag = _loadDatasStatus == LotTrackDatasStatus.None && _flowTestDatasStatus == LotTrackDatasStatus.None;
  708. _loaderOperatingWaferInfosList["load"] = GetWaferInfo(clearFlag);
  709. //Header信息
  710. WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  711. _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
  712. if(info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
  713. info.SchedulerModules.Clear();
  714. LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
  715. _loadTimeList, _unloadTimeList,_unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasBufferStatus);
  716. return true;
  717. }
  718. if (ret == RState.Failed || ret == RState.Timeout)
  719. {
  720. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  721. {
  722. AlarmList alarmList = new AlarmList(Module.ToString(), ((LOADERSTATE)fsm.State).ToString(), (int)LoaderMSG.LoadSide,
  723. _loadSideRoutine.ErrorMsg, _loadSideRoutine.ErrorStep, (int)AlarmType.Error);
  724. AlarmListManager.Instance.AddAlarm(alarmList);
  725. }
  726. PostMsg(LoaderMSG.Error);
  727. _loadLotTrackDatas = _loadSideRoutine.LoadLotTrackDatas;
  728. _loadTimeList = _loadSideRoutine.LoadTimeList;
  729. _flowLotTrackdatas = _loadSideRoutine.FlowLotTrackDatas;
  730. bool clearFlag = _loadDatasStatus == LotTrackDatasStatus.None && _flowTestDatasStatus == LotTrackDatasStatus.None;
  731. _loaderOperatingWaferInfosList["load"] = GetWaferInfo(clearFlag);
  732. //Header信息
  733. WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  734. _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
  735. if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
  736. info.SchedulerModules.Clear();
  737. LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
  738. _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasBufferStatus);
  739. }
  740. return false;
  741. }
  742. /// <summary>
  743. /// 确认UnloadSide是否完成
  744. /// </summary>
  745. /// <param name="param"></param>
  746. /// <returns></returns>
  747. private bool ConfirmLoadSide(object[] param)
  748. {
  749. int stepIdex = (int)param[0];
  750. bool result = _loadSideRoutine.CheckCompleteCondition(stepIdex);
  751. if (!result)
  752. {
  753. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  754. {
  755. AlarmList alarmList = new AlarmList(Module.ToString(), ((LOADERSTATE)fsm.State).ToString(), (int)LoaderMSG.LoadSide,
  756. _loadSideRoutine.ErrorMsg, _loadSideRoutine.ErrorStep, (int)AlarmType.Error);
  757. AlarmListManager.Instance.AddAlarm(alarmList);
  758. }
  759. PostMsg(LoaderMSG.Error);
  760. }
  761. else
  762. {
  763. if (Singleton<RouteManager>.Instance.IsAutoRunning)
  764. {
  765. AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(),LOADERSTATE.Loading.ToString());
  766. }
  767. }
  768. return result;
  769. }
  770. #endregion
  771. #region LotTrack
  772. /// <summary>
  773. /// 获取Wafer信息
  774. /// </summary>
  775. private List<string> GetWaferInfo(bool clearPath = false)
  776. {
  777. List<string> waferIDs = new List<string>(new string[2]);
  778. WaferHolderInfo whInfo = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
  779. if (whInfo == null) return null;
  780. waferIDs[0] = string.IsNullOrEmpty(whInfo.WaferAId) ? "" : whInfo.WaferAId;
  781. waferIDs[1] = string.IsNullOrEmpty(whInfo.WaferBId) ? "" : whInfo.WaferBId;
  782. if (clearPath && !string.IsNullOrEmpty(waferIDs[0])) WaferManager.Instance.ClearWaferLotTrackPath(ModuleName.Loader1, 0);
  783. if (clearPath && !string.IsNullOrEmpty(waferIDs[1])) WaferManager.Instance.ClearWaferLotTrackPath(ModuleName.Loader1, 1);
  784. return waferIDs;
  785. }
  786. /// <summary>
  787. /// 清除信息
  788. /// </summary>
  789. private void LotTrackDataClear()
  790. {
  791. _headerdata = null;
  792. _loadLotTrackDatas.Clear();
  793. _unloadLotTrackDatas.Clear();
  794. _flowLotTrackdatas.Clear();
  795. _loadTimeList.Clear();
  796. _unloadTimeList.Clear();
  797. _loaderOperatingWaferInfosList["load"].Clear();
  798. _loaderOperatingWaferInfosList["unload"].Clear();
  799. }
  800. /// <summary>
  801. /// 设置Load LotTrackDatas记录状态
  802. /// </summary>
  803. /// <param name="stepIndex"></param>
  804. private void SetLotTrackDatasStatus(int stepIndex)
  805. {
  806. if (stepIndex == 0 || stepIndex == -1)
  807. {
  808. _loadDatasStatus = LotTrackDatasStatus.Half;
  809. _flowTestDatasStatus = LotTrackDatasStatus.None;
  810. }
  811. else if (stepIndex == 1)
  812. {
  813. _loadDatasStatus = LotTrackDatasStatus.Complete;
  814. _flowTestDatasStatus = LotTrackDatasStatus.None;
  815. }
  816. else
  817. {
  818. _loadDatasStatus = LotTrackDatasStatus.Complete;
  819. _flowTestDatasStatus = LotTrackDatasStatus.Complete;
  820. }
  821. }
  822. #endregion
  823. #region LoaderRetry
  824. /// <summary>
  825. /// Retry
  826. /// </summary>
  827. /// <param name="param"></param>
  828. /// <returns></returns>
  829. private bool LoaderRetry(object[] param)
  830. {
  831. AlarmList alarmList = AlarmListManager.Instance.GetAlarmListByModule(Module.ToString());
  832. if (alarmList != null)
  833. {
  834. CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), alarmList.ModuleCmd,
  835. alarmList.ModuleStep);
  836. }
  837. return false;
  838. }
  839. #endregion
  840. #region ConfirmComplete
  841. /// <summary>
  842. /// 确认是否完成
  843. /// </summary>
  844. /// <param name="param"></param>
  845. /// <returns></returns>
  846. private bool ConfirmComplete(object[] param)
  847. {
  848. AlarmList alarmList = AlarmListManager.Instance.GetAlarmListByModule(Module.ToString());
  849. if (alarmList != null)
  850. {
  851. if(alarmList.ModuleState==LOADERSTATE.Unloading.ToString())
  852. {
  853. CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(),(int)LoaderMSG.UnloadSide,alarmList.ModuleStep);
  854. }
  855. else if(alarmList.ModuleState==LOADERSTATE.Loading.ToString())
  856. {
  857. CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.LoadSide,alarmList.ModuleStep);
  858. }
  859. else if (alarmList.ModuleState == LOADERSTATE.PrepreForPlacing.ToString())
  860. {
  861. CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.PrepareForPlace, alarmList.ModuleStep);
  862. }
  863. else
  864. {
  865. PostMsg(LoaderMSG.Error);
  866. }
  867. }
  868. return false;
  869. }
  870. /// <summary>
  871. /// 清除报警
  872. /// </summary>
  873. /// <param name="param"></param>
  874. /// <returns></returns>
  875. private bool ClearModuleAlarm(object[] param)
  876. {
  877. AlarmList alarmList = AlarmListManager.Instance.GetAlarmListByModule(Module.ToString());
  878. if (alarmList != null)
  879. {
  880. AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), "");
  881. }
  882. return true;
  883. }
  884. #endregion
  885. public bool Check(int msg, out string reason, params object[] args)
  886. {
  887. reason = "";
  888. return false;
  889. }
  890. public bool CheckAcked(int msg)
  891. {
  892. return false;
  893. }
  894. public int Invoke(string function, params object[] args)
  895. {
  896. switch (function)
  897. {
  898. case "HomeAll":
  899. if(IsIdle)
  900. {
  901. return (int)FSM_MSG.NONE;
  902. }
  903. if (CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.HomeAll))
  904. {
  905. return (int)FSM_MSG.NONE;
  906. }
  907. else
  908. {
  909. return (int)FSM_MSG.ALARM;
  910. }
  911. case "Abort":
  912. CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.Abort);
  913. return (int)FSM_MSG.NONE;
  914. case "PrepareForPlace":
  915. if (State == (int)LOADERSTATE.WaitForUnload||State==(int)LOADERSTATE.PrepreForPlacing)
  916. {
  917. return (int)LoaderMSG.PrepareForPlace;
  918. }
  919. if (CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.WARN_LOADER, Module.ToString(), (int)LoaderMSG.PrepareForPlace,args))
  920. {
  921. return (int)LoaderMSG.PrepareForPlace;
  922. }
  923. else
  924. {
  925. return (int)FSM_MSG.NONE;
  926. }
  927. case "Retry":
  928. if (CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.Retry,args))
  929. {
  930. return (int)LoaderMSG.Retry;
  931. }
  932. else
  933. {
  934. return (int)FSM_MSG.NONE;
  935. }
  936. case "ConfirmComplete":
  937. if (CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.ERR_LOADER, Module.ToString(), (int)LoaderMSG.ConfirmComplete, args))
  938. {
  939. return (int)LoaderMSG.ConfirmComplete;
  940. }
  941. else
  942. {
  943. return (int)FSM_MSG.NONE;
  944. }
  945. }
  946. return (int)FSM_MSG.NONE;
  947. }
  948. }
  949. public enum LoaderMSG
  950. {
  951. ReturnInit,
  952. ReturnIdle,
  953. Abort,
  954. HomeAll,
  955. GoToSavedPosition,
  956. StopFlow,
  957. SwitchOnAll,
  958. SwitchOffAll,
  959. Error,
  960. ClearError,
  961. PrepareForPlace,
  962. ReadyForPuf,
  963. UnloadSide,
  964. LoadSide,
  965. Retry,
  966. ConfirmComplete,
  967. WaitFlip,
  968. }
  969. }