SchedulerSequenceManager.cs 61 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335
  1. using MECF.Framework.Common.RecipeCenter;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using MECF.Framework.Common.Equipment;
  8. using MECF.Framework.Common.Schedulers;
  9. using Aitex.Core.Common;
  10. using MECF.Framework.Common.WaferHolder;
  11. using MECF.Framework.Common.CommonData;
  12. using System.Windows;
  13. using Aitex.Core.RT.IOCore;
  14. using Aitex.Core.RT.Log;
  15. using Aitex.Core.Util;
  16. using MECF.Framework.Common.Routine;
  17. using CyberX8_RT.Modules;
  18. using Aitex.Core.RT.Fsm;
  19. using CyberX8_RT.Modules.PUF;
  20. using CyberX8_RT.Modules.Dummy;
  21. using MECF.Framework.Common.SubstrateTrackings;
  22. using MECF.Framework.Common.ToolLayout;
  23. using CyberX8_RT.Modules.Metal;
  24. using CyberX8_RT.Modules.Rinse;
  25. using MECF.Framework.RT.Core.Equipments;
  26. using MECF.Framework.Common.ProcessCell;
  27. using SecsGem.Core.ItemModel;
  28. using CyberX8_RT.Modules.Transporter;
  29. using CyberX8_Core;
  30. using Aitex.Core.RT.SCCore;
  31. using CyberX8_RT.Modules.Dryer;
  32. using CyberX8_RT.Modules.Prewet;
  33. using CyberX8_RT.Modules.SRD;
  34. using CyberX8_RT.Modules.Reservoir;
  35. using CyberX8_RT.Schedulers.Puf;
  36. using CyberX8_RT.Modules.Loader;
  37. using CyberX8_RT.Schedulers.Transporter;
  38. using CyberX8_RT.Schedulers.Loader;
  39. using CyberX8_RT.Devices.EFEM;
  40. namespace CyberX8_RT.Schedulers
  41. {
  42. public class SchedulerSequenceManager : Singleton<SchedulerSequenceManager>
  43. {
  44. #region 常量
  45. private const string ENGINEERING = "Engineering";
  46. private const string PRODUCTION = "Production";
  47. private const string TRNPA = "TRNPA";
  48. private const string TRNPB = "TRNPB";
  49. #endregion
  50. /// <summary>
  51. /// 解析Wafer所有调度工序
  52. /// </summary>
  53. /// <param name="sequenceRecipe"></param>
  54. /// <returns></returns>
  55. public List<SchedulerSequence> AnalyWaferAllSchedulerSequence(WaferInfo waferInfo,ModuleName pufModule,string side,WaferHolderInfo waferHolderInfo,SequenceRecipe sequenceRecipe)
  56. {
  57. waferInfo.LoaderSide = side;
  58. List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
  59. int index = 0;
  60. MoveItem moveItem = new MoveItem((ModuleName)waferInfo.OriginStation, waferInfo.OriginSlot, ModuleName.Aligner1, 0, Aitex.Sorter.Common.Hand.Blade1);
  61. SchedulerSequence efemRobotSequence = CreateEfemRobotSequence(moveItem,null,sequenceRecipe.SubstrateSize,ref index);
  62. schedulerSequences.Add(efemRobotSequence);
  63. SchedulerSequence alignerSequence=CreateAlignerSequence(sequenceRecipe,ref index);
  64. schedulerSequences.Add(alignerSequence);
  65. //从Aligner至Puf B面
  66. MoveItem moveItem2 = new MoveItem(ModuleName.Aligner1, 0, pufModule, 1, Aitex.Sorter.Common.Hand.Blade1);
  67. SchedulerSequence secondEfemRobotSequence = CreateEfemRobotSequence(moveItem2,null,sequenceRecipe.SubstrateSize, ref index);
  68. schedulerSequences.Add(secondEfemRobotSequence);
  69. SchedulerSequence pufSequence=CreatePufSequence(pufModule,sequenceRecipe,side,true,ref index);
  70. schedulerSequences.Add(pufSequence);
  71. ////Loader
  72. //SchedulerSequence loaderSequence = CreateLoaderSequence(ref index);
  73. //schedulerSequences.Add(loaderSequence);
  74. ////wafer holder装载后的recipe工序
  75. //List<SchedulerSequence> waferHolderAfterLoadedAllSequences = WaferHolderAfterLoadedAllSchedulerSequences(waferHolderInfo, sequenceRecipe, ref index);
  76. //schedulerSequences.AddRange(waferHolderAfterLoadedAllSequences);
  77. ////buffer模块至Loader
  78. //ModuleName bufferModule = ConvertToBufferModule(waferHolderInfo.BufferId);
  79. //WaferHolderMoveItem bufferToLoaderItem = new WaferHolderMoveItem(bufferModule,ModuleType.Buffer , ModuleName.Loader1, ModuleType.Loader);
  80. //SchedulerSequence bufferToLoaderSequence = CreateLoaderTransporterSequence(bufferToLoaderItem, ref index);
  81. //schedulerSequences.Add(bufferToLoaderSequence);
  82. ////Loader
  83. //SchedulerSequence backLoaderSequence = CreateLoaderSequence(ref index);
  84. //schedulerSequences.Add(backLoaderSequence);
  85. //puf模块
  86. SchedulerSequence backPufSequence = CreatePufSequence(pufModule,sequenceRecipe,"",false, ref index);
  87. schedulerSequences.Add(backPufSequence);
  88. //若经过srd
  89. if(SequenceRecipeManager.Instance.IsContainedSrd(sequenceRecipe))
  90. {
  91. SrdRecipe srdRecipe=SequenceRecipeManager.Instance.GetSrdRecipeBySequenceRecipe(sequenceRecipe);
  92. if(srdRecipe!=null)
  93. {
  94. MoveItem pufToSrdItem = new MoveItem();
  95. pufToSrdItem.SourceModule = pufModule;
  96. //A面
  97. pufToSrdItem.SourceSlot = 0;
  98. pufToSrdItem.DestinationType = ModuleType.SRD;
  99. pufToSrdItem.SourceSlot = 0;
  100. pufToSrdItem.DestinationModule = ModuleName.Unknown;
  101. pufToSrdItem.RobotHand = Aitex.Sorter.Common.Hand.Blade1;
  102. SchedulerSequence backEfemRobotSequence = CreateEfemRobotSequence(pufToSrdItem,null,sequenceRecipe.SubstrateSize, ref index);
  103. schedulerSequences.Add(backEfemRobotSequence);
  104. SchedulerSequence srdSequence = CreateSRDSequence(srdRecipe, ref index);
  105. schedulerSequences.Add(srdSequence);
  106. MoveItem srdToLoadPortItem = new MoveItem();
  107. srdToLoadPortItem.SourceModule = ModuleName.Unknown;
  108. srdToLoadPortItem.SourceType = ModuleType.SRD;
  109. srdToLoadPortItem.SourceSlot = 0;
  110. srdToLoadPortItem.DestinationType = ModuleType.LoadPort;
  111. srdToLoadPortItem.DestinationModule = (ModuleName)waferInfo.OriginStation;
  112. srdToLoadPortItem.DestinationSlot = waferInfo.OriginSlot;
  113. srdToLoadPortItem.RobotHand = Aitex.Sorter.Common.Hand.Blade1;
  114. SchedulerSequence srdToLoadPortSequence = CreateEfemRobotSequence(srdToLoadPortItem,null,sequenceRecipe.SubstrateSize, ref index);
  115. schedulerSequences.Add(srdToLoadPortSequence);
  116. }
  117. else
  118. {
  119. LOG.WriteLog(eEvent.ERR_SEQUENCE, "System", $"{sequenceRecipe.Ppid} srd recipe is invalid");
  120. return new List<SchedulerSequence>();
  121. }
  122. }
  123. else
  124. {
  125. MoveItem pufToLoadPortItem=new MoveItem(pufModule,0,(ModuleName)waferInfo.OriginStation,
  126. waferInfo.OriginSlot,Aitex.Sorter.Common.Hand.Blade1);
  127. SchedulerSequence pufToLoaderSequence=CreateEfemRobotSequence(pufToLoadPortItem,null,sequenceRecipe.SubstrateSize, ref index);
  128. schedulerSequences.Add(pufToLoaderSequence);
  129. }
  130. return schedulerSequences;
  131. }
  132. /// <summary>
  133. /// 解析WaferHolder的所有工序
  134. /// </summary>
  135. /// <param name="waferHolderInfo"></param>
  136. /// <param name="sequenceRecipe"></param>
  137. /// <returns></returns>
  138. public List<SchedulerSequence> AnalyWaferHolderAllSchedulerSequence(WaferHolderInfo waferHolderInfo, SequenceRecipe sequenceRecipe,int productWaferCount,int dummyWaferCount)
  139. {
  140. int totalWaferCount = productWaferCount + dummyWaferCount;
  141. int index = 0;
  142. List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
  143. //Buffer To Loader
  144. ModuleName currentLocationModuleName = (ModuleName)Enum.Parse(typeof(ModuleName), waferHolderInfo.CurrentLocation);
  145. TransporterAction transporterAction = GenerateTransporterTransferAction(currentLocationModuleName, ModuleType.Buffer, ModuleName.Loader1, ModuleType.Loader);
  146. string strTRNP = AnalyseLoadTransporterSide(sequenceRecipe, productWaferCount,dummyWaferCount);
  147. List<SchedulerSyncModuleMessage> synModules = GenerateLoaderTransporterSyncModuleMessage(strTRNP);
  148. SchedulerSequence bufferToLoaderSequence = CreateLoaderTransporterSequence(transporterAction,synModules,waferHolderInfo.WaferSize, ref index);
  149. schedulerSequences.Add(bufferToLoaderSequence);
  150. //尺寸不一致
  151. bool needFlip = CheckLoaderWaferSizeNotEqual() && totalWaferCount == 2;
  152. //Loader
  153. LoaderParameter parameter = new LoaderParameter();
  154. parameter.WaferCount= needFlip?1: totalWaferCount;
  155. parameter.LoadCompleteToTransporterSide = strTRNP;
  156. parameter.NeedWaitFlip = needFlip;
  157. SchedulerSequence loaderSequence = CreateLoaderSequence(parameter,sequenceRecipe.SubstrateSize, ref index);
  158. schedulerSequences.Add(loaderSequence);
  159. if (needFlip)
  160. {
  161. string reverse = GetReverseTransporterLocation(strTRNP);
  162. TransporterAction flipAction = GenerateTransporterFlipAction(reverse);
  163. SchedulerSequence flipSequence=CreateLoaderTransporterSequence(flipAction,null,sequenceRecipe.SubstrateSize, ref index);
  164. schedulerSequences.Add(flipSequence);
  165. //Loader
  166. LoaderParameter reverseParameter = new LoaderParameter();
  167. reverseParameter.WaferCount = 1;
  168. reverseParameter.LoadCompleteToTransporterSide = reverse;
  169. reverseParameter.NeedWaitFlip = false;
  170. SchedulerSequence reverseLoadSequence = CreateLoaderSequence(reverseParameter,sequenceRecipe.SubstrateSize, ref index);
  171. schedulerSequences.Add(reverseLoadSequence);
  172. }
  173. //wafer holder装载后的recipe工序
  174. List<SchedulerSequence> waferHolderAfterLoadedAllSequences = WaferHolderAfterLoadedAllSchedulerSequences(waferHolderInfo, sequenceRecipe,ref index);
  175. schedulerSequences.AddRange(waferHolderAfterLoadedAllSequences);
  176. return schedulerSequences;
  177. }
  178. /// <summary>
  179. /// 解析LoaderTransporter放至Loader第一次确定TRNP的方向
  180. /// </summary>
  181. /// <param name="sequenceRecipe"></param>
  182. /// <param name="waferCount"></param>
  183. /// <returns></returns>
  184. private string AnalyseLoadTransporterSide(SequenceRecipe sequenceRecipe,int productWaferCount,int dummyWaferCount)
  185. {
  186. LoaderEntity loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
  187. //单片,同时loader两边尺寸不一致
  188. if ((productWaferCount == 1||dummyWaferCount==1) && loaderEntity.SideAWaferSize != loaderEntity.SideBWaferSize)
  189. {
  190. //recipe使用B面工艺,但loader A面与recipe尺寸一致
  191. if (sequenceRecipe.LastSingleWaferToSideB && sequenceRecipe.SubstrateSize == loaderEntity.SideAWaferSize)
  192. {
  193. return "TRNPB";
  194. }
  195. //recipe使用A面工艺,但loader B面与recipe尺寸一致
  196. else if (!sequenceRecipe.LastSingleWaferToSideB && sequenceRecipe.SubstrateSize == loaderEntity.SideBWaferSize)
  197. {
  198. return "TRNPB";
  199. }
  200. }
  201. return "TRNPA";
  202. }
  203. private string GetReverseTransporterLocation(string strTrn)
  204. {
  205. return strTrn == TRNPA ? TRNPB : TRNPA;
  206. }
  207. /// <summary>
  208. /// 创建Transporter transfer指令
  209. /// </summary>
  210. /// <param name="source"></param>
  211. /// <param name="sourceType"></param>
  212. /// <param name="dest"></param>
  213. /// <param name="destType"></param>
  214. /// <returns></returns>
  215. private TransporterAction GenerateTransporterTransferAction(ModuleName source,ModuleType sourceType,ModuleName dest,ModuleType destType)
  216. {
  217. TransporterAction transporterAction = new TransporterAction();
  218. transporterAction.ActionMsg = TransporterMSG.Transfer;
  219. WaferHolderMoveItem waferHolderMoveItem = new WaferHolderMoveItem(source, sourceType, dest, destType);
  220. transporterAction.Parameter = waferHolderMoveItem;
  221. return transporterAction;
  222. }
  223. /// <summary>
  224. /// 创建Transporter pickup指令
  225. /// </summary>
  226. /// <param name="source"></param>
  227. /// <param name="sourceType"></param>
  228. /// <param name="dest"></param>
  229. /// <param name="destType"></param>
  230. /// <returns></returns>
  231. private TransporterAction GenerateTransporterFlipAction(string strTransporter)
  232. {
  233. TransporterAction transporterAction = new TransporterAction();
  234. transporterAction.ActionMsg = TransporterMSG.Flip;
  235. transporterAction.Parameter = strTransporter;
  236. return transporterAction;
  237. }
  238. /// <summary>
  239. /// 检验Loader两边waferSize不一致
  240. /// </summary>
  241. /// <returns></returns>
  242. private bool CheckLoaderWaferSizeNotEqual()
  243. {
  244. LoaderEntity loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
  245. return loaderEntity.SideAWaferSize != loaderEntity.SideBWaferSize;
  246. }
  247. /// <summary>
  248. /// 创建LoaderTrasporter同步模块消息
  249. /// </summary>
  250. /// <param name="tranporter"></param>
  251. /// <returns></returns>
  252. private List<SchedulerSyncModuleMessage> GenerateLoaderTransporterSyncModuleMessage(string tranporter)
  253. {
  254. List<SchedulerSyncModuleMessage> synModules = new List<SchedulerSyncModuleMessage>();
  255. SchedulerSyncModuleMessage syncModuleMessage = new SchedulerSyncModuleMessage();
  256. syncModuleMessage.ModuleEntity = Singleton<RouteManager>.Instance.GetModule<IModuleEntity>(ModuleName.Loader1.ToString());
  257. syncModuleMessage.ModuleMsg = LoaderMSG.PrepareForPlace.ToString();
  258. syncModuleMessage.parameters = new object[] { tranporter };
  259. synModules.Add(syncModuleMessage);
  260. return synModules;
  261. }
  262. /// <summary>
  263. /// Dummy Wafer对应WaferHolder任务
  264. /// </summary>
  265. /// <param name="waferHolderInfo"></param>
  266. /// <returns></returns>
  267. public List<SchedulerSequence> AnalyseDummyWaferHolderAllSchedulerSequence(WaferHolderInfo waferHolderInfo,int productWaferCount,int dummyWaferCount)
  268. {
  269. int index = 0;
  270. List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
  271. string strTRNP = AnalyseLoadTransporterSide(waferHolderInfo.SequenceRecipe, productWaferCount,dummyWaferCount);
  272. //Buffer To Loader
  273. ModuleName currentLocationModuleName = (ModuleName)Enum.Parse(typeof(ModuleName), waferHolderInfo.CurrentLocation);
  274. ModuleName bufferModule = (ModuleName)Enum.Parse(typeof(ModuleName), waferHolderInfo.OriginalBuffer);
  275. List<SchedulerSyncModuleMessage> synModules = GenerateLoaderTransporterSyncModuleMessage(strTRNP);
  276. TransporterAction transporterAction = GenerateTransporterTransferAction(currentLocationModuleName, ModuleType.Buffer, ModuleName.Loader1, ModuleType.Loader);
  277. SchedulerSequence bufferToLoaderSequence = CreateLoaderTransporterSequence(transporterAction,synModules,waferHolderInfo.WaferSize, ref index);
  278. schedulerSequences.Add(bufferToLoaderSequence);
  279. //尺寸不一致
  280. bool needFlip = CheckLoaderWaferSizeNotEqual() && dummyWaferCount == 2;
  281. //Loader
  282. LoaderParameter parameter = new LoaderParameter();
  283. parameter.WaferCount = needFlip ? 1 : dummyWaferCount; ;
  284. parameter.LoadCompleteToTransporterSide = strTRNP;
  285. parameter.NeedWaitFlip = needFlip;
  286. SchedulerSequence loaderSequence = CreateLoaderSequence(parameter,waferHolderInfo.WaferSize,ref index);
  287. schedulerSequences.Add(loaderSequence);
  288. if (needFlip)
  289. {
  290. string reverse = GetReverseTransporterLocation(strTRNP);
  291. TransporterAction flipAction = GenerateTransporterFlipAction(reverse);
  292. SchedulerSequence flipSequence = CreateLoaderTransporterSequence(flipAction, null,waferHolderInfo.WaferSize, ref index);
  293. schedulerSequences.Add(flipSequence);
  294. //Loader
  295. LoaderParameter reverseParameter = new LoaderParameter();
  296. reverseParameter.WaferCount = 1;
  297. reverseParameter.LoadCompleteToTransporterSide = reverse;
  298. reverseParameter.NeedWaitFlip = false;
  299. SchedulerSequence reverseLoadSequence = CreateLoaderSequence(reverseParameter,waferHolderInfo.WaferSize, ref index);
  300. schedulerSequences.Add(reverseLoadSequence);
  301. }
  302. //Loader To Buffer
  303. TransporterAction loaderMoveToBufferAction=GenerateTransporterTransferAction (ModuleName.Loader1, ModuleType.Loader,
  304. bufferModule, ModuleType.Buffer);
  305. SchedulerSequence loaderToBufferSequence = CreateLoaderTransporterSequence(loaderMoveToBufferAction,null,waferHolderInfo.WaferSize, ref index);
  306. schedulerSequences.Add(loaderToBufferSequence);
  307. return schedulerSequences;
  308. }
  309. /// <summary>
  310. /// 解析Dummy Wafer所有调度工序
  311. /// </summary>
  312. /// <param name="sequenceRecipe"></param>
  313. /// <returns></returns>
  314. public List<SchedulerSequence> AnalyDummyWaferAllSchedulerSequence(SequenceRecipe sequenceRecipe,WaferInfo waferInfo, ModuleName pufModule,string side)
  315. {
  316. waferInfo.LoaderSide = side;
  317. List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
  318. int index = 0;
  319. //DummyCassete至Aligner
  320. MoveItem moveItem = new MoveItem((ModuleName)waferInfo.Station, waferInfo.Slot, ModuleName.Aligner1, 0, Aitex.Sorter.Common.Hand.Blade1);
  321. SchedulerSequence secondEfemRobotSequence = CreateEfemRobotSequence(moveItem, null,sequenceRecipe.SubstrateSize, ref index);
  322. schedulerSequences.Add(secondEfemRobotSequence);
  323. //Aligner
  324. SchedulerSequence alignerSequence=CreateAlignerSequence(sequenceRecipe, ref index);
  325. schedulerSequences.Add(alignerSequence);
  326. //Aligner至Puf
  327. MoveItem alignerToPufMoveItem = new MoveItem(ModuleName.Aligner1, 0, pufModule, 1, Aitex.Sorter.Common.Hand.Blade1);
  328. SchedulerSequence alignerToPufEfemRobotSequence = CreateEfemRobotSequence(alignerToPufMoveItem, null,sequenceRecipe.SubstrateSize, ref index);
  329. schedulerSequences.Add(alignerToPufEfemRobotSequence);
  330. SchedulerSequence pufSequence = CreatePufSequence(pufModule,sequenceRecipe, side,true, ref index);
  331. schedulerSequences.Add(pufSequence);
  332. return schedulerSequences;
  333. }
  334. /// <summary>
  335. /// Loader装载后Recipe工序
  336. /// </summary>
  337. /// <param name="waferHolderInfo"></param>
  338. /// <param name="sequenceRecipe"></param>
  339. /// <param name="index"></param>
  340. /// <returns></returns>
  341. private List<SchedulerSequence> WaferHolderAfterLoadedAllSchedulerSequences(WaferHolderInfo waferHolderInfo,SequenceRecipe sequenceRecipe,ref int index)
  342. {
  343. List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
  344. if(!Enum.TryParse(waferHolderInfo.OriginalBuffer,out ModuleName moduleName))
  345. {
  346. return schedulerSequences;
  347. }
  348. //Loader To Buffer
  349. TransporterAction loaderMoveToBufferAction = GenerateTransporterTransferAction(ModuleName.Loader1, ModuleType.Loader,
  350. moduleName, ModuleType.Buffer);
  351. SchedulerSequence loaderToBufferSequence = CreateLoaderTransporterSequence(loaderMoveToBufferAction,null,sequenceRecipe.SubstrateSize, ref index);
  352. schedulerSequences.Add(loaderToBufferSequence);
  353. //解析sequence recipe后续的工序
  354. var result = AnalyseSequenceRecipeScheduler(sequenceRecipe);
  355. //buffer to recipe第一个工序
  356. TransporterAction bufferToFirstAction = GenerateTransporterTransferAction(moduleName, ModuleType.Buffer, ModuleName.Unknown, result.firstModuleType);
  357. SchedulerSequence bufferSequence = CreateLoaderTransporterSequence(bufferToFirstAction,null,sequenceRecipe.SubstrateSize, ref index);
  358. schedulerSequences.Add(bufferSequence);
  359. //调整工序后面的索引
  360. foreach (SchedulerSequence item in result.sequences)
  361. {
  362. item.SequenceIndex = index;
  363. index++;
  364. }
  365. schedulerSequences.AddRange(result.sequences);
  366. //从recipe最后工序
  367. TransporterAction lastToBufferAction = GenerateTransporterTransferAction(ModuleName.Unknown, result.lastModuleType, moduleName, ModuleType.Buffer);
  368. SchedulerSequence lastToBufferSequence = CreateLoaderTransporterSequence(lastToBufferAction,null,sequenceRecipe.SubstrateSize, ref index);
  369. schedulerSequences.Add(lastToBufferSequence);
  370. return schedulerSequences;
  371. }
  372. /// <summary>
  373. /// 分析Sequence recipe对应的调度步骤
  374. /// </summary>
  375. /// <param name="sequenceRecipe"></param>
  376. /// <returns></returns>
  377. private (ModuleType firstModuleType,List<SchedulerSequence> sequences,ModuleType lastModuleType) AnalyseSequenceRecipeScheduler(SequenceRecipe sequenceRecipe)
  378. {
  379. ModuleType firstModuleType = default;
  380. ModuleType lastModuleType = default;
  381. List<SchedulerSequence> schedulerSequences= new List<SchedulerSequence>();
  382. List<SchedulerSequence> tmpLst = new List<SchedulerSequence>();
  383. var processResult = AnalyseLastProcessRecipeIndex(sequenceRecipe.Recipes);
  384. bool isExistSrd = sequenceRecipe.Recipes.FindIndex(O=>O.ToLower().EndsWith("srd.rcp"))!=-1;
  385. int lastIndex = isExistSrd ? sequenceRecipe.Recipes.Count - 2 : sequenceRecipe.Recipes.Count - 1;
  386. for(int i=0;i<sequenceRecipe.Recipes.Count;i++)
  387. {
  388. string item = sequenceRecipe.Recipes[i];
  389. if(item.ToLower().EndsWith("srd.rcp"))//跳过SRD
  390. {
  391. continue;
  392. }
  393. SchedulerSequence schedulerSequence = new SchedulerSequence();
  394. schedulerSequence.ModuleName = ModuleName.Unknown;
  395. schedulerSequence.ModuleType=SequenceRecipeManager.Instance.GetModuleType(item);
  396. schedulerSequence.SequenceIndex=i;
  397. schedulerSequence.WaferSize = sequenceRecipe.SubstrateSize;
  398. MECF.Framework.Common.RecipeCenter.RecipeType recipeType =SequenceRecipeManager.Instance.GetRecipeType(item);
  399. schedulerSequence.Recipe = SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType,item, recipeType);
  400. schedulerSequence.SequenceType = sequenceRecipe.SequenceType;
  401. schedulerSequence.State = RState.Init;
  402. schedulerSequence.MaterialType = MaterialType.WaferHolder;
  403. tmpLst.Add(schedulerSequence);
  404. if (i == 0)
  405. {
  406. firstModuleType = schedulerSequence.ModuleType;
  407. }
  408. if(i==lastIndex)
  409. {
  410. lastModuleType = schedulerSequence.ModuleType;
  411. }
  412. else
  413. {
  414. string nextModule = sequenceRecipe.Recipes[i + 1];
  415. schedulerSequence.NextModuleType= SequenceRecipeManager.Instance.GetModuleType(nextModule);
  416. MECF.Framework.Common.RecipeCenter.RecipeType nextRecipeType = SequenceRecipeManager.Instance.GetRecipeType(nextModule);
  417. schedulerSequence.NextRecipe= SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType,nextModule,nextRecipeType);
  418. }
  419. schedulerSequence.IsProcessSequece = true;
  420. if(i==processResult.lastIndex)
  421. {
  422. schedulerSequence.IsLastProcessSequence = true;
  423. }
  424. }
  425. int index = 0;
  426. for(int i=0;i<tmpLst.Count;i++)
  427. {
  428. tmpLst[i].SequenceIndex = 0;
  429. schedulerSequences.Add(tmpLst[i]);
  430. index++;
  431. if(i<tmpLst.Count-1)
  432. {
  433. TransporterAction transporterAction = new TransporterAction();
  434. transporterAction.ActionMsg = TransporterMSG.Transfer;
  435. WaferHolderMoveItem moveItem = new WaferHolderMoveItem(ModuleName.Unknown, tmpLst[i].ModuleType, ModuleName.Unknown, tmpLst[i + 1].ModuleType);
  436. transporterAction.Parameter = moveItem;
  437. SchedulerSequence schedulerSequence=CreateProcessTransporterSequence(transporterAction,sequenceRecipe.SubstrateSize,ref index);
  438. schedulerSequences.Add(schedulerSequence);
  439. }
  440. }
  441. return (firstModuleType,schedulerSequences,lastModuleType);
  442. }
  443. /// <summary>
  444. /// 分析最后加工recipe索引
  445. /// </summary>
  446. /// <param name="recipes"></param>
  447. /// <returns></returns>
  448. private (int lastIndex,List<int> processIndexList) AnalyseLastProcessRecipeIndex(List<string> recipes)
  449. {
  450. int index = 0;
  451. List<int> lst = new List<int>();
  452. for(int i=0;i<recipes.Count; i++)
  453. {
  454. string item=recipes[i];
  455. if(item.ToLower().EndsWith("dep.rcp"))
  456. {
  457. index = i;
  458. if(lst.Contains(i))
  459. {
  460. lst.Add(i);
  461. }
  462. }
  463. }
  464. if(lst.Count==0)
  465. {
  466. lst.Add(0);
  467. }
  468. return (index,lst);
  469. }
  470. /// <summary>
  471. /// 创建EFEM Robot步骤
  472. /// </summary>
  473. /// <param name="index"></param>
  474. /// <returns></returns>
  475. private SchedulerSequence CreateEfemRobotSequence(MoveItem moveItem,List<SchedulerSyncModuleMessage> synModules,int waferSize,ref int index)
  476. {
  477. SchedulerSequence sequence = new SchedulerSequence();
  478. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.EfemRobot);
  479. sequence.SequenceIndex= index;
  480. sequence.ModuleName=ModuleName.EfemRobot;
  481. sequence.State = RState.Init;
  482. sequence.Recipe = null;
  483. sequence.ModuleType=ModuleType.EfemRobot;
  484. sequence.Parameters =moveItem;
  485. sequence.MaterialType = MaterialType.Wafer;
  486. sequence.SynchronousModuleMessages = synModules;
  487. sequence.WaferSize = waferSize;
  488. index++;
  489. return sequence;
  490. }
  491. /// <summary>
  492. /// 创建Aligner步骤
  493. /// </summary>
  494. /// <param name="index"></param>
  495. /// <returns></returns>
  496. private SchedulerSequence CreateAlignerSequence(SequenceRecipe recipe,ref int index)
  497. {
  498. SchedulerSequence sequence = new SchedulerSequence();
  499. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Aligner1);
  500. sequence.SequenceIndex = index;
  501. sequence.ModuleName = ModuleName.Aligner1;
  502. sequence.State = RState.Init;
  503. sequence.Recipe = recipe;
  504. sequence.ModuleType = ModuleType.Aligner;
  505. sequence.Parameters = null;
  506. sequence.MaterialType = MaterialType.Wafer;
  507. sequence.WaferSize = sequence.WaferSize;
  508. index++;
  509. return sequence;
  510. }
  511. /// <summary>
  512. /// 创建PUF步骤
  513. /// </summary>
  514. /// <param name="pufModuleName"></param>
  515. /// <param name="index"></param>
  516. /// <returns></returns>
  517. private SchedulerSequence CreatePufSequence(ModuleName pufModuleName,SequenceRecipe sequenceRecipe,string side,bool forward,ref int index)
  518. {
  519. SchedulerSequence sequence = new SchedulerSequence();
  520. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(pufModuleName);
  521. sequence.SequenceIndex = index;
  522. sequence.ModuleName = pufModuleName;
  523. sequence.State = RState.Init;
  524. sequence.Recipe = sequenceRecipe;
  525. PufSchedulerParameter parameter = new PufSchedulerParameter()
  526. {
  527. IsForward = forward,
  528. Side = side,
  529. };
  530. sequence.Parameters = parameter;
  531. sequence.IsWaitNotify = !forward;
  532. sequence.ModuleType = ModuleType.PUF;
  533. sequence.MaterialType = MaterialType.Wafer;
  534. sequence.WaferSize = sequenceRecipe.SubstrateSize;
  535. index++;
  536. return sequence;
  537. }
  538. /// <summary>
  539. /// 创建Loader步骤
  540. /// </summary>
  541. /// <param name="index"></param>
  542. /// <returns></returns>
  543. private SchedulerSequence CreateLoaderSequence(LoaderParameter parameter,int waferSize,ref int index)
  544. {
  545. SchedulerSequence sequence = new SchedulerSequence();
  546. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Loader1);
  547. sequence.SequenceIndex = index;
  548. sequence.ModuleName = ModuleName.Loader1;
  549. sequence.State = RState.Init;
  550. sequence.Recipe = null;
  551. sequence.Parameters = parameter;
  552. sequence.ModuleType = ModuleType.Loader;
  553. sequence.MaterialType = MaterialType.WaferHolder;
  554. sequence.WaferSize = waferSize;
  555. index++;
  556. return sequence;
  557. }
  558. /// <summary>
  559. /// 创建Loader步骤
  560. /// </summary>
  561. /// <param name="index"></param>
  562. /// <returns></returns>
  563. private SchedulerSequence CreateSRDSequence(SrdRecipe recipe,ref int index)
  564. {
  565. SchedulerSequence sequence = new SchedulerSequence();
  566. sequence.SequenceIndex = index;
  567. sequence.State = RState.Init;
  568. sequence.Recipe = recipe;
  569. sequence.ModuleType = ModuleType.SRD;
  570. sequence.MaterialType = MaterialType.Wafer;
  571. index++;
  572. return sequence;
  573. }
  574. /// <summary>
  575. /// 创建LoaderTransporter步骤
  576. /// </summary>
  577. /// <param name="index"></param>
  578. /// <returns></returns>
  579. private SchedulerSequence CreateLoaderTransporterSequence(TransporterAction transporterAction, List<SchedulerSyncModuleMessage> synModules,int waferSize, ref int index)
  580. {
  581. SchedulerSequence sequence = new SchedulerSequence();
  582. sequence.ModuleType = ModuleType.Transporter;
  583. sequence.ModuleName = ModuleName.Transporter2;
  584. sequence.SequenceIndex = index;
  585. sequence.State = RState.Init;
  586. sequence.Recipe = null;
  587. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Transporter2);
  588. sequence.Parameters = transporterAction;
  589. sequence.MaterialType = MaterialType.WaferHolder;
  590. sequence.SynchronousModuleMessages = synModules;
  591. sequence.WaferSize = waferSize;
  592. index++;
  593. return sequence;
  594. }
  595. /// <summary>
  596. /// 创建LoaderTransporter步骤
  597. /// </summary>
  598. /// <param name="index"></param>
  599. /// <returns></returns>
  600. private SchedulerSequence CreateProcessTransporterSequence(TransporterAction transporterAction,int waferSize, ref int index)
  601. {
  602. SchedulerSequence sequence = new SchedulerSequence();
  603. sequence.ModuleType = ModuleType.Transporter;
  604. sequence.ModuleName = ModuleName.Transporter1;
  605. sequence.SequenceIndex = index;
  606. sequence.State = RState.Init;
  607. sequence.Recipe = null;
  608. sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Transporter1);
  609. sequence.Parameters= transporterAction;
  610. sequence.MaterialType = MaterialType.WaferHolder;
  611. sequence.WaferSize = waferSize;
  612. index++;
  613. return sequence;
  614. }
  615. /// <summary>
  616. /// 获取可用Dummy slot
  617. /// </summary>
  618. /// <param name="moduleType"></param>
  619. /// <returns></returns>
  620. public (ModuleName moduleName, int slot) GetAvaibleDummySlots(WaferSize waferSize)
  621. {
  622. if (ModuleHelper.IsInstalled(ModuleName.Dummy1))
  623. {
  624. DummyEntity dummyEntity = Singleton<RouteManager>.Instance.GetModule<DummyEntity>(ModuleName.Dummy1.ToString());
  625. DummyDevice dummyDevice = Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(0);
  626. if (dummyDevice != null && dummyDevice.HasCassette && dummyDevice.WaferSize == waferSize)
  627. {
  628. for (int i = 0; i < dummyEntity.MaxSlotNumber; i++)
  629. {
  630. if (WaferManager.Instance.CheckNoWafer(ModuleName.Dummy1, i))
  631. {
  632. return (ModuleName.Dummy1, i);
  633. }
  634. }
  635. }
  636. }
  637. if (ModuleHelper.IsInstalled(ModuleName.Dummy2))
  638. {
  639. DummyEntity dummyEntity = Singleton<RouteManager>.Instance.GetModule<DummyEntity>(ModuleName.Dummy2.ToString());
  640. DummyDevice dummyDevice = Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(1);
  641. if (dummyDevice != null && dummyDevice.HasCassette && dummyDevice.WaferSize == waferSize)
  642. {
  643. for (int i = 0; i < dummyEntity.MaxSlotNumber; i++)
  644. {
  645. if (WaferManager.Instance.CheckNoWafer(ModuleName.Dummy2, i))
  646. {
  647. return (ModuleName.Dummy2, i);
  648. }
  649. }
  650. }
  651. }
  652. return (ModuleName.Unknown, -1);
  653. }
  654. /// <summary>
  655. /// 根据模块类型获取可用模块
  656. /// </summary>
  657. /// <param name="moduleType"></param>
  658. /// <returns></returns>
  659. public ModuleName GetAvaibleModuleCell(string sequenceType,ModuleType moduleType, ModuleName moduleName = ModuleName.Unknown)
  660. {
  661. if (ModuleHelper.IsMetal(moduleName))
  662. {
  663. List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
  664. return GetMetalAvaibleRinseModule(entities, moduleName);
  665. }
  666. else
  667. {
  668. List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
  669. List<IModuleEntity> avaibles = new List<IModuleEntity>();
  670. foreach (var item in entities)
  671. {
  672. bool result = CheckAvaibleModule(item,moduleType,sequenceType);
  673. if (result)
  674. {
  675. avaibles.Add(item);
  676. }
  677. }
  678. return GetMinTimeToReadyModule(avaibles,moduleType);
  679. }
  680. }
  681. /// <summary>
  682. /// 根据模块类型获取可用模块(不包含WH)
  683. /// </summary>
  684. /// <param name="moduleType"></param>
  685. /// <returns></returns>
  686. public ModuleName GetAvaibleEmptyModuleCell(ModuleType moduleType,string sequenceType, ModuleName moduleName = ModuleName.Unknown)
  687. {
  688. if (ModuleHelper.IsMetal(moduleName))
  689. {
  690. List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
  691. return GetMetalAvaibleEmptyRinseModule(entities, moduleName);
  692. }
  693. else
  694. {
  695. List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
  696. List<IModuleEntity> avaibles = new List<IModuleEntity>();
  697. foreach (var item in entities)
  698. {
  699. bool result = CheckAvaibleModule(item,moduleType,sequenceType);
  700. if (result&&!WaferHolderManager.Instance.HasWaferHolder(item.Module.ToString()))
  701. {
  702. avaibles.Add(item);
  703. }
  704. }
  705. return avaibles.Count != 0 ? avaibles[0].Module : ModuleName.Unknown;
  706. }
  707. }
  708. /// <summary>
  709. /// 根据化学液计算时间获取可用MetalCell(参考其他Metal剩余时间)
  710. /// </summary>
  711. /// <param name="chemistry"></param>
  712. /// <returns></returns>
  713. public ModuleName CalculateAvaibleMetalCellByChemistry(string chemistry,string startRinse,string sequenceType,int waferSize,ref bool isExistEnableMetal)
  714. {
  715. if(!Enum.TryParse(startRinse,out ModuleName startRinseModule)||!ModuleHelper.IsRinse(startRinseModule))
  716. {
  717. startRinse = "";
  718. }
  719. isExistEnableMetal = false;
  720. List<MetalEntity> moduleEntities = GetAvaibleMetalList(chemistry,sequenceType,waferSize,true);
  721. List<IModuleEntity> avaibleMetalEntities = new List<IModuleEntity>();
  722. foreach (var item in moduleEntities)
  723. {
  724. if(CheckAvaibleModule(item,ModuleType.Metal,sequenceType))
  725. {
  726. if (item.WaferHolderInfo == null)
  727. {
  728. if (CheckMetalModuleRinseAvaible(item, startRinse))
  729. {
  730. avaibleMetalEntities.Add(item);
  731. }
  732. }
  733. isExistEnableMetal = true;
  734. }
  735. }
  736. if (avaibleMetalEntities.Count > 0)
  737. {
  738. return GetMinUsageMetal(avaibleMetalEntities);
  739. }
  740. return ModuleName.Unknown;
  741. }
  742. /// <summary>
  743. /// 根据化学液获取可用Metal
  744. /// </summary>
  745. /// <param name="chemistry"></param>
  746. /// <param name="sequenceType"></param>
  747. /// <returns></returns>
  748. public bool CalculateAvaibleMetalCellByChemistry(string chemistry,string sequenceType,int waferSize)
  749. {
  750. List<MetalEntity> moduleEntities = GetAvaibleMetalList(chemistry, sequenceType,waferSize,false);
  751. return moduleEntities.Count != 0;
  752. }
  753. /// <summary>
  754. /// 检验Metal模块Rinse可用性
  755. /// </summary>
  756. /// <param name="item"></param>
  757. /// <returns></returns>
  758. private bool CheckMetalModuleRinseAvaible(MetalEntity item,string startRinse)
  759. {
  760. List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByMetal(item.Module.ToString());
  761. List<string> sharedRinseItems = new List<string>();
  762. List<string> singleRinseItems = new List<string>();
  763. foreach (var cellItem in rinseItems)
  764. {
  765. RinseEntity rinseEntity = Singleton<RouteManager>.Instance.GetModule<RinseEntity>(cellItem.ModuleName);
  766. if (!CellItemManager.Instance.CheckRinseIsShared(cellItem.ModuleName))
  767. {
  768. if (CheckAvaibleModule(rinseEntity, ModuleType.Rinse, "") && rinseEntity.WaferHolderInfo == null)
  769. {
  770. singleRinseItems.Add(cellItem.ModuleName);
  771. }
  772. }
  773. else
  774. {
  775. if (CheckAvaibleModule(rinseEntity,ModuleType.Rinse,"") && rinseEntity.WaferHolderInfo == null)
  776. {
  777. sharedRinseItems.Add(cellItem.ModuleName);
  778. }
  779. //增加自己
  780. if (cellItem.ModuleName == startRinse && rinseEntity != null && (rinseEntity.IsIdle||rinseEntity.State==(int)RinseState.KeepWeting))
  781. {
  782. sharedRinseItems.Add(startRinse);
  783. }
  784. }
  785. }
  786. //独立的Rinse集合
  787. if(singleRinseItems.Count!=0)
  788. {
  789. bool result = CheckSingleRinseItemsCanUsed(singleRinseItems, item.Module.ToString());
  790. if(result)
  791. {
  792. return true;
  793. }
  794. }
  795. //仅剩下共享Rinse
  796. List<string> avaibleSharedList = new List<string>();
  797. if (sharedRinseItems.Count != 0)
  798. {
  799. foreach (string sharedRinse in sharedRinseItems)
  800. {
  801. RinseEntity rinseEntity = Singleton<RouteManager>.Instance.GetModule<RinseEntity>(sharedRinse);
  802. if (rinseEntity.IsBusy&&sharedRinse!=startRinse)
  803. {
  804. continue;
  805. }
  806. //检验共享Rinse是否可用
  807. if (CheckShardRinseCanUse(sharedRinse, item.Module.ToString(),startRinse))
  808. {
  809. avaibleSharedList.Add(sharedRinse);
  810. }
  811. }
  812. }
  813. if (avaibleSharedList.Count != 0)
  814. {
  815. var result = CalculateMetalReservoirAllBusyMetalCount(item.Module.ToString());
  816. if (result.success)
  817. {
  818. bool transporterTransfering = CheckProcessTransporterTransfering(avaibleSharedList);
  819. if(transporterTransfering)
  820. {
  821. return result.busyCount + 1 < avaibleSharedList.Count;
  822. }
  823. else
  824. {
  825. return result.busyCount < avaibleSharedList.Count+singleRinseItems.Count;
  826. }
  827. }
  828. }
  829. return false;
  830. }
  831. /// <summary>
  832. /// 检验Process transporter正在Transfer WH移动至Rinse
  833. /// </summary>
  834. /// <returns></returns>
  835. private bool CheckProcessTransporterTransfering(List<string> rinseList)
  836. {
  837. TransporterEntity processTransporterEntity = Singleton<RouteManager>.Instance.GetModule<TransporterEntity>(ModuleName.Transporter1.ToString());
  838. if(processTransporterEntity!=null)
  839. {
  840. if (processTransporterEntity.IsBusy)
  841. {
  842. string targetCell = processTransporterEntity.TargetCell;
  843. if (rinseList.Contains(targetCell))
  844. {
  845. return true;
  846. }
  847. }
  848. }
  849. return false;
  850. }
  851. /// <summary>
  852. /// 计算Metal所在Reservoir Busy Metal数量
  853. /// </summary>
  854. /// <param name="item"></param>
  855. /// <returns></returns>
  856. private (bool success,int busyCount) CalculateMetalReservoirAllBusyMetalCount(string metalName)
  857. {
  858. string reservoirName = ReservoirItemManager.Instance.GetReservoirByMetal(metalName);
  859. if (string.IsNullOrEmpty(reservoirName))
  860. {
  861. return (false,0);
  862. }
  863. List<string> metals = ReservoirItemManager.Instance.GetMetalsByReservoir(reservoirName);
  864. int count = 0;
  865. foreach (string item in metals)
  866. {
  867. if (metalName == item)
  868. {
  869. continue;
  870. }
  871. MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(item);
  872. if (metalEntity.IsBusy || metalEntity.WaferHolderInfo != null)
  873. {
  874. count++;
  875. }
  876. }
  877. return (true,count);
  878. }
  879. /// <summary>
  880. /// 检验独立Rinse是否可用
  881. /// </summary>
  882. /// <param name="singleRinseItems"></param>
  883. /// <param name="metalName"></param>
  884. /// <returns></returns>
  885. private bool CheckSingleRinseItemsCanUsed(List<string> singleRinseItems, string metalName)
  886. {
  887. var result = CalculateMetalReservoirAllBusyMetalCount(metalName);
  888. if(result.success)
  889. {
  890. bool transporterTransfering = CheckProcessTransporterTransfering(singleRinseItems);
  891. if (transporterTransfering)
  892. {
  893. return result.busyCount + 1 < singleRinseItems.Count;
  894. }
  895. else
  896. {
  897. return result.busyCount < singleRinseItems.Count;
  898. }
  899. }
  900. return false;
  901. }
  902. /// <summary>
  903. /// 检验共享Rinse是否可用
  904. /// </summary>
  905. /// <param name="sharedRinse"></param>
  906. /// <param name="metalName"></param>
  907. /// <returns></returns>
  908. private bool CheckShardRinseCanUse(string sharedRinse, string metalName,string startRinse)
  909. {
  910. string reservoirName = ReservoirItemManager.Instance.GetReservoirByMetal(metalName);
  911. List<string> shardReservoirs = CellItemManager.Instance.GetReservoirsBySharedRinse(sharedRinse);
  912. if (shardReservoirs == null || shardReservoirs.Count == 0)
  913. {
  914. return false;
  915. }
  916. foreach (string reservoir in shardReservoirs)
  917. {
  918. if (reservoir==reservoirName)
  919. {
  920. continue;
  921. }
  922. List<string> metals=ReservoirItemManager.Instance.GetMetalsByReservoir(reservoir);
  923. int metalCount = 0;
  924. int busyMetalCount = 0;
  925. foreach(string metal in metals)
  926. {
  927. MetalEntity metalEntity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>(metal);
  928. if(metalEntity.IsAuto&&metalEntity.IsInitialized)
  929. {
  930. metalCount++;
  931. }
  932. if(metalEntity.IsBusy||metalEntity.WaferHolderInfo!=null)
  933. {
  934. busyMetalCount++;
  935. }
  936. }
  937. List<string> reservoirRinseLst = CellItemManager.Instance.GetRinsesByReservoir(reservoir);
  938. int rinseCount = 0;
  939. int busyRinseCount = 0;
  940. foreach(string rinseItem in reservoirRinseLst)
  941. {
  942. RinseEntity rinseEntity = Singleton<RouteManager>.Instance.GetModule<RinseEntity>(rinseItem);
  943. if(rinseEntity.IsAuto&&rinseEntity.IsInitialized)
  944. {
  945. rinseCount++;
  946. }
  947. if (rinseItem == sharedRinse)
  948. {
  949. continue;
  950. }
  951. if (rinseItem == startRinse)
  952. {
  953. continue;
  954. }
  955. if(rinseEntity.IsBusy||rinseEntity.WaferHolderInfo!=null)
  956. {
  957. busyRinseCount++;
  958. }
  959. }
  960. int resRinseCount=rinseCount- busyRinseCount;
  961. //计算剩余Rinse数量小于等于busy metal数量,则不可用
  962. if (resRinseCount <= busyMetalCount)
  963. {
  964. return false;
  965. }
  966. }
  967. return true;
  968. }
  969. /// <summary>
  970. /// 检验模块是否可用(不包含WH)
  971. /// </summary>
  972. /// <param name="item"></param>
  973. /// <returns></returns>
  974. private bool CheckAvaibleEmptyModule(IModuleEntity item,ModuleType moduleType,string sequenceType)
  975. {
  976. if (!CheckAvaibleModule(item, moduleType, sequenceType))
  977. {
  978. return false;
  979. }
  980. if (!ModuleHelper.IsSRD(item.Module))
  981. {
  982. WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(item.Module.ToString());
  983. if (waferHolderInfo == null)
  984. {
  985. return true;
  986. }
  987. }
  988. else
  989. {
  990. if (!WaferManager.Instance.CheckHasWafer(item.Module, 0))
  991. {
  992. return true;
  993. }
  994. }
  995. return false;
  996. }
  997. /// <summary>
  998. /// 检验模块是否可用
  999. /// </summary>
  1000. /// <param name="item"></param>
  1001. /// <returns></returns>
  1002. public bool CheckAvaibleModule(IModuleEntity item,ModuleType moduleType,string sequenceType)
  1003. {
  1004. if (item.IsDisable)
  1005. {
  1006. return false;
  1007. }
  1008. if (!item.IsAuto)
  1009. {
  1010. return false;
  1011. }
  1012. if (item.IsError)
  1013. {
  1014. return false;
  1015. }
  1016. if (item.IsInit)
  1017. {
  1018. return false;
  1019. }
  1020. if (moduleType==ModuleType.Metal)
  1021. {
  1022. if(item.IsProduction && sequenceType == ENGINEERING)
  1023. return false;
  1024. if (item.IsEngineering && sequenceType == PRODUCTION)
  1025. return false;
  1026. }
  1027. return true;
  1028. }
  1029. /// <summary>
  1030. /// 获取剩余时间最小的模块
  1031. /// </summary>
  1032. /// <param name="avaibles"></param>
  1033. /// <returns></returns>
  1034. private ModuleName GetMinTimeToReadyModule(List<IModuleEntity> avaibles,ModuleType moduleType)
  1035. {
  1036. if (avaibles.Count == 1)
  1037. {
  1038. return avaibles[0].Module;
  1039. }
  1040. int timeToReady = int.MaxValue;
  1041. IModuleEntity selectedModule = null;
  1042. List<IModuleEntity> idleModuleEtities = new List<IModuleEntity>();
  1043. foreach (var item in avaibles)
  1044. {
  1045. if (item.IsIdle)
  1046. {
  1047. if(moduleType!=ModuleType.Metal)
  1048. {
  1049. return item.Module;
  1050. }
  1051. idleModuleEtities.Add(item);
  1052. }
  1053. if (item.TimeToReady < timeToReady&&idleModuleEtities.Count==0)
  1054. {
  1055. timeToReady = item.TimeToReady;
  1056. selectedModule = item;
  1057. }
  1058. }
  1059. if (idleModuleEtities.Count != 0)
  1060. {
  1061. return GetMinUsageMetal(idleModuleEtities);
  1062. }
  1063. if (selectedModule != null)
  1064. {
  1065. return selectedModule.Module;
  1066. }
  1067. return ModuleName.Unknown;
  1068. }
  1069. /// <summary>
  1070. /// 获取电量最小的Metal
  1071. /// </summary>
  1072. /// <param name="idleModuleEntities"></param>
  1073. /// <returns></returns>
  1074. private ModuleName GetMinUsageMetal(List<IModuleEntity> idleModuleEntities)
  1075. {
  1076. double usage = double.MaxValue;
  1077. ModuleName selectedModuleName = ModuleName.Unknown;
  1078. foreach (var item in idleModuleEntities)
  1079. {
  1080. MetalEntity metalEntity= item as MetalEntity;
  1081. if(metalEntity!=null)
  1082. {
  1083. MetalUsage metalUsage = metalEntity.MetalUsage;
  1084. if (metalUsage == null)
  1085. {
  1086. return metalEntity.Module;
  1087. }
  1088. if (metalUsage.TotalUsage < usage)
  1089. {
  1090. usage= metalUsage.TotalUsage;
  1091. selectedModuleName = metalEntity.Module;
  1092. }
  1093. }
  1094. }
  1095. return selectedModuleName;
  1096. }
  1097. /// <summary>
  1098. /// 获取Metal可用的Rinse模块
  1099. /// </summary>
  1100. /// <param name="metalName"></param>
  1101. /// <returns></returns>
  1102. private ModuleName GetMetalAvaibleRinseModule(List<IModuleEntity> items, ModuleName metalName)
  1103. {
  1104. int metalId = CellItemManager.Instance.GetCellIdByModuleName(metalName.ToString());
  1105. if (metalId == 0)
  1106. {
  1107. return ModuleName.Unknown;
  1108. }
  1109. List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByMetal(metalName.ToString());
  1110. if (rinseItems.Count == 0)
  1111. {
  1112. return ModuleName.Unknown;
  1113. }
  1114. List<IModuleEntity> avaibles = new List<IModuleEntity>();
  1115. foreach (var item in items)
  1116. {
  1117. LayoutCellItem cellItem = rinseItems.Find(O => O.ModuleName == item.Module.ToString());
  1118. if (cellItem != null)
  1119. {
  1120. RinseEntity rinseEntity = (RinseEntity)item;
  1121. if (rinseEntity.IsInitialized && rinseEntity.IsAuto)
  1122. {
  1123. avaibles.Add(rinseEntity);
  1124. }
  1125. }
  1126. }
  1127. int minInterval = int.MaxValue;
  1128. IModuleEntity moduleEntity = null;
  1129. foreach (var item in avaibles)
  1130. {
  1131. LayoutCellItem cellItem = rinseItems.Find(O => O.ModuleName == item.Module.ToString());
  1132. if (cellItem != null)
  1133. {
  1134. int abiasId = Math.Abs(metalId - cellItem.CellID);
  1135. if (abiasId < minInterval)
  1136. {
  1137. minInterval = abiasId;
  1138. moduleEntity = item;
  1139. }
  1140. }
  1141. }
  1142. if (moduleEntity != null)
  1143. {
  1144. return moduleEntity.Module;
  1145. }
  1146. return ModuleName.Unknown;
  1147. }
  1148. /// <summary>
  1149. /// 检验Metal可用的Rinse模块
  1150. /// </summary>
  1151. /// <param name="metalName"></param>
  1152. /// <returns></returns>
  1153. private ModuleName GetMetalAvaibleEmptyRinseModule(List<IModuleEntity> items, ModuleName metalName)
  1154. {
  1155. int metalId = CellItemManager.Instance.GetCellIdByModuleName(metalName.ToString());
  1156. if (metalId == 0)
  1157. {
  1158. return ModuleName.Unknown;
  1159. }
  1160. List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByMetal(metalName.ToString());
  1161. if (rinseItems.Count == 0)
  1162. {
  1163. return ModuleName.Unknown;
  1164. }
  1165. List<IModuleEntity> avaibles = new List<IModuleEntity>();
  1166. List<ModuleName> sharedRinseList = new List<ModuleName>();
  1167. foreach (var item in items)
  1168. {
  1169. LayoutCellItem cellItem = rinseItems.Find(O => O.ModuleName == item.Module.ToString());
  1170. if (cellItem != null)
  1171. {
  1172. RinseEntity rinseEntity = (RinseEntity)item;
  1173. if (rinseEntity.IsIdle && rinseEntity.IsAuto && rinseEntity.WaferHolderInfo == null)
  1174. {
  1175. avaibles.Add(rinseEntity);
  1176. if(CellItemManager.Instance.CheckRinseIsShared(rinseEntity.Module.ToString()))
  1177. {
  1178. sharedRinseList.Add(rinseEntity.Module);
  1179. }
  1180. }
  1181. }
  1182. }
  1183. int minInterval = int.MaxValue;
  1184. IModuleEntity moduleEntity = null;
  1185. foreach (var item in avaibles)
  1186. {
  1187. if (sharedRinseList.Contains(item.Module))
  1188. {
  1189. continue;
  1190. }
  1191. LayoutCellItem cellItem = rinseItems.Find(O => O.ModuleName == item.Module.ToString());
  1192. if (cellItem != null)
  1193. {
  1194. int abiasId = Math.Abs(metalId - cellItem.CellID);
  1195. if (abiasId < minInterval)
  1196. {
  1197. minInterval = abiasId;
  1198. moduleEntity = item;
  1199. }
  1200. }
  1201. }
  1202. if (moduleEntity != null)
  1203. {
  1204. return moduleEntity.Module;
  1205. }
  1206. else if(sharedRinseList.Count!=0)
  1207. {
  1208. return sharedRinseList[0];
  1209. }
  1210. return ModuleName.Unknown;
  1211. }
  1212. /// <summary>
  1213. /// 检验Metal cell recipe时间是否可用
  1214. /// </summary>
  1215. /// <param name="depRecipe"></param>
  1216. /// <returns></returns>
  1217. public bool CheckMetalCellRecipeTimeAvaible(IModuleEntity metalEntity,DepRecipe depRecipe)
  1218. {
  1219. List<IModuleEntity> metalEntities=Singleton<RouteManager>.Instance.GetModulesByModuleType(ModuleType.Metal);
  1220. int maxTimeToReady = 0;
  1221. foreach (MetalEntity item in metalEntities)
  1222. {
  1223. if (metalEntity.Module == item.Module)
  1224. {
  1225. continue;
  1226. }
  1227. if(item.IsBusy)
  1228. {
  1229. if(maxTimeToReady>item.TimeToReady)
  1230. {
  1231. maxTimeToReady = item.TimeToReady;
  1232. }
  1233. }
  1234. }
  1235. int transferOffSecond = SC.GetValue<int>("Transporter.TransporterTransferOffSeconds");
  1236. int recipeTotalTime = depRecipe.CalculateRecipeTotalTime();
  1237. //增加了Transporter最大传输时间和最小传输时间的差值
  1238. if (recipeTotalTime>=maxTimeToReady+transferOffSecond)
  1239. {
  1240. return true;
  1241. }
  1242. return false;
  1243. }
  1244. /// <summary>
  1245. /// 根据化学液获取可用的metal集合
  1246. /// </summary>
  1247. /// <param name="chemistry"></param>
  1248. /// <returns></returns>
  1249. public List<MetalEntity> GetAvaibleMetalList(string chemistry, string sequenceType,int waferSize, bool isEmpty)
  1250. {
  1251. List<IModuleEntity> reservoirEntities = Singleton<RouteManager>.Instance.GetModulesByModuleType(ModuleType.Reservoir);
  1252. List<string> avaibles = new List<string>();
  1253. foreach (IModuleEntity item in reservoirEntities)
  1254. {
  1255. ReservoirEntity entity = item as ReservoirEntity;
  1256. if (entity.Chemistry == chemistry && entity.IsAuto && entity.IsInitialized)
  1257. {
  1258. avaibles.Add(entity.Module.ToString());
  1259. }
  1260. }
  1261. List<MetalEntity> metals = new List<MetalEntity>();
  1262. foreach (string item in avaibles)
  1263. {
  1264. ReservoirItem reservoirItem = ReservoirItemManager.Instance.GetReservoirItem(item);
  1265. if (reservoirItem == null)
  1266. {
  1267. continue;
  1268. }
  1269. foreach (MetalItem subItem in reservoirItem.MetalCells)
  1270. {
  1271. MetalEntity entity = Singleton<RouteManager>.Instance.GetModule<MetalEntity>($"Metal{subItem.MetalID}");
  1272. if (!CheckAvaibleModule(entity, ModuleType.Metal, sequenceType))
  1273. {
  1274. continue;
  1275. }
  1276. if (entity.MetalWaferSize != waferSize)
  1277. {
  1278. continue;
  1279. }
  1280. if (!isEmpty || (isEmpty && entity.WaferHolderInfo == null))
  1281. {
  1282. metals.Add(entity);
  1283. }
  1284. }
  1285. }
  1286. return metals;
  1287. }
  1288. /// <summary>
  1289. /// 获取上一个Metal
  1290. /// </summary>
  1291. /// <param name="sequenceIndex"></param>
  1292. /// <param name="sequences"></param>
  1293. /// <returns></returns>
  1294. public ModuleName GetPreMetalModuleName(int sequenceIndex,List<SchedulerSequence> sequences)
  1295. {
  1296. for(int i = sequenceIndex - 1; i >= 0; i--)
  1297. {
  1298. SchedulerSequence schedulerSequence= sequences[i];
  1299. if (schedulerSequence.ModuleType == ModuleType.Metal && ModuleHelper.IsMetal(schedulerSequence.ModuleName))
  1300. {
  1301. return schedulerSequence.ModuleName;
  1302. }
  1303. }
  1304. return ModuleName.Unknown;
  1305. }
  1306. }
  1307. }