SchedulerPM.cs 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using Aitex.Core.Common;
  8. using Aitex.Core.RT.DataCenter;
  9. using Aitex.Core.RT.Device;
  10. using Aitex.Core.RT.Event;
  11. using Aitex.Core.RT.Fsm;
  12. using Aitex.Core.RT.Log;
  13. using Aitex.Core.RT.SCCore;
  14. using Aitex.Core.Util;
  15. using Aitex.Sorter.Common;
  16. using VirgoRT.Module;
  17. using VirgoRT.Modules;
  18. using MECF.Framework.Common.Equipment;
  19. using MECF.Framework.Common.Schedulers;
  20. using MECF.Framework.Common.SubstrateTrackings;
  21. using VirgoRT.Devices;
  22. namespace VirgoRT.Scheduler
  23. {
  24. public class SchedulerPM : SchedulerModule
  25. {
  26. public override bool IsAvailable
  27. {
  28. get { return _entity.IsIdle && _entity.IsOnline && CheckTaskDone() && !_waitCompletejobClean; }
  29. }
  30. public override bool IsOnline
  31. {
  32. get { return _entity != null && _entity.IsOnline; }
  33. }
  34. public override bool IsError
  35. {
  36. get { return _entity.IsError; }
  37. }
  38. public bool IsIdle
  39. {
  40. get { return _entity.IsIdle && _entity.IsOnline && CheckTaskDone() ; }
  41. }
  42. public TaskType Task => _task;
  43. private PMEntity _entity = null;
  44. private ModuleName _taskRobot;
  45. private EnumTransferType _taskTransferType;
  46. private Hand _taskBlade;
  47. private int _taskSlot;
  48. private int _entityTaskToken = (int)FSM_MSG.NONE;
  49. private DeviceTimer _timerProcess = new DeviceTimer();
  50. private JetPM _pm;
  51. private float _paramTemp;
  52. public float Temperature
  53. {
  54. get
  55. {
  56. if (SC.GetValue<bool>($"{Module}.Chiller.EnableChiller"))
  57. {
  58. return _pm.CoolantOutletTempFB;
  59. }
  60. return _pm.SubstrateTempFB;
  61. }
  62. }
  63. public RD_TRIG IdlePurgeTrig { get; set; }
  64. public Stopwatch IdlePurgeTimer { get; set; }
  65. public int IdlePurgeTime { get; set; }
  66. public int IdlePurgeNextRunTime { get; set; }
  67. public RD_TRIG IdleCleanTrig { get; set; }
  68. public Stopwatch IdleCleanTimer { get; set; }
  69. public int IdleCleanTime { get; set; }
  70. public int IdleCleanNextRunTime { get; set; }
  71. private bool _waitPreJobClean;
  72. private bool _waitCompletejobClean;
  73. private R_TRIG _trigIdleCleanFailed = new R_TRIG();
  74. private R_TRIG _trigIdlePurgeFailed = new R_TRIG();
  75. public RD_TRIG PreJobCleanTrig { get; set; }
  76. public Stopwatch PreJobCleanTimer { get; set; }
  77. public int PreJobCleanTime { get; set; }
  78. public SchedulerPM(ModuleName chamber) : base(chamber.ToString())
  79. {
  80. switch (chamber)
  81. {
  82. case ModuleName.PMA:
  83. _entity = Singleton<RouteManager>.Instance.PMA;
  84. break;
  85. case ModuleName.PMB:
  86. _entity = Singleton<RouteManager>.Instance.PMB;
  87. break;
  88. }
  89. _pm = DEVICE.GetDevice<JetPM>(Module.ToString());
  90. IdlePurgeTrig = new RD_TRIG();
  91. IdlePurgeTimer = new Stopwatch();
  92. IdleCleanTrig = new RD_TRIG();
  93. IdleCleanTimer = new Stopwatch();
  94. PreJobCleanTrig = new RD_TRIG();
  95. PreJobCleanTimer = new Stopwatch();
  96. }
  97. public void InitClean()
  98. {
  99. DATA.Subscribe($"{Module}.IdlePurgeNextRunTime", () => IdlePurgeNextRunTime);
  100. DATA.Subscribe($"{Module}.IdleCleanNextRunTime", () => IdleCleanNextRunTime);
  101. }
  102. public override bool IsReadyForPick(ModuleName robot, int slot, Hand blade)
  103. {
  104. return _entity.IsPrepareTransferReady(robot, EnumTransferType.Pick, slot, blade)
  105. && WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);
  106. }
  107. public override bool IsReadyForPlace(ModuleName robot, int slot, Hand blade)
  108. {
  109. return _entity.IsPrepareTransferReady(robot, EnumTransferType.Place, slot, blade)
  110. && WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
  111. }
  112. public bool IsTemperatureReady(float temp)
  113. {
  114. return Math.Abs(Temperature - temp) < SC.GetValue<double>("System.MaxTemperatureToleranceTransferWafer");
  115. }
  116. public bool IsPrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
  117. {
  118. return _task == TaskType.PrepareTransfer && _taskRobot == robot && _taskSlot == slot &&
  119. _taskTransferType == type;
  120. }
  121. public override bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
  122. {
  123. _task = TaskType.PrepareTransfer;
  124. _taskRobot = robot;
  125. _taskSlot = slot;
  126. _taskTransferType = type;
  127. _entityTaskToken = _entity.InvokePrepareTransfer(robot, type, slot);
  128. LogTaskStart(_task, $"{robot} {type} slot {slot + 1}");
  129. return _entityTaskToken != (int)FSM_MSG.NONE;
  130. }
  131. public bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp, Hand blade)
  132. {
  133. _task = TaskType.PrepareTransfer;
  134. _taskRobot = robot;
  135. _taskSlot = slot;
  136. _taskBlade = blade;
  137. _taskTransferType = type;
  138. _entityTaskToken = _entity.InvokePrepareTransfer(robot, type, slot, temp);
  139. LogTaskStart(_task, $"{robot} {type} slot {slot + 1}");
  140. return _entityTaskToken != (int)FSM_MSG.NONE;
  141. }
  142. public bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot, float temp, Hand blade, WaferSize size)
  143. {
  144. _task = TaskType.PrepareTransfer;
  145. _taskRobot = robot;
  146. _taskSlot = slot;
  147. _taskBlade = blade;
  148. _taskTransferType = type;
  149. _entityTaskToken = _entity.InvokePrepareTransfer(robot, type, slot, temp, size);
  150. LogTaskStart(_task, $"{robot} {type} slot {slot + 1}, {size}");
  151. return _entityTaskToken != (int)FSM_MSG.NONE;
  152. }
  153. public override bool PostTransfer(ModuleName robot, EnumTransferType type, int slot)
  154. {
  155. StopWaitTransfer(robot);
  156. _task = TaskType.PostTransfer;
  157. _taskRobot = robot;
  158. _taskSlot = slot;
  159. _taskTransferType = type;
  160. _entityTaskToken = _entity.InvokePostTransfer(robot, type, slot);
  161. LogTaskStart(_task, $"{robot} {type} slot {slot + 1}");
  162. return _entityTaskToken != (int)FSM_MSG.NONE;
  163. }
  164. public override bool PostTransfer(ModuleName robot)
  165. {
  166. StopWaitTransfer(robot);
  167. _task = TaskType.PostTransfer;
  168. _taskRobot = robot;
  169. _taskSlot = _inTransferSlot;
  170. _taskTransferType = _inTransferType;
  171. _entityTaskToken = _entity.InvokePostTransfer(robot, _inTransferType, _inTransferSlot);
  172. LogTaskStart(_task, $"{robot} {_inTransferType} slot {_inTransferSlot + 1}");
  173. return _entityTaskToken != (int)FSM_MSG.NONE;
  174. }
  175. public override bool Process(string recipeName, bool isCleanRecipe, bool withWafer, WaferInfo wafer)
  176. {
  177. _task = TaskType.Process;
  178. LogTaskStart(_task, $"recipe: {recipeName}, clean: {isCleanRecipe}, with wafer: {withWafer}");
  179. if (SC.GetValue<bool>("System.IsATMMode"))
  180. {
  181. int time = SC.GetValue<int>("System.ATMCyclePMDelayTime");
  182. _timerProcess.Start(time * 1000);
  183. EV.PostInfoLog("Scheduler", $"System run in ATM mode, process skipped, delay {time} seconds");
  184. _pm.SetLiftPin(VirgoCommon.MovementPosition.Down, out _);
  185. _entityTaskToken = (int)PMEntity.MSG.MoveLiftPin;
  186. WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.InProcess);
  187. return true;
  188. }
  189. else
  190. {
  191. _entityTaskToken = _entity.InvokeProcess(recipeName, wafer.WaferOrigin, withWafer);
  192. return _entityTaskToken != (int)FSM_MSG.NONE;
  193. }
  194. }
  195. public override bool Preheating(float temperature)
  196. {
  197. _task = TaskType.Heating;
  198. _paramTemp = temperature;
  199. _entityTaskToken = _entity.InvokePreHeat(temperature);
  200. LogTaskStart(_task, $"preheat to {temperature}");
  201. return _entityTaskToken != (int)FSM_MSG.NONE;
  202. }
  203. public bool CheckTaskDone()
  204. {
  205. bool ret = false;
  206. switch (_task)
  207. {
  208. case TaskType.None:
  209. ret = true;
  210. break;
  211. case TaskType.PrepareTransfer:
  212. ret = _entity.CheckAcked(_entityTaskToken) && _entity.IsPrepareTransferReady(_taskRobot, _taskTransferType, _taskSlot, _taskBlade);
  213. break;
  214. case TaskType.PostTransfer:
  215. ret = _entity.CheckAcked(_entityTaskToken);
  216. break;
  217. case TaskType.Heating:
  218. ret = _entity.CheckAcked(_entityTaskToken) && IsTemperatureReady(_paramTemp);
  219. break;
  220. case TaskType.Process:
  221. case TaskType.IdlePurgeProcess:
  222. case TaskType.IdleCleanProcess:
  223. case TaskType.PreJobProcess:
  224. case TaskType.CompleteJobProcess:
  225. if (SC.GetValue<bool>("System.IsATMMode"))
  226. {
  227. ret = _timerProcess.IsTimeout() && _entity.IsIdle && (_entityTaskToken != (int)PMEntity.MSG.MoveLiftPin || _pm.CheckLiftDown());
  228. if (ret)
  229. WaferManager.Instance.UpdateWaferProcessStatus(Module, 0, EnumWaferProcessStatus.Completed);
  230. }
  231. else
  232. {
  233. ret = _entity.CheckAcked(_entityTaskToken) && _entity.IsProcessed();
  234. }
  235. break;
  236. }
  237. if (ret && _task != TaskType.None)
  238. {
  239. LogTaskDone(_task, "");
  240. _task = TaskType.None;
  241. }
  242. return ret;
  243. }
  244. public bool Monitor()
  245. {
  246. return true;
  247. }
  248. public void SetPMAuto()
  249. {
  250. _entity.SetAuto();
  251. }
  252. public bool IdlePurgeProcess(string recipeName)
  253. {
  254. _task = TaskType.IdlePurgeProcess;
  255. _entityTaskToken = _entity.InvokeClean(recipeName, "", false);
  256. LogTaskStart(_task, $"recipe: {recipeName}, clean: {false}, with wafer: {false}");
  257. return _entityTaskToken != (int)FSM_MSG.NONE;
  258. }
  259. public bool IdleCleanProcess(string recipeName)
  260. {
  261. _task = TaskType.IdleCleanProcess;
  262. _entityTaskToken = _entity.InvokeClean(recipeName, "", false);
  263. LogTaskStart(_task, $"recipe: {recipeName}, clean: {true}, with wafer: {false}");
  264. return _entityTaskToken != (int)FSM_MSG.NONE;
  265. }
  266. public void PreJobClean()
  267. {
  268. var enableJobClean = SC.GetValue<bool>($"{Module}.JobClean.IsEnabled");
  269. var enablePreJobClean = SC.GetValue<bool>($"{Module}.JobClean.EnablePreJobClean");
  270. _waitPreJobClean = enableJobClean && enablePreJobClean;
  271. }
  272. public bool PreJobProcess(string recipeName)
  273. {
  274. _task = TaskType.PreJobProcess;
  275. _entityTaskToken = _entity.InvokeClean(recipeName, "", false);
  276. LogTaskStart(_task, $"recipe: {recipeName}, clean: {true}, with wafer: {false}");
  277. return _entityTaskToken != (int)FSM_MSG.NONE;
  278. }
  279. public void CompleteJobClean()
  280. {
  281. var enableJobClean = SC.GetValue<bool>($"{Module}.JobClean.IsEnabled");
  282. var enableCompleteJobClean = SC.GetValue<bool>($"{Module}.JobClean.EnableCompleteJobClean");
  283. _waitCompletejobClean = enableJobClean && enableCompleteJobClean;
  284. }
  285. public bool CompleteJobProcess(string recipeName)
  286. {
  287. _task = TaskType.CompleteJobProcess;
  288. _entityTaskToken = _entity.InvokeClean(recipeName, "", false);
  289. LogTaskStart(_task, $"recipe: {recipeName}, clean: {true}, with wafer: {false}");
  290. return _entityTaskToken != (int)FSM_MSG.NONE;
  291. }
  292. #region clean task
  293. internal void ResetIdlePurgeTime()
  294. {
  295. IdlePurgeTimer.Restart();
  296. }
  297. internal void ResetIdleCleanTime()
  298. {
  299. IdleCleanTimer.Restart();
  300. }
  301. public bool ResetClean(bool resetPurge, bool resetClean, bool jobClean)
  302. {
  303. if (resetPurge)
  304. {
  305. IdlePurgeTrig.RST = true;
  306. IdlePurgeTimer.Stop();
  307. IdlePurgeTime = 0;
  308. }
  309. if (resetClean)
  310. {
  311. IdleCleanTrig.RST = true;
  312. IdleCleanTimer.Stop();
  313. IdleCleanTime = 0;
  314. }
  315. if (jobClean)
  316. {
  317. _waitPreJobClean = false;
  318. _waitCompletejobClean = false;
  319. PreJobCleanTrig.RST = true;
  320. PreJobCleanTimer.Stop();
  321. }
  322. return true;
  323. }
  324. public void MonitorCleanTasks()
  325. {
  326. var hasWafer = WaferManager.Instance.CheckHasWafer(Module, 0);
  327. var enablePurge = false;//SC.GetValue<bool>($"{Module}.IdlePurge.IsEnabled");
  328. var enableClean = SC.GetValue<bool>($"{Module}.IdleClean.IsEnabled");
  329. #region Idle Purge
  330. IdlePurgeTrig.CLK = (IsIdle || _task != TaskType.IdlePurgeProcess) && enablePurge && !hasWafer;
  331. if (IdlePurgeTrig.R)
  332. {
  333. LOG.Write($"{Module} idle purge start calc elapse time");
  334. IdlePurgeTimer.Restart();
  335. }
  336. if (IdlePurgeTrig.T)
  337. {
  338. LOG.Write($"{Module} idle purge stopped calc elapse time");
  339. ResetClean(true, false, false);
  340. }
  341. if (IdlePurgeTimer.IsRunning)
  342. {
  343. IdlePurgeTime = (int)IdlePurgeTimer.ElapsedMilliseconds / 1000;
  344. int idlePurgeTimeSetPoint = SC.GetValue<int>($"{Module}.IdlePurge.IdlePurgeTime");
  345. var nextRunTime = idlePurgeTimeSetPoint - IdlePurgeTime;
  346. if (nextRunTime < 0)
  347. nextRunTime = 0;
  348. if (enablePurge)
  349. {
  350. if (nextRunTime <= 0 && IsAvailable)
  351. {
  352. var recipe = SC.GetStringValue($"{Module}.IdlePurge.IdlePurgeRecipe");
  353. if (string.IsNullOrEmpty(recipe))
  354. {
  355. _trigIdlePurgeFailed.CLK = true;
  356. LOG.Write($"{Module} Idle purge can not run, recipe is empty");
  357. ResetClean(true, false, false);
  358. }
  359. else if (hasWafer)
  360. {
  361. _trigIdlePurgeFailed.CLK = true;
  362. LOG.Write($"{Module} Idle purge can not run, has wafer");
  363. ResetClean(true, false, false);
  364. }
  365. else
  366. {
  367. _trigIdlePurgeFailed.CLK = false;
  368. LOG.Write($"{Module} Start run idle purge recipe {recipe}");
  369. IdlePurgeProcess("ALD\\Process\\" + recipe);
  370. }
  371. if (_trigIdlePurgeFailed.Q)
  372. {
  373. EV.PostWarningLog(Module.ToString(), "Can not run idle purge recipe");
  374. }
  375. }
  376. }
  377. else
  378. {
  379. nextRunTime = 0;
  380. }
  381. IdlePurgeNextRunTime = nextRunTime;
  382. }
  383. else
  384. {
  385. IdlePurgeNextRunTime = 0;
  386. }
  387. #endregion
  388. #region Idle Clean
  389. IdleCleanTrig.CLK = (IsIdle || _task != TaskType.IdleCleanProcess) && enableClean && !hasWafer;
  390. if (IdleCleanTrig.R)
  391. {
  392. LOG.Write($"{Module} idle clean start calc elapse time");
  393. IdleCleanTimer.Restart();
  394. }
  395. if (IdleCleanTrig.T)
  396. {
  397. LOG.Write($"{Module} idle clean stopped calc elapse time");
  398. ResetClean(false, true, false);
  399. }
  400. if (IdleCleanTimer.IsRunning)
  401. {
  402. IdleCleanTime = (int)IdleCleanTimer.ElapsedMilliseconds / 1000;
  403. int idleCleanTimeSetPoint = SC.GetValue<int>($"{Module}.IdleClean.IdleCleanTime");
  404. var nextRunTime = idleCleanTimeSetPoint - IdleCleanTime;
  405. if (nextRunTime < 0)
  406. nextRunTime = 0;
  407. if (enableClean)
  408. {
  409. if (nextRunTime <= 0 && IsAvailable)
  410. {
  411. var recipe = SC.GetStringValue($"{Module}.IdleClean.IdleCleanRecipe");
  412. if (string.IsNullOrEmpty(recipe))
  413. {
  414. _trigIdleCleanFailed.CLK = true;
  415. LOG.Write($"{Module} Idle clean can not run, recipe is empty");
  416. ResetClean(false, true, false);
  417. }
  418. else if (hasWafer)
  419. {
  420. _trigIdleCleanFailed.CLK = true;
  421. LOG.Write($"{Module} Idle clean can not run, has wafer");
  422. ResetClean(false, true, false);
  423. }
  424. else
  425. {
  426. _trigIdleCleanFailed.CLK = false;
  427. LOG.Write($"{Module} Start run idle Clean recipe {recipe}");
  428. IdleCleanProcess($"{Module}\\" + recipe);
  429. }
  430. if (_trigIdleCleanFailed.Q)
  431. {
  432. EV.PostWarningLog(Module.ToString(), "Can not run idle clean recipe");
  433. }
  434. }
  435. }
  436. else
  437. {
  438. nextRunTime = 0;
  439. }
  440. IdleCleanNextRunTime = nextRunTime;
  441. }
  442. else
  443. {
  444. IdleCleanNextRunTime = 0;
  445. }
  446. #endregion
  447. #region PreJob Clean
  448. var enableJobClean = SC.GetValue<bool>($"{Module}.JobClean.IsEnabled");
  449. var enablePreJobClean = SC.GetValue<bool>($"{Module}.JobClean.EnablePreJobClean");
  450. var enableCompleteJobClean = SC.GetValue<bool>($"{Module}.JobClean.EnableCompleteJobClean");
  451. if (enableJobClean && enableCompleteJobClean && _waitCompletejobClean && IsIdle)
  452. {
  453. var recipe = SC.GetStringValue($"{Module}.JobClean.CompleteJobCleanRecipe");
  454. if (string.IsNullOrEmpty(recipe))
  455. {
  456. EV.PostWarningLog(Module.ToString(), "complete job clean can not run, recipe is empty");
  457. }
  458. else if (hasWafer)
  459. {
  460. EV.PostWarningLog(Module.ToString(), "complete job clean can not run, has wafer");
  461. }
  462. else
  463. {
  464. EV.PostInfoLog(Module.ToString(), $"Start run complete job clean recipe {recipe}");
  465. CompleteJobProcess($"{Module}\\" + recipe);
  466. }
  467. _waitCompletejobClean = false;
  468. }
  469. PreJobCleanTrig.CLK = enableJobClean && enablePreJobClean && IsIdle;
  470. if (PreJobCleanTrig.R)
  471. {
  472. PreJobCleanTimer.Restart();
  473. }
  474. if(PreJobCleanTrig.T)
  475. {
  476. ResetClean(false, false, true);
  477. }
  478. if (PreJobCleanTimer.IsRunning && _waitPreJobClean)
  479. {
  480. PreJobCleanTime = (int)PreJobCleanTimer.ElapsedMilliseconds / 1000;
  481. int PreJobCleanIdleTimeSP = SC.GetValue<int>($"{Module}.JobClean.IdleCleanTime");
  482. if(PreJobCleanTime >= PreJobCleanIdleTimeSP)
  483. {
  484. var recipe = SC.GetStringValue($"{Module}.JobClean.PreJobCleanRecipe");
  485. if (string.IsNullOrEmpty(recipe))
  486. {
  487. EV.PostWarningLog(Module.ToString(), "pre job clean can not run, recipe is empty");
  488. }
  489. else if (hasWafer)
  490. {
  491. EV.PostWarningLog(Module.ToString(), "pre job clean can not run, has wafer");
  492. }
  493. else
  494. {
  495. EV.PostInfoLog(Module.ToString(), $"Start run pre job clean recipe {recipe}");
  496. PreJobProcess($"{Module}\\" + recipe);
  497. }
  498. }
  499. }
  500. #endregion
  501. }
  502. #endregion
  503. }
  504. }