LoadPortBaseDevice.cs 154 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042
  1. using Aitex.Core.RT.Device;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Net.Configuration;
  6. using System.Text;
  7. using System.Text.RegularExpressions;
  8. using System.Threading.Tasks;
  9. using Aitex.Core.Common;
  10. using Aitex.Core.RT.DataCenter;
  11. using Aitex.Core.RT.Event;
  12. using Aitex.Core.RT.OperationCenter;
  13. using Aitex.Core.RT.SCCore;
  14. using Aitex.Core.Util;
  15. using Aitex.Sorter.Common;
  16. using MECF.Framework.Common.Equipment;
  17. using MECF.Framework.Common.SubstrateTrackings;
  18. using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK;
  19. using Aitex.Core.RT.Device.Unit;
  20. using System.Threading;
  21. using static Aitex.Core.RT.Device.Unit.IOE84Passive;
  22. using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.CarrierIdReaders.CarrierIDReaderBase;
  23. using Aitex.Core.RT.Fsm;
  24. using MECF.Framework.Common.Event;
  25. using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
  26. using System.Diagnostics;
  27. namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase
  28. {
  29. public abstract class LoadPortBaseDevice : Entity, IEntity, ILoadPort
  30. {
  31. public LoadPortBaseDevice(string module, string name, RobotBaseDevice robot = null, IE84CallBack e84 = null,int slotsCount=25) : base()
  32. {
  33. Module = module;
  34. Name = name;
  35. LPModuleName = (ModuleName)Enum.Parse(typeof(ModuleName), Name);
  36. _robot = robot;
  37. if (_robot != null)
  38. {
  39. MapRobot.OnSlotMapRead += MapRobot_OnSlotMapRead;
  40. MapRobot.OnSlotMapThicknessRead += MapRobot_OnSlotMapThicknessRead;
  41. }
  42. _lpE84Callback = e84;
  43. SlotsCount = slotsCount;
  44. InitializeLP();
  45. }
  46. public int SlotsCount;
  47. public event Action<ModuleName, string> OnCarrierIDReadEvent;
  48. public event Action<ModuleName, string> OnProceedWithCarrierRequestEvent;
  49. //public event Action<ModuleName, string> OnCancelCarrierRequestEvent;
  50. public event Action<ModuleName, bool> OnPortTransferReadyEvent;
  51. public event Action<ModuleName, string> OnE84LoadStartEvent;
  52. public event Action<ModuleName, string> OnE84LoadCompleteEvent;
  53. public event Action<ModuleName, string> OnE84UnloadStartEvent;
  54. public event Action<ModuleName, string> OnE84UnloadCompleteEvent;
  55. public event Action<ModuleName, string> OnCarrierLoadStartEvent;
  56. public event Action<ModuleName, string> OnCarrierLoadCompleteEvent;
  57. public event Action<ModuleName, string> OnSlotMapReadEvent;
  58. public event Action<ModuleName, bool> OnCarrierPresenceChangeEvent;
  59. public void RequestProceedWithCarrier(string carrierId)
  60. {
  61. if (OnProceedWithCarrierRequestEvent != null)
  62. {
  63. OnProceedWithCarrierRequestEvent(LPModuleName, carrierId);
  64. }
  65. }
  66. public virtual void InformProcessComplete()
  67. {
  68. }
  69. public virtual void InformProcessStart()
  70. {
  71. }
  72. public virtual int TimelimitAction
  73. {
  74. get
  75. {
  76. if (SC.ContainsItem($"LoadPort.{Name}.TimeLimitAction"))
  77. return SC.GetValue<int>($"LoadPort.{Name}.TimeLimitAction");
  78. return 90;
  79. }
  80. }
  81. public virtual int TimelimitHome
  82. {
  83. get
  84. {
  85. if (SC.ContainsItem($"LoadPort.{Name}.TimeLimitLoadportHome"))
  86. return SC.GetValue<int>($"LoadPort.{Name}.TimeLimitLoadportHome");
  87. return 90;
  88. }
  89. }
  90. public virtual int TimeLimitNoOperation
  91. {
  92. get
  93. {
  94. if (SC.ContainsItem($"LoadPort.{Name}.TimeLimitNoOperation"))
  95. return SC.GetValue<int>($"LoadPort.{Name}.TimeLimitNoOperation");
  96. return 0;
  97. }
  98. }
  99. public virtual bool IsAutoReadCarrierID
  100. {
  101. get
  102. {
  103. return SC.ContainsItem($"LoadPort.{LPModuleName}.EnableAutoCarrierIdRead") ?
  104. SC.GetValue<bool>($"LoadPort.{LPModuleName}.EnableAutoCarrierIdRead") : true;
  105. }
  106. }
  107. public virtual bool IsAutoUnloadAfterProcess
  108. {
  109. get
  110. {
  111. return SC.ContainsItem($"LoadPort.{LPModuleName}.EnableAutoUnload") ?
  112. SC.GetValue<bool>($"LoadPort.{LPModuleName}.EnableAutoUnload") : false;
  113. }
  114. }
  115. public virtual bool IsCloseDoorWhenIdle
  116. {
  117. get
  118. {
  119. return SC.ContainsItem($"LoadPort.{LPModuleName}.CloseDoorWhenIdle") ?
  120. SC.GetValue<bool>($"LoadPort.{LPModuleName}.CloseDoorWhenIdle") : false;
  121. }
  122. }
  123. public virtual bool IsBypassCarrierIDReader
  124. {
  125. get
  126. {
  127. return SC.ContainsItem($"LoadPort.{LPModuleName}.BypassCarrierIDReader") ?
  128. SC.GetValue<bool>($"LoadPort.{LPModuleName}.BypassCarrierIDReader") : false;
  129. }
  130. }
  131. public virtual bool IsAutoDetectCarrierType
  132. {
  133. get
  134. {
  135. return SC.ContainsItem($"LoadPort.{LPModuleName}.AutoDetectCarrierType") ?
  136. SC.GetValue<bool>($"LoadPort.{LPModuleName}.AutoDetectCarrierType") : true;
  137. }
  138. }
  139. public virtual LightCurtainHandleEnum CurrentLightCurtainHandle
  140. {
  141. get
  142. {
  143. if (SC.ContainsItem($"LoadPort.{LPModuleName}.LightCurtainHandle"))
  144. return (LightCurtainHandleEnum)SC.GetValue<int>($"LoadPort.{LPModuleName}.LightCurtainHandle");
  145. return LightCurtainHandleEnum.Bypass;
  146. }
  147. }
  148. public virtual bool IsNeedMapOnUnload
  149. {
  150. get
  151. {
  152. if (SC.ContainsItem($"LoadPort.{LPModuleName}.IsNeedMapOnUnload"))
  153. return SC.GetValue<bool>($"LoadPort.{LPModuleName}.IsNeedMapOnUnload");
  154. return false;
  155. }
  156. }
  157. public virtual bool IsKeepClampAfterUnload
  158. {
  159. get
  160. {
  161. if (SC.ContainsItem($"CarrierInfo.KeepClampedAfterUnloadCarrier{InfoPadCarrierIndex}"))
  162. return SC.GetValue<bool>($"CarrierInfo.KeepClampedAfterUnloadCarrier{InfoPadCarrierIndex}");
  163. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.KeepClampedAfterUnloadCarrier"))
  164. return SC.GetValue<bool>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.KeepClampedAfterUnloadCarrier");
  165. return false;
  166. }
  167. }
  168. public virtual bool IsAutoClampOnCarrierArrive
  169. {
  170. get
  171. {
  172. if (SC.ContainsItem($"LoadPort.{Name}.AutoClamp"))
  173. return SC.GetValue<bool>($"LoadPort.{Name}.AutoClamp");
  174. return false;
  175. }
  176. }
  177. public virtual ManualSwHandleEnum ManualSwitchHandle
  178. {
  179. get
  180. {
  181. if (SC.ContainsItem($"LoadPort.{Name}.ManualSwitchHandle"))
  182. return (ManualSwHandleEnum)SC.GetValue<int>($"LoadPort.{Name}.ManualSwitchHandle");
  183. return ManualSwHandleEnum.None;
  184. }
  185. }
  186. public virtual bool IsCarrierEnabled
  187. {
  188. get
  189. {
  190. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.EnableCarrier"))
  191. return SC.GetValue<bool>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.EnableCarrier");
  192. return true;
  193. }
  194. }
  195. public virtual bool IsRemoteOperationPermit { get; set; } = true;
  196. public virtual double[] WaferMapThickness { get; set; }
  197. public virtual bool IsHomed { get; set; }
  198. public virtual Tuple<int, int> WaferThicknessTolerance //um
  199. {
  200. get
  201. {
  202. int lowlimit = 0;
  203. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ThicknessLowLimit"))
  204. lowlimit = SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ThicknessLowLimit");
  205. int highlimit = 5000;
  206. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ThicknessHighLimit"))
  207. highlimit = SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ThicknessHighLimit");
  208. return new Tuple<int, int>(lowlimit, highlimit);
  209. }
  210. }//um
  211. public virtual int SlotPositionBaseLine //um
  212. {
  213. get
  214. {
  215. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.SlotPositionBaseLine"))
  216. return SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.SlotPositionBaseLine");
  217. return 0;
  218. }
  219. }
  220. public virtual int SlotPitch //um
  221. {
  222. get
  223. {
  224. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.SlotPitch"))
  225. return SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.SlotPitch");
  226. return 10000;
  227. }
  228. }
  229. public virtual int WaferCenterDeviationLimit //um
  230. {
  231. get
  232. {
  233. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.WaferCenterDeviationLimit"))
  234. return SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.WaferCenterDeviationLimit");
  235. return 1000;
  236. }
  237. }
  238. public virtual E84SigState LPE84SigState
  239. {
  240. get
  241. {
  242. if (_lpE84Callback != null)
  243. {
  244. return new E84SigState()
  245. {
  246. LightCurtain = _lpE84Callback.GetE84SignalState(E84SignalID.LightCurtain),
  247. CS_0 = _lpE84Callback.GetE84SignalState(E84SignalID.CS_0),
  248. CS_1 = _lpE84Callback.GetE84SignalState(E84SignalID.CS_1),
  249. AM_AVBL = _lpE84Callback.GetE84SignalState(E84SignalID.AM_AVBL),
  250. VALID = _lpE84Callback.GetE84SignalState(E84SignalID.VALID),
  251. TR_REQ = _lpE84Callback.GetE84SignalState(E84SignalID.TR_REQ),
  252. BUSY = _lpE84Callback.GetE84SignalState(E84SignalID.BUSY),
  253. COMPT = _lpE84Callback.GetE84SignalState(E84SignalID.COMPT),
  254. CONT = _lpE84Callback.GetE84SignalState(E84SignalID.CONT),
  255. L_REQ = _lpE84Callback.GetE84SignalState(E84SignalID.L_REQ),
  256. U_REQ = _lpE84Callback.GetE84SignalState(E84SignalID.U_REQ),
  257. VA = _lpE84Callback.GetE84SignalState(E84SignalID.VA),
  258. READY = _lpE84Callback.GetE84SignalState(E84SignalID.READY),
  259. VS_0 = _lpE84Callback.GetE84SignalState(E84SignalID.VS_0),
  260. VS_1 = _lpE84Callback.GetE84SignalState(E84SignalID.VS_1),
  261. HO_AVBL = _lpE84Callback.GetE84SignalState(E84SignalID.HO_AVBL),
  262. ES = _lpE84Callback.GetE84SignalState(E84SignalID.ES),
  263. };
  264. }
  265. return _lpE84SigState;
  266. }
  267. set { _lpE84SigState = value; }
  268. }
  269. private E84SigState _lpE84SigState;
  270. public virtual bool SetCarrierIndex(int indexValue, out string reason)
  271. {
  272. reason = "";
  273. if (IsAutoDetectCarrierType)
  274. {
  275. reason = "Auto Detect is On";
  276. EV.PostWarningLog(Module, $"{Name} can not set carrier type index when auto detection is enable.");
  277. return false;
  278. }
  279. if (indexValue >= ValidCarrierTypeCount)
  280. {
  281. reason = "Invalid Carrier Index Value";
  282. EV.PostWarningLog(Module, $"{Name} can not set carrier type index with {indexValue} larger than {ValidCarrierTypeCount - 1}.");
  283. return false;
  284. }
  285. if (SC.ContainsItem($"LoadPort.{LPModuleName}.CarrierIndex"))
  286. {
  287. SC.SetItemValue($"LoadPort.{LPModuleName}.CarrierIndex", indexValue);
  288. }
  289. InfoPadCarrierIndex = indexValue;
  290. EV.PostInfoLog(Module, $"{Name} set carrier type index to {InfoPadCarrierIndex}");
  291. return true;
  292. }
  293. public bool SetCarrierName(string carrierName, out string reason)
  294. {
  295. reason = "";
  296. for (int i = 0; i < ValidCarrierTypeCount; i++)
  297. {
  298. if (SC.ContainsItem($"CarrierInfo.EnableCarrier{i}") && !SC.GetValue<bool>($"CarrierInfo.EnableCarrier{i}"))
  299. continue;
  300. string carriertype = "";
  301. if (SC.ContainsItem($"CarrierInfo.CarrierName{i}"))
  302. {
  303. carriertype = SC.GetStringValue($"CarrierInfo.CarrierName{i}");
  304. }
  305. if (SC.ContainsItem($"CarrierInfo.Carrier{i}.CarrierName"))
  306. {
  307. carriertype = SC.GetStringValue($"CarrierInfo.Carrier{i}.CarrierName");
  308. }
  309. if (IsAutoDetectCarrierType)
  310. {
  311. reason = "AutoDetectOn";
  312. return false;
  313. }
  314. if (carrierName == carriertype)
  315. {
  316. EV.PostInfoLog(Module, $"{Name} set carrier Name to {carrierName}.");
  317. return SetCarrierIndex(i, out reason);
  318. }
  319. }
  320. reason = $"{carrierName} not existed.";
  321. return false;
  322. }
  323. public int ValidCarrierTypeCount { get; set; } = 16;
  324. public virtual Tuple<int, string>[] ValidCarrierTypeList
  325. {
  326. get
  327. {
  328. List<Tuple<int, string>> ret = new List<Tuple<int, string>>();
  329. for (int i = 0; i < ValidCarrierTypeCount; i++)
  330. {
  331. if (!SC.ContainsItem($"CarrierInfo.CarrierName{i}"))
  332. continue;
  333. if (SC.ContainsItem($"CarrierInfo.EnableCarrier{i}") && !SC.GetValue<bool>($"CarrierInfo.EnableCarrier{i}"))
  334. continue;
  335. if (!SC.ContainsItem($"CarrierInfo.CarrierName{i}"))
  336. continue;
  337. if (!SC.ContainsItem($"CarrierInfo.CarrierWaferSize{i}"))
  338. continue;
  339. string carriertype = "Carrier Type: " + SC.GetStringValue($"CarrierInfo.CarrierName{i}")
  340. + (SC.ContainsItem($"CarrierInfo.CarrierWaferSize{i}") ? ($";WaferSize:WS{SC.GetValue<int>($"CarrierInfo.CarrierWaferSize{i}")}") : "");
  341. ret.Add(new Tuple<int, string>(i, carriertype));
  342. }
  343. for (int i = 0; i < ValidCarrierTypeCount; i++)
  344. {
  345. if (!SC.ContainsItem($"CarrierInfo.Carrier{i}.CarrierName"))
  346. continue;
  347. if (SC.ContainsItem($"CarrierInfo.Carrier{i}.EnableCarrier") && !SC.GetValue<bool>($"CarrierInfo.Carrier{i}.EnableCarrier"))
  348. continue;
  349. if (!SC.ContainsItem($"CarrierInfo.Carrier{i}.CarrierName"))
  350. continue;
  351. if (!SC.ContainsItem($"CarrierInfo.Carrier{i}.CarrierWaferSize"))
  352. continue;
  353. string carriertype = "Carrier Type: " + SC.GetStringValue($"CarrierInfo.Carrier{i}.CarrierName")
  354. + (SC.ContainsItem($"CarrierInfo.Carrier{i}.CarrierWaferSize") ? ($";WaferSize:WS{SC.GetValue<int>($"CarrierInfo.Carrier{i}.CarrierWaferSize")}") : "");
  355. ret.Add(new Tuple<int, string>(i, carriertype));
  356. }
  357. return ret.ToArray();
  358. }
  359. }
  360. public virtual DispatchLPType DspLpType
  361. {
  362. get
  363. {
  364. if (SC.ContainsItem($"LoadPort.{Name}.DispatchLpType"))
  365. {
  366. int inttype = SC.GetValue<int>($"LoadPort.{Name}.DispatchLpType");
  367. return (DispatchLPType)inttype;
  368. }
  369. return DispatchLPType.NA;
  370. }
  371. }
  372. private void MapRobot_OnSlotMapRead(ModuleName arg1, string arg2)
  373. {
  374. if (arg1 == LPModuleName)
  375. {
  376. NoteTransferStop();
  377. OnSlotMapRead(arg2);
  378. }
  379. }
  380. private void MapRobot_OnSlotMapThicknessRead(ModuleName arg1, double[] arg2)
  381. {
  382. if (arg1 == LPModuleName)
  383. {
  384. OnSlotMapThicknessRead(arg2);
  385. }
  386. }
  387. private void OnSlotMapThicknessRead(double[] arg2)
  388. {
  389. WaferMapThickness = arg2;
  390. }
  391. private void InitializeLP()
  392. {
  393. BuildTransitionTable();
  394. SubscribeWaferPosition();
  395. SubscribeDataVariable();
  396. SubscribeOperation();
  397. SubscribeDeviceOperation();
  398. RegisterOperation();
  399. }
  400. private void BuildTransitionTable()
  401. {
  402. fsm = new StateMachine<LoadPortBaseDevice>(Name + ".LPStateMachine", (int)LoadPortStateEnum.Init, 50);
  403. AnyStateTransition(LoadPortMsg.Error, fError, LoadPortStateEnum.Error);
  404. AnyStateTransition((int)FSM_MSG.ALARM, fError, (int)LoadPortStateEnum.Error);
  405. AnyStateTransition(LoadPortMsg.Abort, fStartAbort, LoadPortStateEnum.Init);
  406. Transition(LoadPortStateEnum.Init, LoadPortMsg.Reset, fStartReset, LoadPortStateEnum.Resetting);
  407. Transition(LoadPortStateEnum.Error, LoadPortMsg.Reset, fStartReset, LoadPortStateEnum.Resetting);
  408. Transition(LoadPortStateEnum.Idle, LoadPortMsg.Reset, fStartReset, LoadPortStateEnum.Resetting);
  409. Transition(LoadPortStateEnum.TransferBlock, LoadPortMsg.Reset, fStartReset, LoadPortStateEnum.Resetting);
  410. Transition(LoadPortStateEnum.Resetting, LoadPortMsg.ResetComplete, fCompleteReset, LoadPortStateEnum.Idle);
  411. Transition(LoadPortStateEnum.Resetting, LoadPortMsg.ActionDone, fCompleteReset, LoadPortStateEnum.Idle);
  412. Transition(LoadPortStateEnum.Resetting, FSM_MSG.TIMER, fMonitorReset, LoadPortStateEnum.Idle);
  413. Transition(LoadPortStateEnum.Init, LoadPortMsg.Init, fStartInit, LoadPortStateEnum.Initializing);
  414. Transition(LoadPortStateEnum.Idle, LoadPortMsg.Init, fStartInit, LoadPortStateEnum.Initializing);
  415. Transition(LoadPortStateEnum.Error, LoadPortMsg.Init, fStartInit, LoadPortStateEnum.Initializing);
  416. Transition(LoadPortStateEnum.Error, LoadPortMsg.InitComplete, fCompleteInit, LoadPortStateEnum.Idle);
  417. Transition(LoadPortStateEnum.Init, LoadPortMsg.InitComplete, fCompleteInit, LoadPortStateEnum.Idle);
  418. Transition(LoadPortStateEnum.Initializing, LoadPortMsg.ActionDone, fCompleteInit, LoadPortStateEnum.Idle);
  419. Transition(LoadPortStateEnum.Initializing, LoadPortMsg.InitComplete, fCompleteInit, LoadPortStateEnum.Idle);
  420. Transition(LoadPortStateEnum.Initializing, FSM_MSG.TIMER, fMonitorInit, LoadPortStateEnum.Idle);
  421. Transition(LoadPortStateEnum.Init, LoadPortMsg.StartHome, fStartHomet, LoadPortStateEnum.Homing);
  422. Transition(LoadPortStateEnum.Idle, LoadPortMsg.StartHome, fStartHomet, LoadPortStateEnum.Homing);
  423. Transition(LoadPortStateEnum.Error, LoadPortMsg.StartHome, fStartHomet, LoadPortStateEnum.Homing);
  424. Transition(LoadPortStateEnum.Homing, LoadPortMsg.ActionDone, fCompleteHome, LoadPortStateEnum.Idle);
  425. Transition(LoadPortStateEnum.Homing, LoadPortMsg.HomeComplete, fCompleteHome, LoadPortStateEnum.Idle);
  426. Transition(LoadPortStateEnum.Homing, FSM_MSG.TIMER, fMonitorHome, LoadPortStateEnum.Idle);
  427. Transition(LoadPortStateEnum.Init, LoadPortMsg.HomeComplete, fCompleteHome, LoadPortStateEnum.Idle);
  428. Transition(LoadPortStateEnum.Error, LoadPortMsg.HomeComplete, fCompleteHome, LoadPortStateEnum.Idle);
  429. Transition(LoadPortStateEnum.Idle, LoadPortMsg.Load, fStartLoad, LoadPortStateEnum.Loading);
  430. Transition(LoadPortStateEnum.Loading, LoadPortMsg.ActionDone, fCompleteLoad, LoadPortStateEnum.Idle);
  431. Transition(LoadPortStateEnum.Loading, LoadPortMsg.LoadComplete, fCompleteLoad, LoadPortStateEnum.Idle);
  432. Transition(LoadPortStateEnum.Loading, FSM_MSG.TIMER, fMonitorLoad, LoadPortStateEnum.Idle);
  433. Transition(LoadPortStateEnum.Idle, LoadPortMsg.Unload, fStartUnload, LoadPortStateEnum.Unloading);
  434. Transition(LoadPortStateEnum.Unloading, LoadPortMsg.ActionDone, fCompleteUnload, LoadPortStateEnum.Idle);
  435. Transition(LoadPortStateEnum.Unloading, LoadPortMsg.UnloadComplete, fCompleteUnload, LoadPortStateEnum.Idle);
  436. Transition(LoadPortStateEnum.Unloading, FSM_MSG.TIMER, fMonitorUnload, LoadPortStateEnum.Idle);
  437. Transition(LoadPortStateEnum.Idle, LoadPortMsg.StartExecute, fStartExecute, LoadPortStateEnum.Executing);
  438. Transition(LoadPortStateEnum.Executing, LoadPortMsg.ActionDone, fCompleteExecute, LoadPortStateEnum.Idle);
  439. Transition(LoadPortStateEnum.Executing, LoadPortMsg.MoveComplete, fCompleteExecute, LoadPortStateEnum.Idle);
  440. Transition(LoadPortStateEnum.Executing, FSM_MSG.TIMER, fMonitorExecuting, LoadPortStateEnum.Idle);
  441. Transition(LoadPortStateEnum.Idle, LoadPortMsg.StartReadData, fStartRead, LoadPortStateEnum.ReadingData);
  442. Transition(LoadPortStateEnum.ReadingData, LoadPortMsg.ActionDone, fCompleteRead, LoadPortStateEnum.Idle);
  443. Transition(LoadPortStateEnum.ReadingData, LoadPortMsg.ReadComplete, fCompleteRead, LoadPortStateEnum.Idle);
  444. Transition(LoadPortStateEnum.ReadingData, FSM_MSG.TIMER, fMonitorReadingData, LoadPortStateEnum.Idle);
  445. Transition(LoadPortStateEnum.Idle, LoadPortMsg.StartWriteData, fStartWrite, LoadPortStateEnum.WrittingData);
  446. Transition(LoadPortStateEnum.WrittingData, LoadPortMsg.ActionDone, fCompleteWrite, LoadPortStateEnum.Idle);
  447. Transition(LoadPortStateEnum.WrittingData, LoadPortMsg.MoveComplete, fCompleteWrite, LoadPortStateEnum.Idle);
  448. Transition(LoadPortStateEnum.Idle, LoadPortMsg.StartAccess, fStartAccess, LoadPortStateEnum.TransferBlock);
  449. Transition(LoadPortStateEnum.TransferBlock, LoadPortMsg.CompleteAccess, fCompleteAccess, LoadPortStateEnum.Idle);
  450. //Transition(LoadPortStateEnum.TransferBlock, LoadPortMsg.ActionDone, fCompleteAccess, LoadPortStateEnum.Idle);
  451. Transition(LoadPortStateEnum.TransferBlock, FSM_MSG.TIMER, fMonitorTransferBlock, LoadPortStateEnum.TransferBlock);
  452. }
  453. protected virtual bool fMonitorReadingData(object[] param)
  454. {
  455. return false;
  456. }
  457. protected virtual bool fMonitorTransferBlock(object[] param)
  458. {
  459. return true;
  460. }
  461. protected virtual bool fMonitorExecuting(object[] param)
  462. {
  463. return false;
  464. }
  465. protected virtual bool fMonitorInit(object[] param)
  466. {
  467. return false;
  468. }
  469. protected virtual bool fMonitorHome(object[] param)
  470. {
  471. return false;
  472. }
  473. protected virtual bool fMonitorReset(object[] param)
  474. {
  475. return false;
  476. }
  477. protected virtual bool fMonitorUnload(object[] param)
  478. {
  479. return false;
  480. }
  481. protected virtual bool fMonitorLoad(object[] param)
  482. {
  483. return false;
  484. }
  485. protected virtual bool fCompleteAccess(object[] param)
  486. {
  487. return true;
  488. }
  489. protected virtual bool fStartAccess(object[] param)
  490. {
  491. return true;
  492. }
  493. protected virtual bool fCompleteHome(object[] param)
  494. {
  495. return true;
  496. }
  497. protected virtual bool fStartHomet(object[] param)
  498. {
  499. return true;
  500. }
  501. protected virtual bool fCompleteWrite(object[] param)
  502. {
  503. return true;
  504. }
  505. protected abstract bool fStartWrite(object[] param);
  506. protected virtual bool fCompleteRead(object[] param)
  507. {
  508. return true;
  509. }
  510. protected abstract bool fStartRead(object[] param);
  511. protected virtual bool fCompleteMove(object[] param)
  512. {
  513. return true;
  514. }
  515. protected abstract bool fStartExecute(object[] param);
  516. protected virtual bool fCompleteExecute(object[] param)
  517. {
  518. return true;
  519. }
  520. protected abstract bool fStartUnload(object[] param);
  521. protected virtual bool fCompleteUnload(object[] param)
  522. {
  523. OnUnloaded();
  524. return true;
  525. }
  526. protected virtual bool fCompleteLoad(object[] param)
  527. {
  528. OnLoaded();
  529. return true;
  530. }
  531. protected abstract bool fStartLoad(object[] param);
  532. protected virtual bool fCompleteInit(object[] param)
  533. {
  534. return true;
  535. }
  536. protected abstract bool fStartInit(object[] param);
  537. protected virtual bool fCompleteReset(object[] param)
  538. {
  539. return true;
  540. }
  541. protected abstract bool fStartReset(object[] param);
  542. protected virtual bool fStartAbort(object[] param)
  543. {
  544. return true;
  545. }
  546. protected virtual bool fError(object[] param)
  547. {
  548. return true;
  549. }
  550. private void SubscribeDeviceOperation()
  551. {
  552. }
  553. private void SubscribeOperation()
  554. {
  555. }
  556. protected virtual void StartClampAction(bool isClamp)
  557. {
  558. }
  559. protected virtual void SubscribeWaferPosition()
  560. {
  561. WaferManager.Instance.SubscribeLocation(LPModuleName, SlotsCount);
  562. }
  563. protected virtual void SubscribeDataVariable()
  564. {
  565. CarrierManager.Instance.SubscribeLocation(LPModuleName.ToString());
  566. DATA.Subscribe(Name, "IsPresent", () => _isPresent);
  567. DATA.Subscribe(Name, "IsPlaced", () => _isPlaced);
  568. DATA.Subscribe(Name, "IsClamped", () => ClampState == FoupClampState.Close);
  569. DATA.Subscribe(Name, "IsDocked", () => DockState == FoupDockState.Docked);
  570. DATA.Subscribe(Name, "IsDoorOpen", () => DoorState == FoupDoorState.Open);
  571. DATA.Subscribe(Name, "IsAccessSwPressed", () => IsAccessSwPressed);
  572. DATA.Subscribe(Name, "CarrierId", () => _carrierId);
  573. DATA.Subscribe(Name, "LPLotID", () => _lplotID);
  574. DATA.Subscribe(Name, "IsMapped", () => _isMapped);
  575. DATA.Subscribe(Name, "IsAutoDetectCarrierType", () => IsAutoDetectCarrierType);
  576. DATA.Subscribe(Name, "ValidCarrierTypeList", () => ValidCarrierTypeList);
  577. DATA.Subscribe($"{Name}.LoadportState", () => CurrentState.ToString());
  578. DATA.Subscribe($"{Name}.Status", () => CurrentState.ToString());
  579. //DATA.Subscribe($"{Name}.LoadportBusy", () => );
  580. DATA.Subscribe($"{Name}.LoadportError", () => ErrorCode);
  581. DATA.Subscribe($"{Name}.CassetteState", () => CassetteState);
  582. DATA.Subscribe($"{Name}.FoupClampState", () => ClampState);
  583. DATA.Subscribe($"{Name}.FoupDockState", () => DockState);
  584. DATA.Subscribe($"{Name}.FoupDoorState", () => DoorState);
  585. DATA.Subscribe($"{Name}.FoupDoorPosition", () => DoorPosition);
  586. DATA.Subscribe($"{Name}.SlotMap", () => SlotMap);
  587. DATA.Subscribe($"{Name}.WaferMapThickness", () => WaferMapThickness);
  588. DATA.Subscribe($"{Name}.IndicatiorLoad", () => IndicatiorLoad);
  589. DATA.Subscribe($"{Name}.IndicatiorUnload", () => IndicatiorUnload);
  590. DATA.Subscribe($"{Name}.IndicatiorPresence", () => IndicatiorPresence);
  591. DATA.Subscribe($"{Name}.IndicatiorPlacement", () => IndicatiorPlacement);
  592. DATA.Subscribe($"{Name}.IndicatiorAlarm", () => IndicatorAlarm);
  593. DATA.Subscribe($"{Name}.IndicatiorAccessAuto", () => IndicatiorAccessAuto);
  594. DATA.Subscribe($"{Name}.IndicatiorAccessManual", () => IndicatiorAccessManual);
  595. DATA.Subscribe($"{Name}.IndicatiorOpAccess", () => IndicatiorOpAccess);
  596. DATA.Subscribe($"{Name}.IndicatiorStatus1", () => IndicatiorStatus1);
  597. DATA.Subscribe($"{Name}.IndicatiorStatus2", () => IndicatiorStatus2);
  598. DATA.Subscribe($"{Name}.CasstleType", () => (int)CasstleType);
  599. DATA.Subscribe($"{Name}.InfoPadCarrierType", () => SpecCarrierType);
  600. DATA.Subscribe($"{Name}.InfoPadCarrierTypeInformation", () => SpecCarrierInformation);
  601. DATA.Subscribe($"{Name}.InfoPadCarrierIndex", () => InfoPadCarrierIndex);
  602. DATA.Subscribe($"{Name}.CarrierWaferSize", () => GetCurrentWaferSize().ToString());
  603. DATA.Subscribe($"{Name}.IsError", () => CurrentState == LoadPortStateEnum.Error);
  604. DATA.Subscribe($"{Name}.PreDefineWaferCount", () => PreDefineWaferCount);
  605. DATA.Subscribe($"{Name}.IsVerifyPreDefineWaferCount", () => IsVerifyPreDefineWaferCount);
  606. DATA.Subscribe($"{Name}.ValidSlotsNumber", () => ValidSlotsNumber);
  607. DATA.Subscribe($"{Name}.IsCarrierEnabled", () => IsCarrierEnabled);
  608. EV.Subscribe(new EventItem("Event", EventCarrierArrived, "Carrier arrived on port"));
  609. EV.Subscribe(new EventItem("Event", EventCarrierRemoved, "Carrier removed from port"));
  610. EV.Subscribe(new EventItem("Event", EventCarrierIdRead, "Carrier ID read"));
  611. EV.Subscribe(new EventItem("Event", EventCarrierIdReadFailed, "Carrier ID read failed"));
  612. EV.Subscribe(new EventItem("Event", EventCarrierIdWrite, "Carrier ID write"));
  613. EV.Subscribe(new EventItem("Event", EventCarrierIdWriteFailed, "Carrier ID write failed"));
  614. EV.Subscribe(new EventItem("Event", EventSlotMapAvailable, "Slot map available"));
  615. EV.Subscribe(new EventItem("Event", EventCarrierUnloaded, "Carrier unloaded"));
  616. EV.Subscribe(new EventItem("Event", EventCarrierloaded, "Carrier loaded"));
  617. EV.Subscribe(new EventItem("Event", EventCarrierOpened, "Carrier door opened successfully"));
  618. EV.Subscribe(new EventItem("Event", EventCarrierClosed, "Carrier door closed successfully"));
  619. EV.Subscribe(new EventItem("Event", EventCarrierLocationChange, "Carrier location changed successfully"));
  620. EV.Subscribe(new EventItem("Event", EventCarrierClamped, "Carrier is clamped on port successfully"));
  621. EV.Subscribe(new EventItem("Event", EventCarrierUnclamped, "Carrier is unclamped on port successfully"));
  622. EV.Subscribe(new EventItem("Event", EventCarrierDocked, "Carrier is docked successfully"));
  623. EV.Subscribe(new EventItem("Event", EventCarrierUndocked, "Carrier is undocked v"));
  624. EV.Subscribe(new EventItem("Event", EventCarrierIdReadFailed1, "Carrier ID read failed on port"));
  625. EV.Subscribe(new EventItem("Event", EventCarrierUnknowCid, "Carrier ID is unknow"));
  626. EV.Subscribe(new EventItem("Event", EventCarrierIdRead1, "Carrier ID is read successfully"));
  627. EV.Subscribe(new EventItem("Event", EventCarrierArrived1, "Carrier arrived on port successfully"));
  628. EV.Subscribe(new EventItem("Event", EventCarrierRemoved1, "Carrier removed from port successfully"));
  629. EV.Subscribe(new EventItem("Event", EventCarrierIdWrite1, "Carrier ID is written successfully"));
  630. EV.Subscribe(new EventItem("Event", EventCarrierIdWriteFailed1, "Carrier ID is written failed"));
  631. EV.Subscribe(new EventItem("Event", EventMapComplete, "Carrier is mapped successfully"));
  632. EV.Subscribe(new EventItem("Event", EventCarrierUnloaded1, "Carrier is unloaded successfully"));
  633. EV.Subscribe(new EventItem("Event", EventCarrierLoaded1, "Carrier is loaded successfully"));
  634. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierArrived, $"Carrier arrived on {LPModuleName}"));
  635. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierRemoved, $"Carrier removed from {LPModuleName}"));
  636. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdRead, $"Carrier ID read on {LPModuleName}"));
  637. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdReadFailed, $"Carrier ID read failed"));
  638. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdWrite, $"Carrier ID write"));
  639. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdWriteFailed, $"Carrier ID write failed"));
  640. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventSlotMapAvailable, $"Slot map available"));
  641. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierUnloaded, $"Carrier unloaded"));
  642. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierloaded, $"Carrier loaded"));
  643. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierOpened, $"Carrier door opened successfully"));
  644. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierClosed, $"Carrier door closed successfully"));
  645. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierLocationChange, $"Carrier location changed successfully"));
  646. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierClamped, $"Carrier is clamped on port successfully"));
  647. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierUnclamped, $"Carrier is unclamped on port successfully"));
  648. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierDocked, $"Carrier is docked successfully"));
  649. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierUndocked, $"Carrier is undocked v"));
  650. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdReadFailed1, $"Carrier ID read failed on port"));
  651. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierUnknowCid, $"Carrier ID is unknow"));
  652. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdRead1, $"Carrier ID is read successfully"));
  653. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierArrived1, $"Carrier arrived on port successfully"));
  654. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierRemoved1, $"Carrier removed from port successfully"));
  655. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdWrite1, $"Carrier ID is written successfully"));
  656. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierIdWriteFailed1, $"Carrier ID is written failed"));
  657. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventMapComplete, $"Carrier is mapped successfully"));
  658. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierUnloaded1, $"Carrier is unloaded successfully"));
  659. EV.Subscribe(new EventItem("Event", $"{LPModuleName}_" + EventCarrierLoaded1, $"Carrier is loaded successfully"));
  660. //SubscribeAlarm();
  661. IndicatorStateFeedback = new IndicatorState[20];
  662. if (_lpE84Callback != null)
  663. {
  664. _lpE84Callback.OnE84ActiveSignalChange += _lpE84Callback_OnE84ActiveSignalChange;
  665. _lpE84Callback.OnE84PassiveSignalChange += _lpE84Callback_OnE84PassiveSignalChange;
  666. _lpE84Callback.OnE84HandOffComplete += _lpE84Callback_OnE84HandOffComplete;
  667. _lpE84Callback.OnE84HandOffStart += _lpE84Callback_OnE84HandOffStart;
  668. _lpE84Callback.OnE84HandOffTimeout += _lpE84Callback_OnE84HandOffTimeout;
  669. }
  670. }
  671. public virtual bool RequestReadyToUnload()
  672. {
  673. return true;
  674. }
  675. private void SubscribeAlarm()
  676. {
  677. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortError, $"Load Port {Name} occurred error.", EventLevel.Alarm, EventType.EventUI_Notify));
  678. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortCommunicationError, $"Load Port {Name}error.", EventLevel.Alarm, EventType.EventUI_Notify));
  679. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortWaferProtrusion, $"Load Port {Name} wafer protrusion error.", EventLevel.Alarm, EventType.EventUI_Notify));
  680. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortLoadTimeOut, $"Load Port {Name} load timeout.", EventLevel.Alarm, EventType.EventUI_Notify));
  681. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortLoadFailed, $"Load Port {Name} load failed.", EventLevel.Alarm, EventType.EventUI_Notify));
  682. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortUnloadTimeOut, $"Load Port {Name} unload timeout.", EventLevel.Alarm, EventType.EventUI_Notify));
  683. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortUnloadFailed, $"Load Port {Name} unload failed.", EventLevel.Alarm, EventType.EventUI_Notify));
  684. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortMappingError, $"Load Port {Name} mapping error.", EventLevel.Alarm, EventType.EventUI_Notify));
  685. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortMappingTimeout, $"Load Port {Name} mapping Timeout.", EventLevel.Alarm, EventType.EventUI_Notify));
  686. EV.Subscribe(new EventItem("Alarm", AlarmCarrierIDReadError, $"Load Port {Name} occurred error when read carrier ID.", EventLevel.Alarm, EventType.EventUI_Notify));
  687. EV.Subscribe(new EventItem("Alarm", AlarmCarrierIDWriteError, $"Load Port {Name} occurred error when write carrierID.", EventLevel.Alarm, EventType.EventUI_Notify));
  688. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortMapCrossedWafer, $"Load Port {Name} mapped crossed wafer.", EventLevel.Alarm, EventType.EventUI_Notify));
  689. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortMapDoubleWafer, $"Load Port {Name} mapped double wafer.", EventLevel.Alarm, EventType.EventUI_Notify));
  690. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortMapUnknownWafer, $"Load Port {Name} mapped unknown wafer.", EventLevel.Alarm, EventType.EventUI_Notify));
  691. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortCarrierIDIndexConfigError, $"Load Port {Name} carrierID reader configuration is invalid.", EventLevel.Alarm, EventType.EventUI_Notify));
  692. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortHomeFailed, $"Load Port {Name} occurred error when home.", EventLevel.Alarm, EventType.EventUI_Notify));
  693. EV.Subscribe(new EventItem("Alarm", AlarmLoadPortHomeTimeout, $"Load Port {Name} home timeout.", EventLevel.Alarm, EventType.EventUI_Notify));
  694. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP1Timeout, $"Load Port {Name} occurred TP1 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  695. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP2Timeout, $"Load Port {Name} occurred TP2 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  696. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP3Timeout, $"Load Port {Name} occurred TP3 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  697. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP4Timeout, $"Load Port {Name} occurred TP4 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  698. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP5Timeout, $"Load Port {Name} occurred TP5 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  699. EV.Subscribe(new EventItem("Alarm", AlarmLoadE84TP6Timeout, $"Load Port {Name} occurred TP6 timeout during loading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  700. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP1Timeout, $"Load Port {Name} occurred TP1 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  701. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP2Timeout, $"Load Port {Name} occurred TP2 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  702. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP3Timeout, $"Load Port {Name} occurred TP3 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  703. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP4Timeout, $"Load Port {Name} occurred TP4 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  704. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP5Timeout, $"Load Port {Name} occurred TP5 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  705. EV.Subscribe(new EventItem("Alarm", AlarmUnloadE84TP6Timeout, $"Load Port {Name} occurred TP6 timeout during unloading foup.", EventLevel.Alarm, EventType.EventUI_Notify));
  706. }
  707. public LoadPortStateEnum CurrentState => (LoadPortStateEnum)fsm.State;
  708. public LoadPortStateEnum PreviousState => (LoadPortStateEnum)fsm.PrevState;
  709. public ModuleName LPModuleName { get; protected set; }
  710. public virtual int InfoPadCarrierIndex { get; set; }
  711. public virtual int InfoPadSensorIndex { get; set; }
  712. public virtual string SpecPortName
  713. {
  714. get
  715. {
  716. if (SC.ContainsItem($"LoadPort.{LPModuleName}.PortLable"))
  717. return SC.GetStringValue($"LoadPort.{LPModuleName}.PortLable");
  718. return specPortName;
  719. }
  720. set
  721. {
  722. if (SC.ContainsItem($"LoadPort.{LPModuleName}.PortLable"))
  723. SC.SetItemValueFromString($"LoadPort.{LPModuleName}.PortLable", value);
  724. specPortName = value;
  725. EV.PostInfoLog("LoadPort", $"{LPModuleName} lable change to {value}");
  726. }
  727. }
  728. private string specPortName;
  729. public string Module { get; set; }
  730. public string Name { get; set; }
  731. protected event Action<bool> ActionDone;
  732. public event Action<string, AlarmEventItem> OnDeviceAlarmStateChanged;
  733. public virtual bool IsAccessAuto
  734. {
  735. get;
  736. set; }
  737. public bool IsBusy { get; set; }
  738. public virtual bool IsIdle
  739. {
  740. get; set;
  741. }
  742. public virtual bool IsReady()
  743. {
  744. return fsm.State == (int)LoadPortStateEnum.Idle && !IsBusy;
  745. }
  746. public IndicatorState IndicatiorLoad { get; set; }
  747. public IndicatorState IndicatiorUnload { get; set; }
  748. public IndicatorState IndicatiorPresence { get; set; }
  749. public IndicatorState IndicatorAlarm { get; set; }
  750. public IndicatorState IndicatiorPlacement { get; set; }
  751. public IndicatorState IndicatiorOpAccess { get; set; }
  752. public IndicatorState IndicatiorAccessAuto { get; set; }
  753. public IndicatorState IndicatiorAccessManual { get; set; }
  754. public IndicatorState IndicatiorStatus1 { get; set; }
  755. public IndicatorState IndicatiorStatus2 { get; set; }
  756. public IndicatorState IndicatiorManualMode { get; set; }
  757. public IndicatorState IndicatiorClampUnclamp { get; set; }
  758. public IndicatorState IndicatiorDockUndock { get; set; }
  759. public static Dictionary<IndicatorType, Indicator> LoadPortIndicatorLightMap =
  760. new Dictionary<IndicatorType, Indicator>()
  761. {
  762. {IndicatorType.Load, Indicator.LOAD},
  763. {IndicatorType.Unload, Indicator.UNLOAD},
  764. {IndicatorType.AccessAuto, Indicator.ACCESSAUTO },
  765. {IndicatorType.AccessManual, Indicator.ACCESSMANUL},
  766. {IndicatorType.Alarm, Indicator.ALARM},
  767. {IndicatorType.Presence, Indicator.PRESENCE},
  768. {IndicatorType.Placement, Indicator.PLACEMENT},
  769. {IndicatorType.Status1, Indicator.RESERVE1},
  770. {IndicatorType.Status2, Indicator.RESERVE2},
  771. };
  772. public IndicatorState[] IndicatorStateFeedback { get; set; }
  773. public virtual FoupClampState ClampState { get; set; }
  774. public virtual FoupDockState DockState { get; set; }
  775. public virtual FoupDoorState DoorState { get; set; }
  776. public virtual FoupDoorPostionEnum DoorPosition { get; set; }
  777. public virtual bool IsVacuumON { get; set; }
  778. public virtual CasstleType CasstleType { get; set; }
  779. public virtual string SlotMap
  780. {
  781. get
  782. {
  783. WaferInfo[] wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(Name));
  784. string slot = "";
  785. for (int i = 0; i < 25; i++)
  786. {
  787. slot += wafers[i].IsEmpty ? "0" : "1";
  788. }
  789. return slot;
  790. }
  791. }
  792. public virtual string CurrentSlotMapResult
  793. {
  794. get; set;
  795. }
  796. //Hirata
  797. public int WaferCount { get; set; }
  798. public string LoadPortType { get; protected set; }
  799. public virtual bool IsInfoPadAOn { get; set; }
  800. public virtual bool IsInfoPadBOn { get; set; }
  801. public virtual bool IsInfoPadCOn { get; set; }
  802. public virtual bool IsInfoPadDOn { get; set; }
  803. public virtual bool IsWaferProtrude { get; set; }
  804. public virtual string SpecCarrierType
  805. {
  806. get;
  807. set;
  808. }
  809. public virtual string SpecCarrierInformation
  810. {
  811. get
  812. {
  813. if (_isPresent)
  814. return "Index:" + InfoPadCarrierIndex.ToString()
  815. + $"\r\nInfoPad:{InfoPadSensorIndex}"
  816. + $"\r\nType:{SpecCarrierType}"
  817. + $"\r\nSize:{GetCurrentWaferSize()}"
  818. + (IsVerifyPreDefineWaferCount ? ("\r\n" + "Pre-Count:" + PreDefineWaferCount.ToString()) : "")
  819. + $"\r\n{(IsMapped ? "Mapped" : "Not Mapped")}";
  820. return "";
  821. }
  822. }
  823. public virtual LoadportCassetteState CassetteState
  824. {
  825. get;
  826. set;
  827. }
  828. public virtual int PreDefineWaferCount
  829. {
  830. get; set;
  831. }
  832. public virtual bool IsVerifyPreDefineWaferCount
  833. {
  834. get
  835. {
  836. if (SC.ContainsItem($"LoadPort.{LPModuleName}.IsVerifyPreDefineWaferCount"))
  837. return SC.GetValue<bool>($"LoadPort.{LPModuleName}.IsVerifyPreDefineWaferCount");
  838. return false;
  839. }
  840. }
  841. public virtual WaferSize GetCurrentWaferSize()
  842. {
  843. int intwz = 0;
  844. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CarrierWaferSize"))
  845. intwz = SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CarrierWaferSize");
  846. else
  847. return WaferSize.WS12;
  848. switch (intwz)
  849. {
  850. case 0:
  851. return WaferSize.WS0;
  852. case 1:
  853. return WaferSize.WS0;
  854. case 2:
  855. return WaferSize.WS2;
  856. case 3:
  857. return WaferSize.WS3;
  858. case 4:
  859. return WaferSize.WS4;
  860. case 5:
  861. return WaferSize.WS5;
  862. case 6:
  863. return WaferSize.WS6;
  864. case 7:
  865. case 8:
  866. return WaferSize.WS8;
  867. case 12:
  868. return WaferSize.WS12;
  869. default:
  870. return WaferSize.WS0;
  871. }
  872. }
  873. public virtual bool IsMapWaferByLoadPort { get; set; }
  874. public virtual bool IsPresent
  875. {
  876. get { return _isPresent; }
  877. set { _isPresent = value; }
  878. }
  879. public virtual bool IsPlacement
  880. {
  881. get { return _isPlaced; }
  882. set { _isPlaced = value; }
  883. }
  884. public virtual bool IsMapped
  885. {
  886. get
  887. {
  888. return _isMapped;
  889. }
  890. set
  891. {
  892. _isMapped = value;
  893. }
  894. }
  895. public virtual bool IsLoaded
  896. {
  897. get
  898. {
  899. return DockState == FoupDockState.Docked && DoorState == FoupDoorState.Open && DoorPosition == FoupDoorPostionEnum.Down;
  900. }
  901. }
  902. public bool IsComplete { get; set; }
  903. public bool IsAccessSwPressed
  904. {
  905. get { return _isAccessSwPressed; }
  906. }
  907. public virtual bool IsError { get; set; }
  908. public virtual string ErrorCode { get; set; } = "";
  909. public bool MapError { get; protected set; }
  910. public bool ReadCarrierIDError { get; set; }
  911. /// <summary>
  912. /// 是否处于FOSB模式
  913. /// </summary>
  914. ///
  915. public virtual bool IsRequestFOSBMode
  916. {
  917. get; set;
  918. }
  919. public bool IsFosbModeActual { get; set; }
  920. public string CarrierId
  921. {
  922. get { return _carrierId; }
  923. }
  924. public string LPLotID
  925. {
  926. get { return _lplotID; }
  927. }
  928. public RD_TRIG PresentTrig
  929. {
  930. get { return _presentTrig; }
  931. }
  932. public RD_TRIG PlacedtTrig
  933. {
  934. get { return _placetTrig; }
  935. }
  936. public RD_TRIG AccessSwPressedTrig
  937. {
  938. get { return _accessSwPressedTrig; }
  939. }
  940. public RD_TRIG ClampedTrig
  941. {
  942. get { return _clampTrig; }
  943. }
  944. public RD_TRIG DockTrig
  945. {
  946. get { return _dockTrig; }
  947. }
  948. public RD_TRIG DoorTrig
  949. {
  950. get { return _doorTrig; }
  951. }
  952. protected virtual bool _isPresent { get; set; }
  953. protected virtual bool _isPlaced { get; set; }
  954. protected bool _isDocked { get => DockState == FoupDockState.Docked; }
  955. protected bool _isAccessSwPressed;
  956. protected string _carrierId = string.Empty;
  957. protected string _carrierIdToBeWrite = string.Empty;
  958. protected string _rfid;
  959. protected string _lplotID;
  960. protected bool _isMapped;
  961. private readonly RD_TRIG _presentTrig = new RD_TRIG();
  962. private readonly RD_TRIG _placetTrig = new RD_TRIG();
  963. private readonly RD_TRIG _accessSwPressedTrig = new RD_TRIG();
  964. private readonly RD_TRIG _clampTrig = new RD_TRIG();
  965. private readonly RD_TRIG _dockTrig = new RD_TRIG();
  966. private readonly RD_TRIG _doorTrig = new RD_TRIG();
  967. public R_TRIG TrigWaferProtrude = new R_TRIG();
  968. public int PortID
  969. {
  970. get => (int)LPModuleName;
  971. }
  972. protected string EventCarrierArrived = "CARRIER_ARRIVED";
  973. protected string EventCarrierIdRead = "CARRIER_ID_READ";
  974. protected string EventCarrierIdReadFailed = "CARRIER_ID_READ_FAILED";
  975. protected string EventCarrierIdWrite = "CARRIER_ID_WRITE";
  976. protected string EventCarrierIdWriteFailed = "CARRIER_ID_WRITE_FAILED";
  977. protected string EventSlotMapAvailable = "SLOT_MAP_AVAILABLE";
  978. protected string EventCarrierRemoved = "CARRIER_REMOVED";
  979. protected string EventCarrierUnloaded = "CARRIER_UNLOADED";
  980. protected string EventCarrierloaded = "CARRIR_DOCK_COMPLETE";
  981. protected string EventLPHomed = "LP_HOMED";
  982. protected string EventCarrierOpened = "CR_OPN";
  983. protected string EventCarrierClosed = "CR_CLS";
  984. protected string EventCarrierLocationChange = "CLCHG";
  985. protected string EventCarrierClamped = "CCLMP";
  986. protected string EventCarrierUnclamped = "CUCLMP";
  987. protected string EventCarrierDocked = "CDOCK";
  988. protected string EventCarrierUndocked = "CUDOCK";
  989. protected string EventCarrierIdReadFailed1 = "CIDRFAIL";
  990. protected string EventCarrierUnknowCid = "UNKNOWN_CID";
  991. protected string EventCarrierIdRead1 = "CIDREAD";
  992. protected string EventCarrierArrived1 = "CR_ARRIVE";
  993. protected string EventCarrierRemoved1 = "CR_REMOVE";
  994. protected string EventCarrierIdWrite1 = "CID_WRITE";
  995. protected string EventCarrierIdWriteFailed1 = "CID_WRITE_FAIL";
  996. protected string EventMapComplete = "CR_MAPPING_COMPLETE";
  997. protected string EventCarrierUnloaded1 = "CR_UNLOADED";
  998. protected string EventCarrierLoaded1 = "CR_LOADED";
  999. //protected string PORT_ID = "PORT_ID";
  1000. //protected string CAR_ID = "CAR_ID";
  1001. //protected string SLOT_MAP = "SLOT_MAP";
  1002. //protected string PORT_CTGRY = "PORT_CTGRY";
  1003. //protected string RF_ID = "RF_ID";
  1004. //protected string PORT_CARRIER_TYPE = "PORT_CARRIER_TYPE";
  1005. public string AlarmLoadPortError { get => LPModuleName.ToString() + "Error"; }
  1006. public string AlarmLoadPortCommunicationError { get => LPModuleName.ToString() + "CommunicationError"; }
  1007. public string AlarmLoadPortWaferProtrusion { get => LPModuleName.ToString() + "WaferProtrusion"; }
  1008. public string AlarmLoadPortLoadTimeOut { get => LPModuleName.ToString() + "LoadTimeOut"; }
  1009. public string AlarmLoadPortLoadFailed { get => LPModuleName.ToString() + "LoadFailed"; }
  1010. public string AlarmLoadPortUnloadTimeOut { get => LPModuleName.ToString() + "UnloadTimeOut"; }
  1011. public string AlarmLoadPortUnloadFailed { get => LPModuleName.ToString() + "UnloadFailed"; }
  1012. public string AlarmLoadPortMappingError { get => LPModuleName.ToString() + "MappingError"; }
  1013. public string AlarmLoadPortUnloadMappingError { get => LPModuleName.ToString() + "UnloadMappingError"; }
  1014. public string AlarmLoadPortMappingTimeout { get => LPModuleName.ToString() + "MappingTimeout"; }
  1015. public string AlarmCarrierIDReadError { get => LPModuleName.ToString() + "CarrierIDReadFail"; }
  1016. public string AlarmCarrierIDWriteError { get => LPModuleName.ToString() + "CarrierIDWriteFail"; }
  1017. public string AlarmLoadPortHomeFailed { get => LPModuleName.ToString() + "HomeFailed"; }
  1018. public string AlarmLoadPortHomeTimeout { get => LPModuleName.ToString() + "HomeTimeout"; }
  1019. public string AlarmLoadE84TP1Timeout { get => LPModuleName.ToString() + "E84LoadTP1TimeOut"; }
  1020. public string AlarmLoadE84TP2Timeout { get => LPModuleName.ToString() + "E84LoadTP2TimeOut"; }
  1021. public string AlarmLoadE84TP3Timeout { get => LPModuleName.ToString() + "E84LoadTP3TimeOut"; }
  1022. public string AlarmLoadE84TP4Timeout { get => LPModuleName.ToString() + "E84LoadTP4TimeOut"; }
  1023. public string AlarmLoadE84TP5Timeout { get => LPModuleName.ToString() + "E84LoadTP5TimeOut"; }
  1024. public string AlarmLoadE84TP6Timeout { get => LPModuleName.ToString() + "E84LoadTP6TimeOut"; }
  1025. public string AlarmUnloadE84TP1Timeout { get => LPModuleName.ToString() + "E84UnloadTP1TimeOut"; }
  1026. public string AlarmUnloadE84TP2Timeout { get => LPModuleName.ToString() + "E84UnloadTP2TimeOut"; }
  1027. public string AlarmUnloadE84TP3Timeout { get => LPModuleName.ToString() + "E84UnloadTP3TimeOut"; }
  1028. public string AlarmUnloadE84TP4Timeout { get => LPModuleName.ToString() + "E84UnloadTP4TimeOut"; }
  1029. public string AlarmUnloadE84TP5Timeout { get => LPModuleName.ToString() + "E84UnloadTP5TimeOut"; }
  1030. public string AlarmUnloadE84TP6Timeout { get => LPModuleName.ToString() + "E84UnloadTP6TimeOut"; }
  1031. public string AlarmLoadPortMapCrossedWafer => LPModuleName.ToString() + "MapCrossedWafer";
  1032. public string AlarmLoadPortMapDoubleWafer => LPModuleName.ToString() + "MapDoubleWafer";
  1033. public string AlarmLoadPortMapUnknownWafer => LPModuleName.ToString() + "MapUnknownWafer";
  1034. public string AlarmLoadPortCarrierIDIndexConfigError => LPModuleName.ToString() + "LoadPortCarrierIDIndexConfigError";
  1035. public string AlarmLoadPortUnloadMapCrossedWafer => LPModuleName.ToString() + "UnloadMapCrossedWafer";
  1036. public string AlarmLoadPortUnloadMapDoubleWafer => LPModuleName.ToString() + "UnloadMapDoubleWafer";
  1037. public string AlarmLoadPortUnloadMapUnknownWafer => LPModuleName.ToString() + "UnloadMapUnknownWafer";
  1038. private IE87CallBack _lpcallback = null;
  1039. public IE87CallBack LPCallBack
  1040. {
  1041. get { return _lpcallback; }
  1042. set { _lpcallback = value; }
  1043. }
  1044. private IE84CallBack _lpE84Callback = null;
  1045. public IE84CallBack LPE84Callback
  1046. {
  1047. get { return _lpE84Callback; }
  1048. set
  1049. {
  1050. _lpE84Callback = value;
  1051. _lpE84Callback.OnE84ActiveSignalChange += _lpE84Callback_OnE84ActiveSignalChange;
  1052. _lpE84Callback.OnE84PassiveSignalChange += _lpE84Callback_OnE84PassiveSignalChange;
  1053. _lpE84Callback.OnE84HandOffComplete += _lpE84Callback_OnE84HandOffComplete;
  1054. _lpE84Callback.OnE84HandOffStart += _lpE84Callback_OnE84HandOffStart;
  1055. _lpE84Callback.OnE84HandOffTimeout += _lpE84Callback_OnE84HandOffTimeout;
  1056. _lpE84Callback.SetLoadPortCallBack(this);
  1057. }
  1058. }
  1059. public virtual CIDReaderBaseDevice[] CIDReaders
  1060. {
  1061. get;
  1062. set;
  1063. }
  1064. public CIDReaderBaseDevice CurrentReader
  1065. {
  1066. get
  1067. {
  1068. if (CIDReaders == null) return null;
  1069. if (CIDReaders.Length > CurrentCidIndex)
  1070. return CIDReaders[CurrentCidIndex];
  1071. return null;
  1072. }
  1073. }
  1074. private RobotBaseDevice _robot = null;
  1075. public RobotBaseDevice MapRobot
  1076. {
  1077. get { return _robot; }
  1078. set { _robot = value; }
  1079. }
  1080. public LoadPortBaseDevice()
  1081. {
  1082. }
  1083. private void _lpE84Callback_OnE84PassiveSignalChange(E84SignalID arg2, bool arg3)
  1084. {
  1085. ;
  1086. }
  1087. private void _lpE84Callback_OnE84HandOffTimeout(E84Timeout _timeout, string LoadorUnload)
  1088. {
  1089. NoteTransferStop();
  1090. Thread.Sleep(100);
  1091. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  1092. if (LoadorUnload == "Load")
  1093. {
  1094. switch (_timeout)
  1095. {
  1096. case E84Timeout.TP1:
  1097. dvid = new SerializableDictionary<string, object>();
  1098. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP1 timeout";
  1099. EV.Notify(AlarmLoadE84TP1Timeout, dvid);
  1100. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP1 timeout");
  1101. break;
  1102. case E84Timeout.TP2:
  1103. dvid = new SerializableDictionary<string, object>();
  1104. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP2 timeout";
  1105. EV.Notify(AlarmLoadE84TP2Timeout, dvid);
  1106. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP2 timeout");
  1107. break;
  1108. case E84Timeout.TP3:
  1109. dvid = new SerializableDictionary<string, object>();
  1110. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP3 timeout";
  1111. EV.Notify(AlarmLoadE84TP3Timeout, dvid);
  1112. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP3 timeout");
  1113. break;
  1114. case E84Timeout.TP4:
  1115. dvid = new SerializableDictionary<string, object>();
  1116. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP4 timeout";
  1117. EV.Notify(AlarmLoadE84TP4Timeout, dvid);
  1118. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP4 timeout");
  1119. break;
  1120. case E84Timeout.TP5:
  1121. dvid = new SerializableDictionary<string, object>();
  1122. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP5 timeout";
  1123. EV.Notify(AlarmLoadE84TP5Timeout, dvid);
  1124. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Load TP5 timeout");
  1125. break;
  1126. default:
  1127. break;
  1128. }
  1129. }
  1130. if (LoadorUnload == "Unload")
  1131. {
  1132. switch (_timeout)
  1133. {
  1134. case E84Timeout.TP1:
  1135. dvid = new SerializableDictionary<string, object>();
  1136. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP1 timeout";
  1137. EV.Notify(AlarmUnloadE84TP1Timeout, dvid);
  1138. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP1 timeout");
  1139. break;
  1140. case E84Timeout.TP2:
  1141. dvid = new SerializableDictionary<string, object>();
  1142. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP2 timeout";
  1143. EV.Notify(AlarmUnloadE84TP2Timeout, dvid);
  1144. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP2 timeout");
  1145. break;
  1146. case E84Timeout.TP3:
  1147. dvid = new SerializableDictionary<string, object>();
  1148. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP3 timeout";
  1149. EV.Notify(AlarmUnloadE84TP3Timeout, dvid);
  1150. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP3 timeout");
  1151. break;
  1152. case E84Timeout.TP4:
  1153. dvid = new SerializableDictionary<string, object>();
  1154. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP4 timeout";
  1155. EV.Notify(AlarmUnloadE84TP4Timeout, dvid);
  1156. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP4 timeout");
  1157. break;
  1158. case E84Timeout.TP5:
  1159. dvid = new SerializableDictionary<string, object>();
  1160. dvid["AlarmDescription"] = $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP5 timeout";
  1161. EV.Notify(AlarmUnloadE84TP5Timeout, dvid);
  1162. EV.PostAlarmLog("LoadPort", $"{LPModuleName} with carrier:{CarrierId} occurred E84 Unload TP5 timeout");
  1163. break;
  1164. default:
  1165. break;
  1166. }
  1167. }
  1168. }
  1169. private void _lpE84Callback_OnE84HandOffStart(string arg2)
  1170. {
  1171. NoteTransferStart();
  1172. OnE84HandOffStart(arg2 == "Load");
  1173. }
  1174. private void _lpE84Callback_OnE84HandOffComplete(string arg2)
  1175. {
  1176. NoteTransferStop();
  1177. Thread.Sleep(100);
  1178. OnE84HandOffComplete(arg2 == "Load");
  1179. }
  1180. private void _lpE84Callback_OnE84ActiveSignalChange(E84SignalID arg2, bool arg3)
  1181. {
  1182. ;
  1183. }
  1184. public virtual bool Connect()
  1185. {
  1186. return true;
  1187. }
  1188. private void RegisterOperation()
  1189. {
  1190. OP.Subscribe($"{Name}.SetPreDefineWaferCount", (string cmd, object[] param) =>
  1191. {
  1192. PreDefineWaferCount = Convert.ToInt32(param[0]);
  1193. EV.PostInfoLog(Module, $"{Name} set pre define wafer count to {PreDefineWaferCount}");
  1194. return true;
  1195. });
  1196. OP.Subscribe($"{Name}.SetInfoPadIndex", (string cmd, object[] param) =>
  1197. {
  1198. int indexValue = Convert.ToInt32(param[0]);
  1199. return SetCarrierIndex(indexValue, out _);
  1200. });
  1201. OP.Subscribe($"{Name}.ReadCarrierIDByIndex", (string cmd, object[] param) =>
  1202. {
  1203. if (!ReadCarrierIDByIndex(param))
  1204. {
  1205. EV.PostWarningLog(Module, $"{Name} can not read carrier ID");
  1206. return false;
  1207. }
  1208. EV.PostInfoLog(Module, $"{Name} start read carrierID");
  1209. return true;
  1210. });
  1211. OP.Subscribe($"{Name}.WriteCarrierIDByIndex", (string cmd, object[] param) =>
  1212. {
  1213. if (!WriteCarrierIDByIndex(param))
  1214. {
  1215. EV.PostWarningLog(Module, $"{Name} can not write carrier ID");
  1216. return false;
  1217. }
  1218. EV.PostInfoLog(Module, $"{Name} start write carrierID");
  1219. return true;
  1220. });
  1221. OP.Subscribe($"{Name}.ReadCarrierID", (string cmd, object[] param) =>
  1222. {
  1223. if (!ReadCarrierID(param))
  1224. {
  1225. EV.PostWarningLog(Module, $"{Name} can not read carrier ID");
  1226. return false;
  1227. }
  1228. EV.PostInfoLog(Module, $"{Name} start read carrierID");
  1229. return true;
  1230. });
  1231. OP.Subscribe($"{Name}.ReadCarrierIDByLP", (string cmd, object[] param) =>
  1232. {
  1233. string reason;
  1234. if (!ReadCarrierIDByLP(param, out reason))
  1235. {
  1236. EV.PostWarningLog(Module, $"{Name} can not read carrier ID:{reason}");
  1237. return false;
  1238. }
  1239. EV.PostInfoLog(Module, $"{Name} start read carrierID");
  1240. return true;
  1241. });
  1242. OP.Subscribe($"{Name}.LoadportHome", (string cmd, object[] param) =>
  1243. {
  1244. if (!Home(out string reason))
  1245. {
  1246. EV.PostWarningLog(Module, $"{Name} can not start home, {reason}");
  1247. return false;
  1248. }
  1249. EV.PostInfoLog(Module, $"{Name} start home");
  1250. return true;
  1251. });
  1252. OP.Subscribe($"{Name}.LoadportHomeModule", (string cmd, object[] param) =>
  1253. {
  1254. if (!HomeModule(out string reason))
  1255. {
  1256. EV.PostWarningLog(Module, $"{Name} can not start home, {reason}");
  1257. return false;
  1258. }
  1259. EV.PostInfoLog(Module, $"{Name} start home");
  1260. return true;
  1261. });
  1262. OP.Subscribe($"{Name}.LoadportReset", (string cmd, object[] param) =>
  1263. {
  1264. if (!LoadportReset(out string reason))
  1265. {
  1266. EV.PostWarningLog(Module, $"{Name} can not reset, {reason}");
  1267. return false;
  1268. }
  1269. EV.PostInfoLog(Module, $"{Name} start reset");
  1270. return true;
  1271. });
  1272. OP.Subscribe($"{Name}.LoadportStop", (string cmd, object[] param) =>
  1273. {
  1274. if (!Stop(out string reason))
  1275. {
  1276. EV.PostWarningLog(Module, $"{Name} can not stop, {reason}");
  1277. return false;
  1278. }
  1279. EV.PostInfoLog(Module, $"{Name} stop");
  1280. return true;
  1281. });
  1282. OP.Subscribe($"{Name}.LoadportLoad", (string cmd, object[] param) =>
  1283. {
  1284. if (!Load(out string reason))
  1285. {
  1286. EV.PostWarningLog(Module, $"{Name} can not load, {reason}");
  1287. return false;
  1288. }
  1289. EV.PostInfoLog(Module, $"{Name} start load");
  1290. return true;
  1291. });
  1292. OP.Subscribe($"{Name}.LoadportLoadWithoutMap", (string cmd, object[] param) =>
  1293. {
  1294. if (!LoadWithoutMap(out string reason))
  1295. {
  1296. EV.PostWarningLog(Module, $"{Name} can not load without map, {reason}");
  1297. return false;
  1298. }
  1299. EV.PostInfoLog(Module, $"{Name} start load without map");
  1300. return true;
  1301. });
  1302. OP.Subscribe($"{Name}.LoadportLoadWithMap", (string cmd, object[] param) =>
  1303. {
  1304. if (!Load(out string reason))
  1305. {
  1306. EV.PostWarningLog(Module, $"{Name} can not load with map, {reason}");
  1307. return false;
  1308. }
  1309. EV.PostInfoLog(Module, $"{Name} start load with map");
  1310. return true;
  1311. });
  1312. OP.Subscribe($"{Name}.LoadportUnload", (string cmd, object[] param) =>
  1313. {
  1314. if (!Unload(out string reason))
  1315. {
  1316. EV.PostWarningLog(Module, $"{Name} can not unload, {reason}");
  1317. return false;
  1318. }
  1319. EV.PostInfoLog(Module, $"{Name} start unload");
  1320. return true;
  1321. });
  1322. OP.Subscribe($"{Name}.LoadportUnloadWithMap", (string cmd, object[] param) =>
  1323. {
  1324. if (!UnloadWithMap(out string reason))
  1325. {
  1326. EV.PostWarningLog(Module, $"{Name} can not unload, {reason}");
  1327. return false;
  1328. }
  1329. EV.PostInfoLog(Module, $"{Name} start unload");
  1330. return true;
  1331. });
  1332. OP.Subscribe($"{Name}.LoadportClamp", (string cmd, object[] param) =>
  1333. {
  1334. if (!Clamp(out string reason))
  1335. {
  1336. EV.PostWarningLog(Module, $"{Name} can not clamp, {reason}");
  1337. return false;
  1338. }
  1339. EV.PostInfoLog(Module, $"{Name} start clamp");
  1340. return true;
  1341. });
  1342. OP.Subscribe($"{Name}.LoadportUnclamp", (string cmd, object[] param) =>
  1343. {
  1344. if (!Unclamp(out string reason))
  1345. {
  1346. EV.PostWarningLog(Module, $"{Name} can not unclamp, {reason}");
  1347. return false;
  1348. }
  1349. EV.PostInfoLog(Module, $"{Name} start unclamp");
  1350. return true;
  1351. });
  1352. OP.Subscribe($"{Name}.LoadportOpenDoor", (string cmd, object[] param) =>
  1353. {
  1354. if (!OpenDoor(out string reason))
  1355. {
  1356. EV.PostWarningLog(Module, $"{Name} can not open door, {reason}");
  1357. return false;
  1358. }
  1359. EV.PostInfoLog(Module, $"{Name} start open door");
  1360. return true;
  1361. });
  1362. OP.Subscribe($"{Name}.LoadportOpenDoorNoMap", (string cmd, object[] param) =>
  1363. {
  1364. if (!OpenDoorNoMap(out string reason))
  1365. {
  1366. EV.PostWarningLog(Module, $"{Name} can not open door, {reason}");
  1367. return false;
  1368. }
  1369. EV.PostInfoLog(Module, $"{Name} start open door");
  1370. return true;
  1371. });
  1372. OP.Subscribe($"{Name}.LoadportCloseDoor", (string cmd, object[] param) =>
  1373. {
  1374. if (!CloseDoor(out string reason))
  1375. {
  1376. EV.PostWarningLog(Module, $"{Name} can not close door, {reason}");
  1377. return false;
  1378. }
  1379. EV.PostInfoLog(Module, $"{Name} start close door");
  1380. return true;
  1381. });
  1382. OP.Subscribe($"{Name}.LoadportDock", (string cmd, object[] param) =>
  1383. {
  1384. if (!Dock(out string reason))
  1385. {
  1386. EV.PostWarningLog(Module, $"{Name} can not dock, {reason}");
  1387. return false;
  1388. }
  1389. EV.PostInfoLog(Module, $"{Name} start dock");
  1390. return true;
  1391. });
  1392. OP.Subscribe($"{Name}.LoadportUndock", (string cmd, object[] param) =>
  1393. {
  1394. if (!Undock(out string reason))
  1395. {
  1396. EV.PostWarningLog(Module, $"{Name} can not undock, {reason}");
  1397. return false;
  1398. }
  1399. EV.PostInfoLog(Module, $"{Name} start undock");
  1400. return true;
  1401. });
  1402. OP.Subscribe($"{Name}.LoadportQueryState", (string cmd, object[] param) =>
  1403. {
  1404. if (!QueryState(out string reason))
  1405. {
  1406. EV.PostWarningLog(Module, $"{Name} can not query state, {reason}");
  1407. return false;
  1408. }
  1409. EV.PostInfoLog(Module, $"{Name} start query state");
  1410. return true;
  1411. });
  1412. OP.Subscribe($"{Name}.LoadportQueryLED", (string cmd, object[] param) =>
  1413. {
  1414. if (!QueryIndicator(out string reason))
  1415. {
  1416. EV.PostWarningLog(Module, $"{Name} can not query led state, {reason}");
  1417. return false;
  1418. }
  1419. EV.PostInfoLog(Module, $"{Name} start query led state");
  1420. return true;
  1421. });
  1422. OP.Subscribe($"{Name}.LoadportSetLED", (string cmd, object[] param) =>
  1423. {
  1424. int light = (int)param[0];
  1425. int state = (int)param[1];
  1426. if (!SetIndicator((Indicator)light, (IndicatorState)state, out string reason))
  1427. {
  1428. EV.PostWarningLog(Module, $"{Name} can not set led state, {reason}");
  1429. return true;
  1430. }
  1431. EV.PostInfoLog(Module, $"{Name} start set led state");
  1432. return true;
  1433. });
  1434. OP.Subscribe($"{Name}.LoadportMap", (string cmd, object[] param) =>
  1435. {
  1436. if (!LoadPortMap(out string reason))
  1437. {
  1438. EV.PostWarningLog(Module, $"{Name} can not start loadport map, {reason}");
  1439. return false;
  1440. }
  1441. EV.PostInfoLog(Module, $"{Name} start loadport map");
  1442. return true;
  1443. });
  1444. OP.Subscribe($"{Name}.MapWafer", (string cmd, object[] param) =>
  1445. {
  1446. if (!MapWafer(out string reason))
  1447. {
  1448. EV.PostWarningLog(Module, $"{Name} can not map, {reason}");
  1449. return false;
  1450. }
  1451. EV.PostInfoLog(Module, $"{Name} start map");
  1452. return true;
  1453. });
  1454. OP.Subscribe($"{Name}.SetCassetteType", (string cmd, object[] param) =>
  1455. {
  1456. if (!SetCassetteType(param, out string reason))
  1457. {
  1458. EV.PostWarningLog(Module, $"{Name} can not set type, {reason}");
  1459. return false;
  1460. }
  1461. EV.PostInfoLog(Module, $"{Name} cassette type have set to {CasstleType}");
  1462. return true;
  1463. });
  1464. OP.Subscribe($"{Name}.LoadportForceHome", (string cmd, object[] param) =>
  1465. {
  1466. if (!ForceHome(out string reason))
  1467. {
  1468. EV.PostWarningLog(Module, $"{Name} can not start force home, {reason}");
  1469. return false;
  1470. }
  1471. EV.PostInfoLog(Module, $"{Name} start force home");
  1472. return true;
  1473. });
  1474. OP.Subscribe($"{Name}.LoadportFOSBMode", (string cmd, object[] param) =>
  1475. {
  1476. if (!FOSBMode(out string reason))
  1477. {
  1478. EV.PostWarningLog(Module, $"{Name} can not change to FOSB mode, {reason}");
  1479. return false;
  1480. }
  1481. EV.PostInfoLog(Module, $"{Name} changed to FOSB mode");
  1482. return true;
  1483. });
  1484. OP.Subscribe($"{Name}.LoadportFOUPMode", (string cmd, object[] param) =>
  1485. {
  1486. if (!FOUPMode(out string reason))
  1487. {
  1488. EV.PostWarningLog(Module, $"{Name} can not change to FOSB mode, {reason}");
  1489. return false;
  1490. }
  1491. EV.PostInfoLog(Module, $"{Name} changed to FOSB mode");
  1492. return true;
  1493. });
  1494. OP.Subscribe($"{Name}.LoadportQueryFOSBMode", (string cmd, object[] param) =>
  1495. {
  1496. if (!QueryFOSBMode(out string reason))
  1497. {
  1498. EV.PostWarningLog(Module, $"{Name} can not change to FOUP mode, {reason}");
  1499. return false;
  1500. }
  1501. EV.PostInfoLog(Module, $"{Name} changed to FOSB mode");
  1502. return true;
  1503. });
  1504. OP.Subscribe($"{Name}.SetLoadportLotID", (string cmd, object[] param) =>
  1505. {
  1506. if (!SetLotID(param, out string reason))
  1507. {
  1508. return false;
  1509. }
  1510. EV.PostInfoLog(Module, $"{Name} set lotID for loadport.");
  1511. return true;
  1512. });
  1513. OP.Subscribe($"{Name}.LoadportExecuteCommand", (string cmd, object[] param) =>
  1514. {
  1515. if (!LoadPortExecute(param, out string reason))
  1516. {
  1517. return false;
  1518. }
  1519. EV.PostInfoLog(Module, $"{Name} execute command {cmd[0].ToString()}.");
  1520. return true;
  1521. });
  1522. OP.Subscribe($"{Name}.E84Retry", (string cmd, object[] param) =>
  1523. {
  1524. if (!LoadPortE84Retry(param, out string reason))
  1525. {
  1526. return false;
  1527. }
  1528. EV.PostInfoLog(Module, $"{Name} execute command {cmd[0].ToString()}.");
  1529. return true;
  1530. });
  1531. OP.Subscribe($"{Name}.E84Complete", (string cmd, object[] param) =>
  1532. {
  1533. if (!LoadPortE84Complete(param, out string reason))
  1534. {
  1535. return false;
  1536. }
  1537. EV.PostInfoLog(Module, $"{Name} execute command {cmd[0].ToString()}.");
  1538. return true;
  1539. });
  1540. OP.Subscribe($"{Name}.ManualSetCarrierID", (string cmd, object[] param) =>
  1541. {
  1542. OnCarrierIdRead(param[0].ToString());
  1543. EV.PostInfoLog(Module, $"{Name} execute command {cmd[0].ToString()}.");
  1544. return true;
  1545. });
  1546. }
  1547. public virtual bool LoadPortE84Complete(object[] param, out string reason)
  1548. {
  1549. if (_lpE84Callback != null)
  1550. {
  1551. _lpE84Callback.Complete();
  1552. }
  1553. reason = "";
  1554. return true;
  1555. }
  1556. public virtual bool LoadPortE84Retry(object[] param, out string reason)
  1557. {
  1558. if (_lpE84Callback != null)
  1559. {
  1560. _lpE84Callback.ResetE84();
  1561. }
  1562. reason = "";
  1563. return true;
  1564. }
  1565. private bool LoadPortMap(out string reason)
  1566. {
  1567. reason = "";
  1568. if (!IsMapWaferByLoadPort)
  1569. {
  1570. if (_robot == null)
  1571. {
  1572. reason = "No mapping tools";
  1573. return false;
  1574. }
  1575. if (!_robot.IsReady())
  1576. {
  1577. reason = "Robot not ready";
  1578. return false;
  1579. }
  1580. if (!IsEnableMapWafer(out reason))
  1581. {
  1582. EV.PostAlarmLog("System", $"{LPModuleName} with carrier:{CarrierId} is not ready:{reason}.");
  1583. return false;
  1584. }
  1585. return _robot.WaferMapping(LPModuleName, out reason);
  1586. }
  1587. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "MapWafer" });
  1588. if (!ret)
  1589. {
  1590. reason = $"Can't execute on {CurrentState}";
  1591. return false;
  1592. }
  1593. return true;
  1594. }
  1595. public bool LoadPortExecute(object[] para, out string reason)
  1596. {
  1597. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, para);
  1598. if (!ret)
  1599. {
  1600. reason = $"Can't execute on {CurrentState}";
  1601. return false;
  1602. }
  1603. reason = "";
  1604. return true;
  1605. }
  1606. public bool LoadportReset(out string reason)
  1607. {
  1608. reason = "";
  1609. return CheckToPostMessage((int)LoadPortMsg.Reset, null);
  1610. }
  1611. public bool SetLotID(object[] param, out string reason)
  1612. {
  1613. reason = "";
  1614. if (param == null || param.Length == 0) return false;
  1615. _lplotID = param[0].ToString();
  1616. return true;
  1617. }
  1618. private bool SetCassetteType(object[] param, out string reason)
  1619. {
  1620. reason = "";
  1621. if (param.Length != 1)
  1622. {
  1623. reason = "Invalid setting parameter.";
  1624. return false;
  1625. }
  1626. CasstleType = (CasstleType)int.Parse(param[0].ToString());
  1627. return true;
  1628. }
  1629. public virtual int ValidSlotsNumber
  1630. {
  1631. get
  1632. {
  1633. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CarrierSlotsNumber"))
  1634. return SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CarrierSlotsNumber");
  1635. return ValidEndSlotIndex - ValidStartSlotIndex + 1;
  1636. }
  1637. }
  1638. public virtual int ValidStartSlotIndex
  1639. {
  1640. get
  1641. {
  1642. if (SC.ContainsItem($"LoadPort.{LPModuleName}.ValidStartSlot"))
  1643. return SC.GetValue<int>($"LoadPort.{LPModuleName}.ValidStartSlot") - 1;
  1644. return 0;
  1645. }
  1646. }
  1647. public virtual int ValidEndSlotIndex
  1648. {
  1649. get
  1650. {
  1651. if (SC.ContainsItem($"LoadPort.{LPModuleName}.ValidEndSlot"))
  1652. return SC.GetValue<int>($"LoadPort.{LPModuleName}.ValidEndSlot") - 1;
  1653. if (SC.ContainsItem($"LoadPort.{LPModuleName}.ValidSlotNumber"))
  1654. return SC.GetValue<int>($"LoadPort.{LPModuleName}.ValidSlotNumber") + ValidStartSlotIndex - 1;
  1655. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CarrierSlotsNumber"))
  1656. {
  1657. return ValidStartSlotIndex + ValidSlotsNumber - 1;
  1658. }
  1659. return 24;
  1660. }
  1661. }
  1662. public virtual bool Load(out string reason)
  1663. {
  1664. if (!IsEnableLoad(out reason))
  1665. {
  1666. EV.PostAlarmLog("LoadPort", $"Can't execute load command due to {reason}");
  1667. if (reason == "CarrierNotEnabled")
  1668. EV.Notify($"{LPModuleName}CarrierNotEnabled");
  1669. return false;
  1670. }
  1671. reason = "";
  1672. bool ret;
  1673. if (IsMapWaferByLoadPort)
  1674. ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithMap" });
  1675. else
  1676. ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithoutMap" });
  1677. if (!ret)
  1678. {
  1679. reason = $"Can't execute on {CurrentState}";
  1680. return false;
  1681. }
  1682. return true;
  1683. }
  1684. public virtual bool LoadWithCloseDoor(out string reason)
  1685. {
  1686. if (!IsEnableLoad(out reason))
  1687. return false;
  1688. reason = "";
  1689. bool ret;
  1690. if (IsMapWaferByLoadPort)
  1691. ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithCloseDoor" });
  1692. else
  1693. ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithoutMapWithCloseDoor" });
  1694. if (!ret)
  1695. {
  1696. reason = $"Can't execute on {CurrentState}";
  1697. return false;
  1698. }
  1699. return true;
  1700. }
  1701. public virtual bool LoadWithMap(out string reason)
  1702. {
  1703. if (!IsEnableLoad(out reason))
  1704. return false;
  1705. reason = "";
  1706. bool ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithMap" });
  1707. if (!ret)
  1708. {
  1709. reason = $"Can't execute on {CurrentState}";
  1710. return false;
  1711. }
  1712. return true;
  1713. }
  1714. public virtual bool LoadWithoutMap(out string reason)
  1715. {
  1716. if (!IsEnableLoad(out reason))
  1717. return false;
  1718. reason = "";
  1719. bool ret = CheckToPostMessage((int)LoadPortMsg.Load, new object[] { "LoadWithoutMap" });
  1720. if (!ret)
  1721. {
  1722. reason = $"Can't execute on {CurrentState}";
  1723. return false;
  1724. }
  1725. return true;
  1726. }
  1727. public virtual bool MapWafer(out string reason)
  1728. {
  1729. reason = "";
  1730. if (!IsEnableMapWafer(out reason))
  1731. {
  1732. EV.PostAlarmLog("System", $"{LPModuleName} with carrier:{CarrierId} is not ready:{reason}.");
  1733. return false;
  1734. }
  1735. if (!IsMapWaferByLoadPort)
  1736. {
  1737. if (_robot == null)
  1738. {
  1739. reason = "No mapping tools";
  1740. EV.PostAlarmLog("System", $"{LPModuleName} with carrier:{CarrierId} is not ready:{reason}.");
  1741. return false;
  1742. }
  1743. if (!_robot.IsReady())
  1744. {
  1745. reason = "Robot not ready";
  1746. EV.PostAlarmLog("System", $"{LPModuleName} with carrier:{CarrierId} is not ready:{reason}.");
  1747. return false;
  1748. }
  1749. return _robot.WaferMapping(LPModuleName, out reason);
  1750. }
  1751. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "MapWafer" });
  1752. if (!ret)
  1753. {
  1754. reason = $"Can't execute on {CurrentState}";
  1755. return false;
  1756. }
  1757. return true;
  1758. }
  1759. public virtual bool QueryWaferMap(out string reason)
  1760. {
  1761. reason = "";
  1762. bool ret = CheckToPostMessage((int)LoadPortMsg.StartReadData, new object[] { "MapData" });
  1763. if (!ret)
  1764. {
  1765. reason = $"Can't execute on {CurrentState}";
  1766. return false;
  1767. }
  1768. return true;
  1769. }
  1770. public virtual bool QueryFOSBMode(out string reason)
  1771. {
  1772. reason = "";
  1773. bool ret = CheckToPostMessage((int)LoadPortMsg.StartReadData, new object[] { "FOSBMode" });
  1774. if (!ret)
  1775. {
  1776. reason = $"Can't execute on {CurrentState}";
  1777. return false;
  1778. }
  1779. return true;
  1780. }
  1781. public virtual bool QueryCarrierID(out string reason)
  1782. {
  1783. reason = "";
  1784. bool ret = CheckToPostMessage((int)LoadPortMsg.StartReadData, new object[] { "CarrierID" });
  1785. if (!ret)
  1786. {
  1787. reason = $"Can't execute on {CurrentState}";
  1788. return false;
  1789. }
  1790. return true;
  1791. }
  1792. /// <summary>
  1793. /// FOSB模式下的Dock指令
  1794. /// </summary>
  1795. /// <param name="reason"></param>
  1796. /// <returns></returns>
  1797. public virtual bool FOSBDock(out string reason)
  1798. {
  1799. reason = "";
  1800. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "Dock" });
  1801. if (!ret)
  1802. {
  1803. reason = $"Can't execute on {CurrentState}";
  1804. return false;
  1805. }
  1806. return true;
  1807. }
  1808. /// <summary>
  1809. /// FOSB模式下的FOSBUnDock指令
  1810. /// </summary>
  1811. /// <param name="reason"></param>
  1812. /// <returns></returns>
  1813. public virtual bool FOSBUnDock(out string reason)
  1814. {
  1815. reason = "";
  1816. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "UnDock" });
  1817. if (!ret)
  1818. {
  1819. reason = $"Can't execute on {CurrentState}";
  1820. return false;
  1821. }
  1822. return true;
  1823. }
  1824. /// <summary>
  1825. /// FOSB模式下的开门指令
  1826. /// </summary>
  1827. /// <param name="reason"></param>
  1828. /// <returns></returns>
  1829. public virtual bool FOSBDoorOpen(out string reason)
  1830. {
  1831. reason = "";
  1832. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "FOSBDoorOpen" });
  1833. if (!ret)
  1834. {
  1835. reason = $"Can't execute on {CurrentState}";
  1836. return false;
  1837. }
  1838. return true;
  1839. }
  1840. /// <summary>
  1841. /// FOSB模式下的关门指令
  1842. /// </summary>
  1843. /// <param name="reason"></param>
  1844. /// <returns></returns>
  1845. public virtual bool FOSBDoorClose(out string reason)
  1846. {
  1847. reason = "";
  1848. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "FOSBDoorClose" });
  1849. if (!ret)
  1850. {
  1851. reason = $"Can't execute on {CurrentState}";
  1852. return false;
  1853. }
  1854. return true;
  1855. }
  1856. /// <summary>
  1857. /// FOSB模式下的门下移指令
  1858. /// </summary>
  1859. /// <param name="reason"></param>
  1860. /// <returns></returns>
  1861. public virtual bool DoorDown(out string reason)
  1862. {
  1863. reason = "";
  1864. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "DoorDown" });
  1865. if (!ret)
  1866. {
  1867. reason = $"Can't execute on {CurrentState}";
  1868. return false;
  1869. }
  1870. return true;
  1871. }
  1872. /// <summary>
  1873. /// FOSB模式下的门上移指令
  1874. /// </summary>
  1875. /// <param name="reason"></param>
  1876. /// <returns></returns>
  1877. public virtual bool DoorUp(out string reason)
  1878. {
  1879. reason = "";
  1880. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "DoorUp" });
  1881. if (!ret)
  1882. {
  1883. reason = $"Can't execute on {CurrentState}";
  1884. return false;
  1885. }
  1886. return true;
  1887. }
  1888. public virtual bool SetIndicator(IndicatorType light, IndicatorState state)
  1889. {
  1890. if (LoadPortIndicatorLightMap.ContainsKey(light))
  1891. {
  1892. SetIndicator(LoadPortIndicatorLightMap[light], state, out string _);
  1893. return true;
  1894. }
  1895. //EV.PostWarningLog(Module, $"Not supported indicator {light}");
  1896. return false;
  1897. }
  1898. public IndicatorState GetIndicator(IndicatorType light)
  1899. {
  1900. if (LoadPortIndicatorLightMap.ContainsKey(light))
  1901. {
  1902. return IndicatorStateFeedback[(int)LoadPortIndicatorLightMap[light]];
  1903. }
  1904. //EV.PostWarningLog(Module, $"Not supported indicator {light}");
  1905. return IndicatorState.OFF;
  1906. }
  1907. public virtual bool SetE84Available(out string reason)
  1908. {
  1909. //IsAccessAuto = true;
  1910. if (_lpE84Callback != null)
  1911. {
  1912. _lpE84Callback.SetHoAutoControl(false);
  1913. _lpE84Callback.SetHoAvailable(true);
  1914. }
  1915. reason = "";
  1916. return true;
  1917. }
  1918. public virtual bool SetE84Unavailable(out string reason)
  1919. {
  1920. //IsAccessAuto = false;
  1921. if (_lpE84Callback != null)
  1922. {
  1923. _lpE84Callback.SetHoAutoControl(false);
  1924. _lpE84Callback.SetHoAvailable(false);
  1925. }
  1926. reason = "";
  1927. return true;
  1928. }
  1929. public virtual bool SetIndicator(Indicator light, IndicatorState state, out string reason)
  1930. {
  1931. reason = "";
  1932. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "SetIndicator", light, state });
  1933. if (!ret)
  1934. {
  1935. reason = $"Can't execute on {CurrentState}";
  1936. }
  1937. return ret;
  1938. }
  1939. public virtual bool QueryIndicator(out string reason)
  1940. {
  1941. reason = "";
  1942. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "QueryIndicator" });
  1943. if (!ret)
  1944. {
  1945. reason = $"Can't execute on {CurrentState}";
  1946. }
  1947. return ret;
  1948. }
  1949. public virtual bool QueryState(out string reason)
  1950. {
  1951. reason = "";
  1952. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "QueryState" });
  1953. if (!ret)
  1954. {
  1955. reason = $"Can't execute on {CurrentState}";
  1956. }
  1957. return ret;
  1958. }
  1959. public virtual bool Undock(out string reason)
  1960. {
  1961. reason = "";
  1962. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "Undock" });
  1963. if (!ret)
  1964. {
  1965. reason = $"Can't execute on {CurrentState}";
  1966. }
  1967. return ret;
  1968. }
  1969. public virtual bool Dock(out string reason)
  1970. {
  1971. reason = "";
  1972. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "Dock" });
  1973. if (!ret)
  1974. {
  1975. reason = $"Can't execute on {CurrentState}";
  1976. }
  1977. return ret;
  1978. }
  1979. public virtual bool CloseDoor(out string reason)
  1980. {
  1981. reason = "";
  1982. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "CloseDoor" });
  1983. if (!ret)
  1984. {
  1985. reason = $"Can't execute on {CurrentState}";
  1986. }
  1987. return ret;
  1988. }
  1989. public virtual bool OpenDoor(out string reason)
  1990. {
  1991. reason = "";
  1992. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "OpenDoor" });
  1993. if (!ret)
  1994. {
  1995. reason = $"Can't execute on {CurrentState}";
  1996. }
  1997. return ret;
  1998. }
  1999. public virtual bool OpenDoorAndDown(out string reason)
  2000. {
  2001. reason = "";
  2002. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "OpenDoorAndDown" });
  2003. if (!ret)
  2004. {
  2005. reason = $"Can't execute on {CurrentState}";
  2006. }
  2007. return ret;
  2008. }
  2009. public virtual bool DoorUpAndClose(out string reason)
  2010. {
  2011. reason = "";
  2012. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "DoorUpAndClose" });
  2013. if (!ret)
  2014. {
  2015. reason = $"Can't execute on {CurrentState}";
  2016. }
  2017. return ret;
  2018. }
  2019. public virtual bool OpenDoorNoMap(out string reason)
  2020. {
  2021. reason = "";
  2022. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "OpenDoorNoMap" });
  2023. if (!ret)
  2024. {
  2025. reason = $"Can't execute on {CurrentState}";
  2026. }
  2027. return ret;
  2028. }
  2029. public virtual bool OpenDoorAndMap(out string reason)
  2030. {
  2031. reason = "";
  2032. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "OpenDoorAndMap" });
  2033. if (!ret)
  2034. {
  2035. reason = $"Can't execute on {CurrentState}";
  2036. }
  2037. return ret;
  2038. }
  2039. public virtual bool Unclamp(out string reason)
  2040. {
  2041. reason = "";
  2042. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "Unclamp" });
  2043. if (!ret)
  2044. {
  2045. reason = $"Can't execute on {CurrentState}";
  2046. }
  2047. return ret;
  2048. }
  2049. public virtual bool Clamp(out string reason)
  2050. {
  2051. reason = "";
  2052. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "Clamp" });
  2053. if (!ret)
  2054. {
  2055. reason = $"Can't execute on {CurrentState}";
  2056. }
  2057. return ret;
  2058. }
  2059. public virtual bool Unload(out string reason)
  2060. {
  2061. reason = "";
  2062. if (!IsEnableUnload(out reason))
  2063. return false;
  2064. bool ret = CheckToPostMessage((int)LoadPortMsg.Unload);
  2065. if (!ret)
  2066. {
  2067. reason = $"Can't execute on {CurrentState}";
  2068. }
  2069. return ret;
  2070. }
  2071. public virtual bool UnloadWithMap(out string reason)
  2072. {
  2073. reason = "";
  2074. if (!IsEnableUnload(out reason))
  2075. return false;
  2076. bool ret = CheckToPostMessage((int)LoadPortMsg.Unload, "UnloadWithMap");
  2077. if (!ret)
  2078. {
  2079. reason = $"Can't execute on {CurrentState}";
  2080. }
  2081. return ret;
  2082. }
  2083. public virtual bool Stop(out string reason)
  2084. {
  2085. reason = "";
  2086. bool ret = CheckToPostMessage((int)LoadPortMsg.Abort, null);
  2087. if (!ret)
  2088. {
  2089. reason = $"Can't execute on {CurrentState}";
  2090. }
  2091. return ret;
  2092. }
  2093. public virtual bool ClearError(out string reason)
  2094. {
  2095. reason = "";
  2096. return true;
  2097. }
  2098. public virtual bool Init(out string reason)
  2099. {
  2100. reason = "";
  2101. bool ret = CheckToPostMessage((int)LoadPortMsg.Init, new object[] { "Init" });
  2102. if (!ret)
  2103. {
  2104. reason = $"Can't execute on {CurrentState}";
  2105. }
  2106. return ret;
  2107. }
  2108. public virtual bool Home(out string reason)
  2109. {
  2110. IsHomed = false;
  2111. reason = "";
  2112. bool ret = CheckToPostMessage((int)LoadPortMsg.Init, new object[] { "Home" });
  2113. if (!ret)
  2114. {
  2115. reason = $"Can't execute on {CurrentState}";
  2116. }
  2117. return ret;
  2118. }
  2119. public virtual bool HomeModule(out string reason)
  2120. {
  2121. reason = "";
  2122. bool ret = CheckToPostMessage((int)LoadPortMsg.StartHome, new object[] { "Home" });
  2123. if (!ret)
  2124. {
  2125. reason = $"Can't execute on {CurrentState}";
  2126. }
  2127. return ret;
  2128. }
  2129. public virtual bool ForceHome(out string reason)
  2130. {
  2131. reason = "";
  2132. bool ret = CheckToPostMessage((int)LoadPortMsg.Init, new object[] { "ForceHome" });
  2133. if (!ret)
  2134. {
  2135. reason = $"Can't execute on {CurrentState}";
  2136. }
  2137. return ret;
  2138. }
  2139. public virtual bool FOSBMode(out string reason)
  2140. {
  2141. reason = "";
  2142. return true;
  2143. }
  2144. public virtual bool FOUPMode(out string reason)
  2145. {
  2146. reason = "";
  2147. return true;
  2148. }
  2149. public virtual bool ReadCarrierIDByLP(object[] para, out string reason)
  2150. {
  2151. reason = "";
  2152. if (para != null && para.Length == 2)
  2153. return ReadCarrierIDByLP(Convert.ToInt32(para[0]), Convert.ToInt32(para[1]), out reason);
  2154. return
  2155. ReadCarrierIDByLP(0, 8, out reason);
  2156. }
  2157. public virtual bool ReadCarrierIDByLP(int offset, int length, out string reason)
  2158. {
  2159. reason = "";
  2160. bool ret = CheckToPostMessage((int)LoadPortMsg.StartExecute, new object[] { "ReadCarrierID", offset, length });
  2161. if (!ret)
  2162. {
  2163. reason = $"Can't execute on {CurrentState}";
  2164. }
  2165. return ret;
  2166. }
  2167. public virtual bool ChangeAccessMode(bool auto, out string reason)
  2168. {
  2169. if (auto)
  2170. {
  2171. IsAccessAuto = true;
  2172. if (_lpE84Callback != null)
  2173. {
  2174. _lpE84Callback.SetHoAutoControl(false);
  2175. _lpE84Callback.SetHoAvailable(true);
  2176. }
  2177. SetIndicator(IndicatorType.AccessAuto, IndicatorState.ON);
  2178. SetIndicator(IndicatorType.AccessManual, IndicatorState.OFF);
  2179. }
  2180. else
  2181. {
  2182. IsAccessAuto = false;
  2183. if (_lpE84Callback != null)
  2184. {
  2185. _lpE84Callback.SetHoAutoControl(false);
  2186. _lpE84Callback.SetHoAvailable(false);
  2187. }
  2188. SetIndicator(IndicatorType.AccessManual, IndicatorState.ON);
  2189. SetIndicator(IndicatorType.AccessAuto, IndicatorState.OFF);
  2190. }
  2191. reason = "";
  2192. return true;
  2193. }
  2194. public virtual bool SetServiceCommand(bool inService, out string reason)
  2195. {
  2196. reason = "";
  2197. return true;
  2198. }
  2199. public virtual bool GetE84HandoffActiveSignalState(E84PioPosition piopostion, E84PioSignalAtoP AtoPsignal)
  2200. {
  2201. if (_lpE84Callback == null) return false;
  2202. switch (AtoPsignal)
  2203. {
  2204. case E84PioSignalAtoP.AM_AVBL:
  2205. return _lpE84Callback.GetE84SignalState(E84SignalID.AM_AVBL);
  2206. case E84PioSignalAtoP.BUSY:
  2207. return _lpE84Callback.GetE84SignalState(E84SignalID.BUSY);
  2208. case E84PioSignalAtoP.COMPT:
  2209. return _lpE84Callback.GetE84SignalState(E84SignalID.COMPT);
  2210. case E84PioSignalAtoP.CONT:
  2211. return _lpE84Callback.GetE84SignalState(E84SignalID.CONT);
  2212. case E84PioSignalAtoP.CS_0:
  2213. return _lpE84Callback.GetE84SignalState(E84SignalID.CS_0);
  2214. case E84PioSignalAtoP.CS_1:
  2215. return _lpE84Callback.GetE84SignalState(E84SignalID.CS_1);
  2216. case E84PioSignalAtoP.TR_REQ:
  2217. return _lpE84Callback.GetE84SignalState(E84SignalID.TR_REQ);
  2218. case E84PioSignalAtoP.VALID:
  2219. return _lpE84Callback.GetE84SignalState(E84SignalID.VALID);
  2220. default:
  2221. return false;
  2222. }
  2223. }
  2224. public virtual bool GetE84HandoffPassiveSignalState(E84PioPosition piopostion, E84PioSignalPtoA PtoAsignal)
  2225. {
  2226. if (_lpE84Callback == null) return false;
  2227. switch (PtoAsignal)
  2228. {
  2229. case E84PioSignalPtoA.ES:
  2230. return _lpE84Callback.GetE84SignalState(E84SignalID.ES);
  2231. case E84PioSignalPtoA.HO_AVBL:
  2232. return _lpE84Callback.GetE84SignalState(E84SignalID.HO_AVBL);
  2233. case E84PioSignalPtoA.L_REQ:
  2234. return _lpE84Callback.GetE84SignalState(E84SignalID.L_REQ);
  2235. case E84PioSignalPtoA.READY:
  2236. return _lpE84Callback.GetE84SignalState(E84SignalID.READY);
  2237. case E84PioSignalPtoA.U_REQ:
  2238. return _lpE84Callback.GetE84SignalState(E84SignalID.U_REQ);
  2239. default:
  2240. return false;
  2241. }
  2242. }
  2243. public virtual void SetE84HandoffSignalState(E84PioPosition piopostion, E84PioSignalPtoA PtoAsignal, bool state)
  2244. {
  2245. if (_lpE84Callback == null) return;
  2246. switch (PtoAsignal)
  2247. {
  2248. case E84PioSignalPtoA.ES:
  2249. _lpE84Callback.SetE84SignalState(E84PassiveSignal.ES, state);
  2250. break;
  2251. case E84PioSignalPtoA.HO_AVBL:
  2252. _lpE84Callback.SetE84SignalState(E84PassiveSignal.HOAvbl, state);
  2253. break;
  2254. case E84PioSignalPtoA.L_REQ:
  2255. _lpE84Callback.SetE84SignalState(E84PassiveSignal.LoadReq, state);
  2256. break;
  2257. case E84PioSignalPtoA.READY:
  2258. _lpE84Callback.SetE84SignalState(E84PassiveSignal.Ready, state);
  2259. break;
  2260. case E84PioSignalPtoA.U_REQ:
  2261. _lpE84Callback.SetE84SignalState(E84PassiveSignal.UnloadReq, state);
  2262. break;
  2263. default:
  2264. break;
  2265. }
  2266. }
  2267. public virtual void Monitor()
  2268. {
  2269. _presentTrig.CLK = _isPresent;
  2270. _placetTrig.CLK = _isPlaced;
  2271. _dockTrig.CLK = _isDocked;
  2272. _clampTrig.CLK = ClampState == FoupClampState.Close;
  2273. _doorTrig.CLK = DoorState == FoupDoorState.Close;
  2274. _accessSwPressedTrig.CLK = _isAccessSwPressed;
  2275. if (_lpE84Callback != null)
  2276. {
  2277. _lpE84Callback.SetFoupStatus(_isPlaced);
  2278. _lpE84Callback.SetReadyTransferStatus(IsReadyForE84Transfer);
  2279. _lpE84Callback.SetLightCurtainHandle(CurrentLightCurtainHandle);
  2280. }
  2281. }
  2282. public virtual bool IsReadyForE84Transfer
  2283. {
  2284. get
  2285. {
  2286. if ((CurrentState == LoadPortStateEnum.Idle || CurrentState == LoadPortStateEnum.TransferBlock)
  2287. && ClampState == FoupClampState.Open && DoorState == FoupDoorState.Close &&
  2288. DockState == FoupDockState.Undocked)
  2289. return true;
  2290. return false;
  2291. }
  2292. }
  2293. public virtual void Reset()
  2294. {
  2295. MapError = false;
  2296. ReadCarrierIDError = false;
  2297. if (CurrentReader != null)
  2298. CurrentReader.Reset();
  2299. }
  2300. public virtual bool IsEnableDualTransfer(out string reason)
  2301. {
  2302. reason = "";
  2303. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.EnableDualTransfer") &&
  2304. SC.GetValue<bool>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.EnableDualTransfer"))
  2305. {
  2306. return true;
  2307. }
  2308. return false;
  2309. }
  2310. public virtual bool IsEnableMapWafer(out string reason)
  2311. {
  2312. reason = "";
  2313. if (!_isPlaced)
  2314. {
  2315. reason = "No carrier placed";
  2316. return false;
  2317. }
  2318. if (!_isDocked)
  2319. {
  2320. reason = "carrier is not docked";
  2321. return false;
  2322. }
  2323. if (!IsReady())
  2324. {
  2325. reason = "Not Ready";
  2326. return false;
  2327. }
  2328. if (DoorState != FoupDoorState.Open)
  2329. {
  2330. reason = "Door is not opened";
  2331. return false;
  2332. }
  2333. if (DoorPosition != FoupDoorPostionEnum.Down)
  2334. {
  2335. reason = "Door is not down";
  2336. return false;
  2337. }
  2338. if (!IsCarrierEnabled)
  2339. {
  2340. reason = "Carrier Not Enabled";
  2341. return false;
  2342. }
  2343. return true;
  2344. }
  2345. public virtual bool IsEnableTransferWafer(out string reason)
  2346. {
  2347. reason = "";
  2348. if (CurrentState == LoadPortStateEnum.Error)
  2349. {
  2350. reason = "LoadPort In Error";
  2351. return false;
  2352. }
  2353. if (!_isPlaced)
  2354. {
  2355. reason = "No carrier placed";
  2356. return false;
  2357. }
  2358. if (!_isMapped)
  2359. {
  2360. reason = "Not Mapped";
  2361. return false;
  2362. }
  2363. if (!IsReady())
  2364. {
  2365. reason = "Not Ready";
  2366. return false;
  2367. }
  2368. if (!IsCarrierEnabled)
  2369. {
  2370. reason = "Carrier Not Enabled";
  2371. return false;
  2372. }
  2373. WaferInfo[] wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(Name));
  2374. foreach (WaferInfo wafer in wafers)
  2375. {
  2376. if (wafer.IsEmpty) continue;
  2377. if (wafer.Status == WaferStatus.Crossed || wafer.Status == WaferStatus.Double || wafer.Status == WaferStatus.Unknown)
  2378. {
  2379. //EV.PostWarningLog(Name, $"At least one wafer is {wafer.Status.ToString()}.");
  2380. reason = $"At least one wafer is {wafer.Status.ToString()}.";
  2381. return false;
  2382. }
  2383. }
  2384. return true;
  2385. }
  2386. public virtual bool IsEnableLoad(out string reason)
  2387. {
  2388. if (!_isPlaced)
  2389. {
  2390. reason = "No carrier placed";
  2391. return false;
  2392. }
  2393. if (_isDocked)
  2394. {
  2395. reason = "Carrier is docked";
  2396. return false;
  2397. }
  2398. if (!IsReady())
  2399. {
  2400. reason = "Not Ready";
  2401. return false;
  2402. }
  2403. if (!IsCarrierEnabled)
  2404. {
  2405. reason = "CarrierNotEnabled";
  2406. return false;
  2407. }
  2408. reason = "";
  2409. return true;
  2410. }
  2411. public virtual bool IsEnableUnload(out string reason)
  2412. {
  2413. if (!IsRemoteOperationPermit)
  2414. {
  2415. reason = "RemoteOperationNotAllowed";
  2416. return false;
  2417. }
  2418. if (!_isPlaced)
  2419. {
  2420. reason = "No carrier placed";
  2421. return false;
  2422. }
  2423. if (!_isDocked)
  2424. {
  2425. reason = "Carrier is undocked";
  2426. return false;
  2427. }
  2428. if (!IsReady())
  2429. {
  2430. reason = "Not Ready";
  2431. return false;
  2432. }
  2433. reason = "";
  2434. return true;
  2435. }
  2436. public virtual bool IsForbidAccessSlotAboveWafer()
  2437. {
  2438. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ForbidAccessAboveWaferCarrier"))
  2439. return SC.GetValue<bool>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ForbidAccessAboveWaferCarrier");
  2440. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ForbidAccessAboveWafer"))
  2441. return SC.GetValue<bool>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.ForbidAccessAboveWafer");
  2442. return false;
  2443. }
  2444. public CarrierOnLPState m_CarrierOnState { get; set; } = CarrierOnLPState.Unknow;
  2445. public bool HasAlarm => false;
  2446. protected virtual void ConfirmAddCarrier()
  2447. {
  2448. _isPlaced = true;
  2449. IsComplete = false;
  2450. if (m_CarrierOnState != CarrierOnLPState.On)
  2451. {
  2452. if (m_CarrierOnState == CarrierOnLPState.Off)
  2453. {
  2454. if (_lpE84Callback != null && IsAccessAuto)
  2455. {
  2456. if (_lpE84Callback.GetCurrentE84State() != E84State.Busy ||
  2457. !_lpE84Callback.GetE84SignalState(E84SignalID.VALID))
  2458. {
  2459. OnError("Unexpected carrier placed on access auto");
  2460. }
  2461. }
  2462. }
  2463. if (CarrierManager.Instance.GetCarrier(Name).IsEmpty)
  2464. {
  2465. CarrierManager.Instance.CreateCarrier(Name);
  2466. }
  2467. _carrierId = CarrierManager.Instance.GetCarrier(Name).CarrierId;
  2468. m_CarrierOnState = CarrierOnLPState.On;
  2469. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2470. dvid["PortID"] = PortID;
  2471. dvid["PORT_CTGRY"] = SpecPortName;
  2472. dvid["CarrierType"] = SpecCarrierType;
  2473. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2474. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2475. EV.Notify(EventCarrierArrived, dvid);
  2476. EV.Notify(EventCarrierArrived1, dvid);
  2477. EV.Notify($"{LPModuleName}_" + EventCarrierArrived, dvid);
  2478. if (_lpcallback != null)
  2479. _lpcallback.CarrierArrive();
  2480. if (OnCarrierPresenceChangeEvent != null)
  2481. OnCarrierPresenceChangeEvent(LPModuleName, true);
  2482. _isMapped = false;
  2483. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrier arrived.");
  2484. if (IsAutoClampOnCarrierArrive && !IsAccessAuto)
  2485. StartClampAction(true);
  2486. }
  2487. }
  2488. protected virtual void ConfirmRemoveCarrier()
  2489. {
  2490. _isPlaced = false;
  2491. IsComplete = false;
  2492. _isMapped = false;
  2493. if (m_CarrierOnState != CarrierOnLPState.Off)
  2494. {
  2495. if (m_CarrierOnState == CarrierOnLPState.On)
  2496. {
  2497. if (_lpE84Callback != null && IsAccessAuto)
  2498. {
  2499. if (_lpE84Callback.GetCurrentE84State() != E84State.Busy ||
  2500. !_lpE84Callback.GetE84SignalState(E84SignalID.VALID))
  2501. {
  2502. OnError("Unexpected carrier removed on access auto");
  2503. }
  2504. }
  2505. }
  2506. WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(Name), 0, 25);
  2507. //for (int i = 0; i < 25; i++)
  2508. //{
  2509. // WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(Name), 0, 25);
  2510. //}
  2511. CarrierManager.Instance.DeleteCarrier(Name);
  2512. m_CarrierOnState = CarrierOnLPState.Off;
  2513. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2514. dvid["PortID"] = PortID;
  2515. dvid["PORT_CTGRY"] = SpecPortName;
  2516. dvid["CarrierType"] = SpecCarrierType;
  2517. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2518. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2519. dvid["CarrierID"] = _carrierId ?? "";
  2520. dvid["CAR_ID"] = _carrierId ?? "";
  2521. EV.Notify(EventCarrierRemoved, dvid);
  2522. EV.Notify(EventCarrierRemoved1, dvid);
  2523. EV.Notify($"{LPModuleName}_" + EventCarrierRemoved, dvid);
  2524. if (_lpcallback != null) _lpcallback.CarrerRemove(_carrierId);
  2525. if (OnCarrierPresenceChangeEvent != null)
  2526. OnCarrierPresenceChangeEvent(LPModuleName, false);
  2527. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrier:{_carrierId} was removed.");
  2528. _carrierId = "";
  2529. }
  2530. }
  2531. public virtual void OnSlotMapRead(string _slotMap)
  2532. {
  2533. WaferInfo wafer = null;
  2534. if (OnSlotMapReadEvent != null)
  2535. OnSlotMapReadEvent(LPModuleName, _slotMap);
  2536. if (CurrentState == LoadPortStateEnum.Unloading)
  2537. {
  2538. for (int i = 0; i < _slotMap.Length; i++)
  2539. {
  2540. switch (_slotMap[i])
  2541. {
  2542. case '1':
  2543. if (WaferManager.Instance.CheckNoWafer(LPModuleName, i))
  2544. {
  2545. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Unknown);
  2546. EV.PostAlarmLog("LoadPort", $"{LPModuleName} detect wafer on slot:{i + 1} when unloading,but no record");
  2547. EV.Notify(AlarmLoadPortUnloadMappingError);
  2548. }
  2549. break;
  2550. case '0':
  2551. if (WaferManager.Instance.CheckHasWafer(LPModuleName, i))
  2552. {
  2553. wafer = WaferManager.Instance.GetWafer(LPModuleName, i);
  2554. wafer.Status = WaferStatus.Unknown;
  2555. EV.PostAlarmLog("LoadPort", $"{LPModuleName} didn't detect wafer on slot:{i + 1} when unloading,but it has record");
  2556. EV.Notify(AlarmLoadPortUnloadMappingError);
  2557. }
  2558. break;
  2559. case '2':
  2560. if (WaferManager.Instance.CheckNoWafer(LPModuleName, i))
  2561. {
  2562. wafer = WaferManager.Instance.GetWafer(LPModuleName, i);
  2563. EV.PostAlarmLog("LoadPort", $"{LPModuleName} detect wafer on slot:{i + 1} when unloading,but no record");
  2564. EV.Notify(AlarmLoadPortUnloadMappingError);
  2565. }
  2566. EV.Notify(AlarmLoadPortUnloadMapCrossedWafer);
  2567. EV.PostInfoLog("LoadPort", $"{LPModuleName} map crossed wafer on carrier:{_carrierId},slot:{i + 1}.");
  2568. break;
  2569. case 'W':
  2570. if (WaferManager.Instance.CheckNoWafer(LPModuleName, i))
  2571. {
  2572. wafer = WaferManager.Instance.GetWafer(LPModuleName, i);
  2573. EV.PostAlarmLog("LoadPort", $"{LPModuleName} detect wafer on slot:{i + 1} when unloading,but no record");
  2574. EV.Notify(AlarmLoadPortUnloadMappingError);
  2575. }
  2576. EV.Notify(AlarmLoadPortUnloadMapDoubleWafer);
  2577. EV.PostInfoLog("LoadPort", $"{LPModuleName} map double wafer on carrier:{_carrierId},slot:{i + 1}.");
  2578. break;
  2579. default:
  2580. if (WaferManager.Instance.CheckNoWafer(LPModuleName, i))
  2581. {
  2582. wafer = WaferManager.Instance.GetWafer(LPModuleName, i);
  2583. EV.PostAlarmLog("LoadPort", $"{LPModuleName} detect wafer on slot:{i + 1} when unloading,but no record");
  2584. EV.Notify(AlarmLoadPortUnloadMappingError);
  2585. }
  2586. EV.Notify(AlarmLoadPortUnloadMapUnknownWafer);
  2587. EV.PostInfoLog("LoadPort", $"{LPModuleName} map unknow wafer on carrier:{_carrierId},slot:{i + 1}.");
  2588. break;
  2589. }
  2590. }
  2591. }
  2592. else
  2593. {
  2594. CurrentSlotMapResult = _slotMap;
  2595. string tempSlotMap = _slotMap;//.Substring(ValidStartSlotIndex, ValidSlotsNumber);
  2596. for (int i = 0; i < tempSlotMap.Length; i++)
  2597. {
  2598. // No wafer: "0", Wafer: "1", Crossed:"2", Undefined: "?", Overlapping wafers: "W"
  2599. switch (tempSlotMap[i])
  2600. {
  2601. case '0':
  2602. WaferManager.Instance.DeleteWafer(LPModuleName, i);
  2603. CarrierManager.Instance.UnregisterCarrierWafer(Name, i);
  2604. break;
  2605. case '1':
  2606. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Normal);
  2607. WaferManager.Instance.UpdateWaferSize(LPModuleName, i, GetCurrentWaferSize());
  2608. CarrierManager.Instance.RegisterCarrierWafer(Name, i, wafer);
  2609. break;
  2610. case '2':
  2611. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Crossed);
  2612. WaferManager.Instance.UpdateWaferSize(LPModuleName, i, GetCurrentWaferSize());
  2613. CarrierManager.Instance.RegisterCarrierWafer(Name, i, wafer);
  2614. EV.Notify(AlarmLoadPortMapCrossedWafer);
  2615. EV.PostInfoLog("LoadPort", $"{LPModuleName} map crossed wafer on carrier:{_carrierId},slot:{i + 1}.");
  2616. break;
  2617. case 'W':
  2618. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Double);
  2619. WaferManager.Instance.UpdateWaferSize(LPModuleName, i, GetCurrentWaferSize());
  2620. CarrierManager.Instance.RegisterCarrierWafer(Name, i, wafer);
  2621. EV.Notify(AlarmLoadPortMapDoubleWafer);
  2622. EV.PostInfoLog("LoadPort", $"{LPModuleName} map double wafer on carrier:{_carrierId},slot:{i + 1}.");
  2623. break;
  2624. case '?':
  2625. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Unknown);
  2626. WaferManager.Instance.UpdateWaferSize(LPModuleName, i, GetCurrentWaferSize());
  2627. CarrierManager.Instance.RegisterCarrierWafer(Name, i, wafer);
  2628. EV.PostInfoLog("LoadPort", $"{LPModuleName} map unknown wafer on carrier:{_carrierId},slot:{i + 1}.");
  2629. break;
  2630. default:
  2631. tempSlotMap = tempSlotMap.Substring(0, i) + "?" + tempSlotMap.Substring(i + 1);
  2632. wafer = WaferManager.Instance.CreateWafer(LPModuleName, i, WaferStatus.Unknown);
  2633. WaferManager.Instance.UpdateWaferSize(LPModuleName, i, GetCurrentWaferSize());
  2634. CarrierManager.Instance.RegisterCarrierWafer(Name, i, wafer);
  2635. EV.PostInfoLog("LoadPort", $"{LPModuleName} map unknown wafer on carrier:{_carrierId},slot:{i + 1}.");
  2636. break;
  2637. }
  2638. }
  2639. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2640. dvid["SlotMap"] = tempSlotMap;
  2641. dvid["PortID"] = PortID;
  2642. dvid["PORT_CTGRY"] = SpecPortName;
  2643. dvid["CarrierType"] = SpecCarrierType;
  2644. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2645. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2646. dvid["CarrierID"] = CarrierId;
  2647. EV.Notify(EventSlotMapAvailable, dvid);
  2648. EV.Notify(EventMapComplete, dvid);
  2649. EV.Notify($"{LPModuleName}_" + EventSlotMapAvailable, dvid);
  2650. if (tempSlotMap.Contains("2"))
  2651. {
  2652. MapError = true;
  2653. string slotSpec = "";
  2654. for (int i = 0; i < CurrentSlotMapResult.Length; i++)
  2655. {
  2656. if (CurrentSlotMapResult[i] == '2')
  2657. {
  2658. if (slotSpec == "")
  2659. slotSpec += $"{i + 1}";
  2660. else
  2661. slotSpec += $",{i + 1}";
  2662. }
  2663. }
  2664. SerializableDictionary<string, object> dvid1 = new SerializableDictionary<string, object>();
  2665. dvid["AlarmDescription"] = $"{LPModuleName} load map crossed wafer on slot:{slotSpec} of carrier:{_carrierId}";
  2666. EV.Notify(AlarmLoadPortMapCrossedWafer, dvid1);
  2667. SerializableDictionary<string, object> dvid2 = new SerializableDictionary<string, object>();
  2668. dvid1["AlarmDescription"] = $"{LPModuleName} map error:crossed wafer when load carrier:{_carrierId}";
  2669. EV.Notify(AlarmLoadPortMappingError, dvid2);
  2670. //OnError("MappingError");
  2671. }
  2672. if (tempSlotMap.Contains("3"))
  2673. {
  2674. MapError = true;
  2675. string slotSpec = "";
  2676. for (int i = 0; i < CurrentSlotMapResult.Length; i++)
  2677. {
  2678. if (CurrentSlotMapResult[i] == '3')
  2679. {
  2680. if (slotSpec == "")
  2681. slotSpec += $"{i + 1}";
  2682. else
  2683. slotSpec += $",{i + 1}";
  2684. }
  2685. }
  2686. SerializableDictionary<string, object> dvid1 = new SerializableDictionary<string, object>();
  2687. dvid["AlarmDescription"] = $"{LPModuleName} load map double wafer on slot:{slotSpec} of carrier:{_carrierId}";
  2688. EV.Notify(AlarmLoadPortMapDoubleWafer, dvid1);
  2689. SerializableDictionary<string, object> dvid2 = new SerializableDictionary<string, object>();
  2690. dvid1["AlarmDescription"] = $"{LPModuleName} map error:double wafer when load carrier:{_carrierId}";
  2691. EV.Notify(AlarmLoadPortMappingError, dvid2);
  2692. //OnError("MappingError");
  2693. }
  2694. if (tempSlotMap.Contains("W"))
  2695. {
  2696. MapError = true;
  2697. string slotSpec = "";
  2698. for (int i = 0; i < CurrentSlotMapResult.Length; i++)
  2699. {
  2700. if (CurrentSlotMapResult[i] == 'W')
  2701. {
  2702. if (slotSpec == "")
  2703. slotSpec += $"{i + 1}";
  2704. else
  2705. slotSpec += $",{i + 1}";
  2706. }
  2707. }
  2708. SerializableDictionary<string, object> dvid1 = new SerializableDictionary<string, object>();
  2709. dvid["AlarmDescription"] = $"{LPModuleName} load map double wafer on slot:{slotSpec} of carrier:{_carrierId}";
  2710. EV.Notify(AlarmLoadPortMapDoubleWafer, dvid1);
  2711. SerializableDictionary<string, object> dvid2 = new SerializableDictionary<string, object>();
  2712. dvid1["AlarmDescription"] = $"{LPModuleName} map error:double wafer when load carrier:{_carrierId}";
  2713. EV.Notify(AlarmLoadPortMappingError, dvid2);
  2714. //OnError("MappingError");
  2715. }
  2716. if (tempSlotMap.Contains("?"))
  2717. {
  2718. MapError = true;
  2719. string slotSpec = "";
  2720. for (int i = 0; i < CurrentSlotMapResult.Length; i++)
  2721. {
  2722. if (CurrentSlotMapResult[i] == '?')
  2723. {
  2724. if (slotSpec == "")
  2725. slotSpec += $"{i + 1}";
  2726. else
  2727. slotSpec += $",{i + 1}";
  2728. }
  2729. }
  2730. SerializableDictionary<string, object> dvid1 = new SerializableDictionary<string, object>();
  2731. dvid["AlarmDescription"] = $"{LPModuleName} load unknow wafer on slot:{slotSpec} of carrier:{_carrierId}";
  2732. EV.Notify(AlarmLoadPortMapUnknownWafer, dvid1);
  2733. SerializableDictionary<string, object> dvid2 = new SerializableDictionary<string, object>();
  2734. dvid1["AlarmDescription"] = $"{LPModuleName} map error:unknow wafer when load carrier:{_carrierId}";
  2735. EV.Notify(AlarmLoadPortMappingError, dvid2);
  2736. //OnError("MappingError");
  2737. }
  2738. if (LPCallBack != null && IsPlacement)
  2739. LPCallBack.MappingComplete(_carrierId, CurrentSlotMapResult);
  2740. }
  2741. _isMapped = true;
  2742. }
  2743. /// <summary>
  2744. /// 获取LP中空缺Slot
  2745. /// </summary>
  2746. /// <returns>返回一个list, 顺序为从下到上.(0-25)</returns>
  2747. public virtual bool ReadCarrierIDByIndex(int offset = 0, int length = 16, int index = 0)
  2748. {
  2749. if (CIDReaders == null || CIDReaders.Length <= index) return false;
  2750. return CIDReaders[index].ReadCarrierID(offset, length);
  2751. }
  2752. public virtual bool WriteCarrierIDByIndex(string cid, int offset = 0, int length = 16, int index = 0)
  2753. {
  2754. if (CIDReaders == null || CIDReaders.Length <= index) return false;
  2755. _carrierIdToBeWrite = cid;
  2756. if (!CIDReaders[index].WriteCarrierID(offset, length, cid))
  2757. return false;
  2758. int waitCount = 0;
  2759. while (true)
  2760. {
  2761. if (CIDReaders[index].IsReady)
  2762. return true;
  2763. Thread.Sleep(100);
  2764. waitCount++;
  2765. if (waitCount > 150)
  2766. break;
  2767. }
  2768. return false;
  2769. }
  2770. public bool ReadCarrierIDByIndex(object[] para)
  2771. {
  2772. int offset = SC.ContainsItem($"LoadPort.{LPModuleName}.StartPage") ?
  2773. SC.GetValue<int>($"LoadPort.{LPModuleName}.StartPage") : 0;
  2774. int length = SC.ContainsItem($"LoadPort.{LPModuleName}.DataReadSize") ?
  2775. SC.GetValue<int>($"LoadPort.{LPModuleName}.DataReadSize") : 16;
  2776. int index = 0;
  2777. if (para != null)
  2778. index = Convert.ToInt32(para[0]);
  2779. return ReadCarrierIDByIndex(offset, length, index);
  2780. }
  2781. public bool WriteCarrierIDByIndex(object[] para)
  2782. {
  2783. int offset = SC.ContainsItem($"LoadPort.{LPModuleName}.StartPage") ?
  2784. SC.GetValue<int>($"LoadPort.{LPModuleName}.StartPage") : 0;
  2785. int length = SC.ContainsItem($"LoadPort.{LPModuleName}.DataReadSize") ?
  2786. SC.GetValue<int>($"LoadPort.{LPModuleName}.DataReadSize") : 16;
  2787. if (para == null) return false;
  2788. int index = Convert.ToInt32(para[0]);
  2789. string cid = para[1].ToString();
  2790. return WriteCarrierIDByIndex(cid, offset, length, index);
  2791. }
  2792. protected int CurrentCidIndex
  2793. {
  2794. get
  2795. {
  2796. if (SC.ContainsItem($"CarrierInfo.{LPModuleName}CIDReaderIndex{InfoPadCarrierIndex}"))
  2797. {
  2798. return SC.GetValue<int>($"CarrierInfo.{LPModuleName}CIDReaderIndex{InfoPadCarrierIndex}");
  2799. }
  2800. if (SC.ContainsItem($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CIDReaderIndex"))
  2801. {
  2802. return SC.GetValue<int>($"CarrierInfo.Carrier{InfoPadCarrierIndex}.CIDReaderIndex");
  2803. }
  2804. return 0;
  2805. }
  2806. }
  2807. public virtual bool ReadCarrierID(int offset, int length)
  2808. {
  2809. if (CIDReaders == null || CIDReaders.Length < CurrentCidIndex)
  2810. {
  2811. return false;
  2812. }
  2813. return CIDReaders[CurrentCidIndex].ReadCarrierID(offset, length);
  2814. }
  2815. public virtual bool GetCarrierID(int offset, int length, string tagid, out string carrierId)
  2816. {
  2817. carrierId = _carrierId;
  2818. if (CIDReaders == null || CIDReaders.Length < CurrentCidIndex)
  2819. {
  2820. return false;
  2821. }
  2822. if (!CIDReaders[CurrentCidIndex].ReadCarrierID(offset, length))
  2823. {
  2824. return false;
  2825. }
  2826. int waitCount = 0;
  2827. while (!CIDReaders[CurrentCidIndex].IsReady)
  2828. {
  2829. Thread.Sleep(100);
  2830. waitCount++;
  2831. if (waitCount > 200)
  2832. {
  2833. return false;
  2834. }
  2835. }
  2836. carrierId = CIDReaders[CurrentCidIndex].CarrierIDBeRead;
  2837. return true;
  2838. }
  2839. public virtual bool ReadCarrierID()
  2840. {
  2841. int offset = SC.ContainsItem($"LoadPort.{LPModuleName}.StartPage") ?
  2842. SC.GetValue<int>($"LoadPort.{LPModuleName}.StartPage") : 0;
  2843. int length = SC.ContainsItem($"LoadPort.{LPModuleName}.DataReadSize") ?
  2844. SC.GetValue<int>($"LoadPort.{LPModuleName}.DataReadSize") : 16;
  2845. if (CIDReaders == null || CIDReaders.Length < CurrentCidIndex)
  2846. {
  2847. return false;
  2848. }
  2849. return CIDReaders[CurrentCidIndex].ReadCarrierID(offset, length);
  2850. }
  2851. public virtual bool ReadCarrierID(object[] para)
  2852. {
  2853. if (para != null && para.Length == 2)
  2854. {
  2855. return ReadCarrierID(Convert.ToInt32(para[0]), Convert.ToInt32(para[1]));
  2856. }
  2857. return ReadCarrierID();
  2858. }
  2859. public virtual bool WriteCarrierID(string carrierID, int offset = 0, int length = 16)
  2860. {
  2861. if (CIDReaders == null || CIDReaders.Length < CurrentCidIndex)
  2862. {
  2863. return false;
  2864. }
  2865. if (!CIDReaders[CurrentCidIndex].WriteCarrierID(offset, length, carrierID))
  2866. return false;
  2867. int waitCount = 0;
  2868. while (true)
  2869. {
  2870. if (CIDReaders[CurrentCidIndex].IsReady)
  2871. return true;
  2872. Thread.Sleep(100);
  2873. waitCount++;
  2874. if (waitCount > 150)
  2875. break;
  2876. }
  2877. return false;
  2878. }
  2879. public virtual bool WriteCarrierID(string cid, int offset, int length, string tagid, out string reason)
  2880. {
  2881. reason = "";
  2882. if (CIDReaders == null || CIDReaders.Length < CurrentCidIndex)
  2883. {
  2884. reason = "No valid reader";
  2885. return false;
  2886. }
  2887. if (!CIDReaders[CurrentCidIndex].WriteCarrierID(offset, length, cid))
  2888. return false;
  2889. int waitCount = 0;
  2890. while (true)
  2891. {
  2892. if (CIDReaders[CurrentCidIndex].IsReady)
  2893. return true;
  2894. Thread.Sleep(100);
  2895. waitCount++;
  2896. if (waitCount > 150)
  2897. break;
  2898. }
  2899. return false;
  2900. }
  2901. public virtual void OnCarrierIdRead(string carrierId, int readerIndex = 0, int startPage = 0, int length = 16, bool updateCarrierID = true)
  2902. {
  2903. if (_isPlaced && _isPresent)
  2904. {
  2905. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2906. dvid["PORT_ID"] = PortID;
  2907. dvid["PortID"] = PortID;
  2908. dvid["PORT_CTGRY"] = SpecPortName;
  2909. dvid["CarrierType"] = SpecCarrierType;
  2910. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2911. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2912. dvid["CarrierID"] = carrierId;
  2913. dvid["CIDReaderIndex"] = readerIndex;
  2914. dvid["StartPage"] = startPage;
  2915. dvid["PageLength"] = length;
  2916. EV.Notify(EventCarrierIdRead, dvid);
  2917. EV.Notify(EventCarrierIdRead1, dvid);
  2918. EV.Notify($"{LPModuleName}_" + EventCarrierIdRead, dvid);
  2919. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrierID read successfully:{carrierId}.");
  2920. ReadCarrierIDError = false;
  2921. if (updateCarrierID)
  2922. {
  2923. _carrierId = carrierId;
  2924. CarrierManager.Instance.UpdateCarrierId(Name, carrierId);
  2925. if (_lpcallback != null)
  2926. _lpcallback.CarrierIDReadSuccess(carrierId);
  2927. }
  2928. if (OnCarrierIDReadEvent != null)
  2929. OnCarrierIDReadEvent(LPModuleName, carrierId);
  2930. }
  2931. else
  2932. {
  2933. EV.PostWarningLog(Module, $"No FOUP found, carrier id {carrierId} not saved");
  2934. }
  2935. }
  2936. public bool NoteTransferStart()
  2937. {
  2938. return CheckToPostMessage((int)LoadPortMsg.StartAccess, null);
  2939. }
  2940. private Stopwatch _timerMonitorAccess = new Stopwatch();
  2941. public bool NoteTransferStop()
  2942. {
  2943. CheckToPostMessage((int)LoadPortMsg.CompleteAccess, null);
  2944. _timerMonitorAccess.Restart();
  2945. while (_timerMonitorAccess.IsRunning && _timerMonitorAccess.Elapsed < TimeSpan.FromSeconds(2)
  2946. && !IsReady())
  2947. {
  2948. }
  2949. _timerMonitorAccess.Stop();
  2950. return IsReady();
  2951. }
  2952. public void ProceedSetCarrierID(string cid)
  2953. {
  2954. _carrierId = cid;
  2955. CarrierManager.Instance.UpdateCarrierId(Name, cid);
  2956. }
  2957. public void OnCarrierIdWrite(string carrierId, int readerIndex = 1, int startPage = 1, int length = 16, bool isUpdateCid = true)
  2958. {
  2959. if (_isPlaced && _isPresent)
  2960. {
  2961. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2962. dvid["PORT_ID"] = PortID;
  2963. dvid["PortID"] = PortID;
  2964. dvid["PORT_CTGRY"] = SpecPortName;
  2965. dvid["CarrierType"] = SpecCarrierType;
  2966. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2967. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2968. dvid["CarrierID"] = carrierId;
  2969. dvid["CAR_ID"] = carrierId;
  2970. dvid["CIDReaderIndex"] = readerIndex;
  2971. dvid["StartPage"] = startPage;
  2972. dvid["PageLength"] = length;
  2973. EV.Notify(EventCarrierIdWrite, dvid);
  2974. EV.Notify($"{LPModuleName}_" + EventCarrierIdWrite, dvid);
  2975. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrierID write successfully:{carrierId}.");
  2976. if (isUpdateCid)
  2977. _carrierId = carrierId;
  2978. }
  2979. else
  2980. {
  2981. EV.PostWarningLog(Module, $"No FOUP found, carrier id {carrierId} not saved");
  2982. }
  2983. }
  2984. public void OnCarrierIdReadFailed(int readerIndex = 1)
  2985. {
  2986. if (_isPlaced && _isPresent)
  2987. {
  2988. //_carrierId = "";
  2989. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  2990. dvid["PORT_ID"] = PortID;
  2991. dvid["PortID"] = PortID;
  2992. dvid["PORT_CTGRY"] = SpecPortName;
  2993. dvid["CarrierType"] = SpecCarrierType;
  2994. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  2995. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  2996. dvid["CIDReaderIndex"] = readerIndex;
  2997. EV.Notify(EventCarrierIdReadFailed, dvid);
  2998. EV.Notify(EventCarrierIdReadFailed1, dvid);
  2999. EV.Notify($"{LPModuleName}_" + EventCarrierIdReadFailed, dvid);
  3000. if (_lpcallback != null) _lpcallback.CarrierIDReadFail();
  3001. EV.Notify(AlarmCarrierIDReadError, new SerializableDictionary<string, object> {
  3002. {"AlarmText","CarrierID read fail." }
  3003. });
  3004. ReadCarrierIDError = true;
  3005. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrierID read fail.");
  3006. }
  3007. else
  3008. {
  3009. EV.PostWarningLog(Module, "No FOUP found, carrier id read is not valid");
  3010. }
  3011. }
  3012. public void OnCarrierIdWriteFailed(int readerIndex = 1)
  3013. {
  3014. if (_isPlaced && _isPresent)
  3015. {
  3016. SerializableDictionary<string, object> dvid = new SerializableDictionary<string, object>();
  3017. dvid["PORT_ID"] = PortID;
  3018. dvid["PortID"] = PortID;
  3019. dvid["PORT_CTGRY"] = SpecPortName;
  3020. dvid["CarrierType"] = SpecCarrierType;
  3021. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  3022. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  3023. dvid["CIDReaderIndex"] = readerIndex;
  3024. EV.Notify(EventCarrierIdWriteFailed, dvid);
  3025. EV.Notify(EventCarrierIdWriteFailed1, dvid);
  3026. EV.Notify($"{LPModuleName}_" + EventCarrierIdWriteFailed, dvid);
  3027. EV.PostInfoLog("LoadPort", $"{LPModuleName} carrierID write fail carrierID:{_carrierIdToBeWrite ?? ""}.");
  3028. }
  3029. else
  3030. {
  3031. EV.PostWarningLog(Module, "No FOUP found, carrier id not valid");
  3032. }
  3033. }
  3034. public void OnCarrierIdRead(ModuleName module, string carrierId, int readerIndex = 1, int startPage = 1, int length = 16, bool isUpdateLPCarrier = true)
  3035. {
  3036. OnCarrierIdRead(carrierId, readerIndex, startPage, length, isUpdateLPCarrier);
  3037. }
  3038. public void OnCarrierIdReadFailed(ModuleName module, int readerIndex = 1)
  3039. {
  3040. OnCarrierIdReadFailed(readerIndex);
  3041. }
  3042. public void OnCarrierIdWrite(ModuleName module, string carrierId, int readerIndex = 1, int startPage = 1, int length = 16, bool isUpdateCid = true)
  3043. {
  3044. OnCarrierIdWrite(carrierId, readerIndex, startPage, length, isUpdateCid);
  3045. }
  3046. public void OnCarrierIdWriteFailed(ModuleName module, int readerIndex = 1)
  3047. {
  3048. OnCarrierIdWriteFailed(readerIndex);
  3049. }
  3050. public virtual void OnLoaded()
  3051. {
  3052. var dvid = new SerializableDictionary<string, object>
  3053. {
  3054. ["CarrierID"] = _carrierId ?? "",
  3055. ["CAR_ID"] = _carrierId ?? "",
  3056. ["PORT_ID"] = PortID,
  3057. ["PortID"] = PortID,
  3058. ["PORT_CTGRY"] = SpecPortName,
  3059. ["CarrierType"] = SpecCarrierType,
  3060. ["CarrierIndex"] = InfoPadCarrierIndex,
  3061. ["InfoPadSensorIndex"] = InfoPadSensorIndex,
  3062. };
  3063. EV.Notify(EventCarrierloaded, dvid);
  3064. EV.Notify($"{LPModuleName}_" + EventCarrierloaded, dvid);
  3065. EV.PostInfoLog("LoadPort", $"{LPModuleName} load complete with carrier type:{SpecCarrierType ?? ""}.");
  3066. EV.Notify(EventCarrierLoaded1, dvid);
  3067. if (_lpcallback != null) _lpcallback.LoadComplete();
  3068. if (OnCarrierLoadCompleteEvent != null)
  3069. OnCarrierLoadCompleteEvent(LPModuleName, _carrierId);
  3070. }
  3071. public virtual void OnUnloaded()
  3072. {
  3073. var dvid = new SerializableDictionary<string, object>();
  3074. dvid["PortID"] = PortID;
  3075. dvid["PORT_CTGRY"] = SpecPortName;
  3076. dvid["CarrierType"] = SpecCarrierType;
  3077. dvid["CarrierID"] = _carrierId;
  3078. dvid["CAR_ID"] = _carrierId ?? "";
  3079. dvid["PORT_ID"] = PortID;
  3080. dvid["SlotMap"] = CurrentSlotMapResult;
  3081. EV.Notify(EventCarrierUnloaded, dvid);
  3082. EV.Notify(EventCarrierUnloaded1, dvid);
  3083. EV.Notify($"{LPModuleName}_" + EventCarrierUnloaded, dvid);
  3084. EV.PostInfoLog("LoadPort", $"{LPModuleName} unload complete with carrier:{CarrierId ?? ""}.");
  3085. //}
  3086. DockState = FoupDockState.Undocked;
  3087. if (_lpcallback != null) _lpcallback.UnloadComplete();
  3088. if (OnPortTransferReadyEvent != null)
  3089. OnPortTransferReadyEvent(LPModuleName, true);
  3090. //_isMapped = false;
  3091. }
  3092. public virtual void OnCarrierClamped()
  3093. {
  3094. var dvid = new SerializableDictionary<string, object>();
  3095. dvid["PortID"] = PortID;
  3096. dvid["PORT_CTGRY"] = SpecPortName;
  3097. dvid["CarrierType"] = SpecCarrierType;
  3098. dvid["CarrierID"] = _carrierId;
  3099. dvid["CAR_ID"] = _carrierId ?? "";
  3100. dvid["PORT_ID"] = PortID;
  3101. dvid["SlotMap"] = CurrentSlotMapResult;
  3102. EV.Notify(EventCarrierClamped, dvid);
  3103. EV.Notify($"{LPModuleName}_" + EventCarrierClamped, dvid);
  3104. EV.PostInfoLog("LoadPort", $"{LPModuleName} clamped carrier:{CarrierId ?? ""}.");
  3105. //}
  3106. }
  3107. public virtual void OnCarrierUnClamped()
  3108. {
  3109. var dvid = new SerializableDictionary<string, object>();
  3110. dvid["PortID"] = PortID;
  3111. dvid["PORT_CTGRY"] = SpecPortName;
  3112. dvid["CarrierType"] = SpecCarrierType;
  3113. dvid["CarrierID"] = _carrierId;
  3114. dvid["CAR_ID"] = _carrierId ?? "";
  3115. dvid["PORT_ID"] = PortID;
  3116. dvid["SlotMap"] = CurrentSlotMapResult;
  3117. EV.Notify(EventCarrierUnclamped, dvid);
  3118. EV.Notify($"{LPModuleName}_" + EventCarrierUnclamped, dvid);
  3119. EV.PostInfoLog("LoadPort", $"{LPModuleName} unclamped carrier:{CarrierId ?? ""}.");
  3120. //}
  3121. }
  3122. public virtual void OnCarrierDocked()
  3123. {
  3124. var dvid = new SerializableDictionary<string, object>();
  3125. dvid["PortID"] = PortID;
  3126. dvid["PORT_CTGRY"] = SpecPortName;
  3127. dvid["CarrierType"] = SpecCarrierType;
  3128. dvid["CarrierID"] = _carrierId;
  3129. dvid["CAR_ID"] = _carrierId ?? "";
  3130. dvid["PORT_ID"] = PortID;
  3131. dvid["SlotMap"] = CurrentSlotMapResult;
  3132. EV.Notify(EventCarrierDocked, dvid);
  3133. EV.Notify($"{LPModuleName}_" + EventCarrierDocked, dvid);
  3134. EV.PostInfoLog("LoadPort", $"{LPModuleName} docked carrier:{CarrierId ?? ""}.");
  3135. //}
  3136. }
  3137. public virtual void OnCarrierUnDocked()
  3138. {
  3139. var dvid = new SerializableDictionary<string, object>();
  3140. dvid["PortID"] = PortID;
  3141. dvid["PORT_CTGRY"] = SpecPortName;
  3142. dvid["CarrierType"] = SpecCarrierType;
  3143. dvid["CarrierID"] = _carrierId;
  3144. dvid["CAR_ID"] = _carrierId ?? "";
  3145. dvid["PORT_ID"] = PortID;
  3146. dvid["SlotMap"] = CurrentSlotMapResult;
  3147. EV.Notify(EventCarrierUndocked, dvid);
  3148. EV.Notify($"{LPModuleName}_" + EventCarrierUndocked, dvid);
  3149. EV.PostInfoLog("LoadPort", $"{LPModuleName} undocked carrier:{CarrierId ?? ""}.");
  3150. //}
  3151. }
  3152. public virtual void OnCarrierOpened()
  3153. {
  3154. var dvid = new SerializableDictionary<string, object>();
  3155. dvid["PortID"] = PortID;
  3156. dvid["PORT_CTGRY"] = SpecPortName;
  3157. dvid["CarrierType"] = SpecCarrierType;
  3158. dvid["CarrierID"] = _carrierId;
  3159. dvid["CAR_ID"] = _carrierId ?? "";
  3160. dvid["PORT_ID"] = PortID;
  3161. dvid["SlotMap"] = CurrentSlotMapResult;
  3162. EV.Notify(EventCarrierOpened, dvid);
  3163. EV.Notify($"{LPModuleName}_" + EventCarrierOpened, dvid);
  3164. EV.PostInfoLog("LoadPort", $"{LPModuleName} opened carrier:{CarrierId ?? ""}.");
  3165. //}
  3166. }
  3167. public virtual void OnCarrierClosed()
  3168. {
  3169. var dvid = new SerializableDictionary<string, object>();
  3170. dvid["PortID"] = PortID;
  3171. dvid["PORT_CTGRY"] = SpecPortName;
  3172. dvid["CarrierType"] = SpecCarrierType;
  3173. dvid["CarrierID"] = _carrierId;
  3174. dvid["CAR_ID"] = _carrierId ?? "";
  3175. dvid["PORT_ID"] = PortID;
  3176. dvid["SlotMap"] = CurrentSlotMapResult;
  3177. EV.Notify(EventCarrierClosed, dvid);
  3178. EV.Notify($"{LPModuleName}_" + EventCarrierClosed, dvid);
  3179. EV.PostInfoLog("LoadPort", $"{LPModuleName} closed carrier:{CarrierId ?? ""}.");
  3180. //}
  3181. }
  3182. public virtual void OnE84HandOffStart(bool isload)
  3183. {
  3184. if (_lpcallback != null)
  3185. _lpcallback.OnE84HandoffStart(isload);
  3186. if (isload)
  3187. {
  3188. if (OnE84LoadStartEvent != null)
  3189. {
  3190. OnE84LoadStartEvent(LPModuleName, "");
  3191. }
  3192. }
  3193. else
  3194. {
  3195. if (OnE84UnloadStartEvent != null)
  3196. {
  3197. OnE84UnloadStartEvent(LPModuleName, _carrierId);
  3198. }
  3199. }
  3200. }
  3201. public virtual void OnE84HandOffComplete(bool isload)
  3202. {
  3203. if (_lpcallback != null)
  3204. _lpcallback.OnE84HandoffComplete(isload);
  3205. if (isload)
  3206. {
  3207. if (OnE84LoadCompleteEvent != null)
  3208. {
  3209. OnE84LoadCompleteEvent(LPModuleName, "");
  3210. }
  3211. }
  3212. else
  3213. {
  3214. if (OnE84UnloadCompleteEvent != null)
  3215. {
  3216. OnE84UnloadCompleteEvent(LPModuleName, _carrierId);
  3217. }
  3218. }
  3219. if (isload && IsAutoClampOnCarrierArrive && IsAccessAuto)
  3220. {
  3221. StartClampAction(true);
  3222. }
  3223. }
  3224. public void OnHomed()
  3225. {
  3226. //for (int i = 0; i < 25; i++)
  3227. //{
  3228. if (!_isPlaced)
  3229. WaferManager.Instance.DeleteWafer(ModuleHelper.Converter(Name), 0, 25);
  3230. //}
  3231. _isMapped = false;
  3232. var dvid = new SerializableDictionary<string, object>();
  3233. dvid["PortID"] = PortID;
  3234. dvid["PORT_CTGRY"] = SpecPortName;
  3235. dvid["CarrierType"] = SpecCarrierType;
  3236. dvid["CarrierIndex"] = InfoPadCarrierIndex;
  3237. dvid["InfoPadSensorIndex"] = InfoPadSensorIndex;
  3238. dvid["CarrierID"] = _carrierId;
  3239. EV.Notify(EventLPHomed);
  3240. EV.Notify($"{LPModuleName}_" + EventLPHomed);
  3241. EV.PostInfoLog("LoadPort", $"{LPModuleName} home complete with carrier:{CarrierId ?? ""}.");
  3242. if (_lpcallback != null) _lpcallback.OnLPHomed();
  3243. if (OnPortTransferReadyEvent != null)
  3244. OnPortTransferReadyEvent(LPModuleName, IsPlacement);
  3245. }
  3246. public virtual void OnError(string error = "")
  3247. {
  3248. EV.Notify(AlarmLoadPortError);
  3249. EV.PostAlarmLog("LoadPort", $"{LPModuleName} occurried error:{error} with carrier:{CarrierId ?? ""}.");
  3250. IsBusy = false;
  3251. CheckToPostMessage((int)LoadPortMsg.Error, null);
  3252. if (ActionDone != null)
  3253. ActionDone(false);
  3254. }
  3255. protected void SetPresent(bool isPresent)
  3256. {
  3257. _isPresent = isPresent;
  3258. if (_isPresent)
  3259. {
  3260. //ConfirmAddCarrier();
  3261. }
  3262. else
  3263. {
  3264. //ConfirmRemoveCarrier();
  3265. }
  3266. }
  3267. protected virtual void SetPlaced(bool isPlaced)
  3268. {
  3269. _isPlaced = isPlaced;
  3270. if (_isPlaced)
  3271. {
  3272. ConfirmAddCarrier();
  3273. }
  3274. else
  3275. {
  3276. ConfirmRemoveCarrier();
  3277. }
  3278. }
  3279. public virtual bool OnActionDone(object[] param)
  3280. {
  3281. IsBusy = false;
  3282. CheckToPostMessage((int)LoadPortMsg.ActionDone, new object[] { "ActionDone" });
  3283. if (ActionDone != null)
  3284. ActionDone(true);
  3285. return true;
  3286. }
  3287. public void OnActionDone(bool result)
  3288. {
  3289. if (ActionDone != null)
  3290. ActionDone(result);
  3291. }
  3292. public bool CheckToPostMessage(int msg, params object[] args)
  3293. {
  3294. if (!fsm.FindTransition(fsm.State, msg))
  3295. {
  3296. if ((LoadPortMsg)msg != LoadPortMsg.ActionDone && (LoadPortMsg)msg != LoadPortMsg.StartExecute)
  3297. EV.PostInfoLog(Name, $"{Name} is in { (LoadPortStateEnum)fsm.State} state,can not do {(LoadPortMsg)msg}");
  3298. return false;
  3299. }
  3300. CurrentParamter = args;
  3301. if (msg < 10)
  3302. IsBusy = true;
  3303. else
  3304. IsBusy = false;
  3305. fsm.PostMsg(msg, args);
  3306. return true;
  3307. }
  3308. public bool CheckToPostMessage(LoadPortMsg msg, params object[] args)
  3309. {
  3310. if (!fsm.FindTransition(fsm.State, (int)msg))
  3311. {
  3312. if ((LoadPortMsg)msg != LoadPortMsg.ActionDone && (LoadPortMsg)msg != LoadPortMsg.StartExecute)
  3313. EV.PostWarningLog(Name, $"{Name} is in { (LoadPortStateEnum)fsm.State} state,can not do {(LoadPortMsg)msg}");
  3314. return false;
  3315. }
  3316. CurrentParamter = args;
  3317. if ((int)msg < 10)
  3318. IsBusy = true;
  3319. else
  3320. IsBusy = false;
  3321. fsm.PostMsg((int)msg, args);
  3322. return true;
  3323. }
  3324. public bool Check(int msg, out string reason, params object[] args)
  3325. {
  3326. if (!fsm.FindTransition(fsm.State, msg))
  3327. {
  3328. reason = String.Format("{0} is in {1} state,can not do {2}", Name, (LoadPortStateEnum)fsm.State, (LoadPortMsg)msg);
  3329. return false;
  3330. }
  3331. reason = "";
  3332. return true;
  3333. }
  3334. public virtual bool FALoad(out string reason)
  3335. {
  3336. reason = "";
  3337. return true;
  3338. }
  3339. public virtual bool FAUnload(out string reason)
  3340. {
  3341. reason = "";
  3342. return true;
  3343. }
  3344. public virtual bool WriteRfid(string cid, int startpage, int length, out string reason)
  3345. {
  3346. reason = "";
  3347. return true;
  3348. }
  3349. public virtual bool ReadRfId(out string reason)
  3350. {
  3351. reason = "";
  3352. return true;
  3353. }
  3354. public object[] CurrentParamter { get; private set; }
  3355. public virtual DeviceState State
  3356. {
  3357. get
  3358. {
  3359. if (CurrentState == LoadPortStateEnum.Idle)
  3360. {
  3361. return DeviceState.Idle;
  3362. }
  3363. if (MapError || ReadCarrierIDError || CurrentState == LoadPortStateEnum.Error)
  3364. {
  3365. return DeviceState.Error;
  3366. }
  3367. if (IsBusy)
  3368. return DeviceState.Busy;
  3369. return DeviceState.Unknown;
  3370. }
  3371. }
  3372. public string InfoPadCarrierType { get; set; }
  3373. }
  3374. public enum LoadPortStateEnum
  3375. {
  3376. Undefined = 0,
  3377. Init,
  3378. Initializing,
  3379. Homing,
  3380. Resetting,
  3381. Idle,
  3382. Mapping,
  3383. Loading,
  3384. Unloading,
  3385. Executing,
  3386. Error,
  3387. ReadingData,
  3388. WrittingData,
  3389. TransferBlock,
  3390. };
  3391. public enum LoadPortMsg
  3392. {
  3393. Init,
  3394. StartReadData,
  3395. StartWriteData,
  3396. Load,
  3397. Unload,
  3398. Reset,
  3399. StartExecute,
  3400. StartHome,
  3401. InitComplete = 10,
  3402. ReadComplete,
  3403. WriteComplete,
  3404. LoadComplete,
  3405. UnloadComplete,
  3406. ResetComplete,
  3407. HomeComplete,
  3408. Error,
  3409. Abort,
  3410. Stop,
  3411. MoveComplete,
  3412. ActionDone,
  3413. StartAccess,
  3414. CompleteAccess,
  3415. ToIdle
  3416. }
  3417. public enum DispatchLPType
  3418. {
  3419. NA,
  3420. Loader,
  3421. Unloader,
  3422. }
  3423. public enum E84DeviceTypeEnum
  3424. {
  3425. None,
  3426. Internal,
  3427. External,
  3428. }
  3429. public class E84SigState
  3430. {
  3431. public bool LightCurtain { get; set; }
  3432. public bool CS_0 { get; set; }
  3433. public bool CS_1 { get; set; }
  3434. public bool AM_AVBL { get; set; }
  3435. public bool VALID { get; set; }
  3436. public bool TR_REQ { get; set; }
  3437. public bool BUSY { get; set; }
  3438. public bool COMPT { get; set; }
  3439. public bool CONT { get; set; }
  3440. public bool L_REQ { get; set; }
  3441. public bool U_REQ { get; set; }
  3442. public bool VA { get; set; }
  3443. public bool READY { get; set; }
  3444. public bool VS_0 { get; set; }
  3445. public bool VS_1 { get; set; }
  3446. public bool HO_AVBL { get; set; }
  3447. public bool ES { get; set; }
  3448. }
  3449. public enum ManualSwHandleEnum
  3450. {
  3451. None,
  3452. Clamp,
  3453. Load,
  3454. ProceedWithCarrier,
  3455. }
  3456. }