Model-based analysis of nonblocking control sequences for lineair cluster tools R. van de Wouw
SE 420617
Bachelor Eindproject Supervisor: Advisors:
Prof.dr.ir. J.E. Rooda Dr.ir. J.M. van de Mortel-Fronczak Ing. H.W.A.M. van Rooy
Technische Universiteit Eindhoven Faculteit Werktuigbouwkunde Systems Engineering Group
Eindhoven, juni 2010 0
0
i
ii
Samenvatting De opdracht was enkele modellen van lineaire cluster tools in een grafisch programma te modelleren en hier vervolgens supervisor syntheses en simulatie experimenten mee uit te voeren. De modellen zijn gedefinieerd in een hieraan voorafgaand afstudeerproject. Het grafisch programma dat gebruikt is in dit project is een nieuwe tooling genaamd Supervisory Control Integrated Development Environment (SCIDE). Het programma SCIDE is recent ontworpen op de TU/e. Een doel van dit project is dan ook om de aangeleverde modellen in SCIDE te modelleren om hier vervolgens berekeningen mee uit te voeren. Vervolgens wordt er gekeken in welke mate SCIDE daar geschikt voor is. De modellen die gebruikt zijn in dit project zijn bedoeld voor het besturen van lineaire cluster tools. Deze lineaire cluster tools zijn transport en bewerkingssystemen die veel gebruikt worden in de semi-conductor industrie. In dit project is er eerst globaal gekeken naar lineaire cluster tools, waarbij diverse systemen nader uitgelegd zijn. Vervolgens is er gekeken naar supervisor synthese. Vervolgens met de kennis en opbouw van de modellen is men begonnnen met de tooling SCIDE te introduceren. Aangezien er geen handleiding voor het gebruik van SCIDE beschikbaar is, is er begonnen met het invoeren van eenvoudige modellen. Vervolgens zijn deze modellen steeds uitgebreid tot de modellen die aangeleverd waren. Deze zijn ingevoerd en vervolgens zijn hier supervisors van gesynthetiseerd. Deze supervisors zijn vervolgens getest met een simulatie experiment. Hieruit bleek of de supervisors voldeden aan de systeemvereisten welke men aan de systemen gekoppeld had. Hierna is SCIDE geëvalueerd door een opsomming van enkele voor- en nadelen welke tijdens het gebruik ondervonden zijn. Ook worden nog enkele aanbevelingen gedaan voor de verdere ontwikkeling van SCIDE in de toekomst.
iii
iv
INHOUD Opdrachtomschrijving ............................................................................... i Samenvatting .............................................................................................. iii 1
Inleiding ................................................................................................. 1
2
Lineaire Cluster Tools ....................................................................... 3
3
Supervisor synthese ............................................................................ 7
4
Case study ............................................................................................. 9 4.1 Werking SCIDE .......................................................................... 10 4.2 Synthese binnen SCIDE. ........................................................... 15 4.3 Simuleren van supervisor .......................................................... 20 4.4 Modellen compleet uitgewerkt................................................. 25 4.5 Evaluatie en ervaring SCIDE ................................................... 33
5
Conclusie.............................................................................................. 35
Literatuurlijst ............................................................................................ 37 Bijlagen ....................................................................................................... 39
I. SCIDE model 1-link.............................................................................. 40 II. SCIDE model 2-link.............................................................................. 42 III. Gantt chart 1-link model, test 1 ......................................................... 45 IV. SCIDE model link 1, test 1 .................................................................. 46 V. SCIDE model met tijd link 1, test 1 .................................................. 48 VI. Gantt chart 2-link model, test 2 ......................................................... 49 VII. SCIDE model 2-link, test 2 ................................................................. 50 VIII. SCIDE model met tijd, 2-link, test 2 ................................................. 52
0
0
1 Inleiding Elke fabriek, groot of klein, heeft een bepaalde infrastructuur. Bij kleine fabrieken soms overzichtelijk, bij grotere fabrieken al snel niet meer. In elke fabriek staan machines die producten verplaatsen of bewerken. De productie in deze machines moet altijd efficiënter want men wil zoveel mogelijk producten verwerken per uur. Zodoende zal er continu gekeken worden of en waar er nog wat verbeterd kan worden. Zo ook in de semiconductor industrie waar men veel gebruik maakt van bewerkings- en transportmachines, welke steeds nauwkeuriger en efficiënter moeten kunnen werken. Deze machines bestaan vaak uit meerdere bewerkingsstations waar door robots producten aangeleverd worden. De robots zorgen dan voor alle verplaatsingen tussen de bewerkingsstations. Het ontwerpen en programmeren van de besturing van dit soort machines neemt veel tijd in beslag en is erg duur. Zodoende wordt er veel gebruik gemaakt van programma’s waarbij in relatief korte tijd een systeemmodel ingevoerd kan worden om daar vervolgens simulatie experimenten mee uit te voeren. Een van deze programma’s is Supervisory Control Integrated Development Environment (SCIDE). Deze tooling is recent ontworpen en is nog in de beginfase. Door gebruik van deze tooling kan men op een grafische en relatief efficiënte manier supervisors voor systemen synthetiseren. Vervolgens kunnen deze systemen gesimuleerd worden en kan er gekeken worden of supervisors tijdens de simulatie voldoen aan de verwachtingen en eisen van de machines. Om een goed model bij SCIDE in te kunnen voeren moet men goed bedenken wat de machine allemaal kan, en wat er gewenst is. Vervolgens kan men hier de juiste modellen voor in voeren en vervolgens SCIDE aansturen om een goede besturing van het systeem te synthetiseren. Ook is het belangrijk dat bij deze systemen de recepten van verschillende bewerkingen welke op de producten worden uitgevoerd makkelijk veranderd kunnen worden. Zo moet het mogelijk zijn dat dezelfde producten in eenzelfde machine een verschillend recept van bewerkingen ondergaan bij eenzelfde besturing. Aangezien SCIDE recent ontworpen is en nog met regelmaat verbeterd wordt is er in dit project gekeken in welke mate SCIDE momenteel bruikbaar is voor supervisor synthese en het vervolgens simuleren van supervisors van lineaire cluster tools.
1
2
2 Lineaire Cluster Tools Onder semi-conductor industrie vallen de transport- en bewerkingsapparatuur waarmee de fabricage van chips wordt gedaan. Zo dienen de chips vaak in vele aparte procesmodules bewerkt te worden. Om deze bewerkingen zo efficiënt mogelijk uit te voeren worden de procesmodules vaak in één machine geplaatst waar meerdere bewerkingen plaats vinden. Tegenwoordig vindt men in de semi-conductor industrie steeds meer lineaire cluster tools. Lineaire cluster tools zijn losstaande systemen, waarin diverse bewerkingsprocessen achtereenvolgens plaatsvinden. Er bestaan zowel lineaire cluster tools als traditionele cluster tools. Traditionele cluster tools zijn systemen waarin alle procesmodules rondom een centrale transport robot staan. Bij lineaire cluster tools is het systeem opgebouwd uit links, welke bestaan uit een loadlockmodule, buffermodules, transportrobots en meerdere procesmodules. Schematische modellen van deze cluster tools kan men zien in f. 2.1 Link 1
Link 2
Link 3
f. 2.1 Verschillende soorten cluster tools [1]
Vanuit de loadlock worden de producten aangevoerd. De transport robot zorgt voor het transport van de producten tussen alle modules binnen 1 link. In de bewerkingsmodules worden de producten bewerkt, wat een bepaalde tijd in beslag neemt. De buffermodules zijn de interfaces van de links en dienen als tijdelijke opslaglocatie waarbij vanuit beide links producten in geplaatst kunnen worden. Deze producten kunnen door de andere link weer opgehaald worden voor verdere bewerking. Deze buffermodule kan meerdere producten tegelijkertijd opslaan. De buffer grootte is afhankelijk van de specificaties van de buffermodule. De producten die de cluster tool betreden zullen een vooraf geregelde route van bewerkingen volgen, het ‘recept’. Een traditionele cluster tool functioneert als volgt: Een loadlock voert de producten aan die vervolgens door een centrale robot verplaatst worden tussen de aanliggende procesmodules. Elk product dient in de procesmodules bewerkt te worden. De robot transporteert de producten telkens na bewerking in een procesmodule naar een volgende procesmodule. Zo kunnen er aan een traditionele cluster tool veel procesmodules gekoppeld worden. 3
Een lineaire clustertool is zoals hierboven besproken opgebouwd uit links, welke alle een eigen robot hebben. Aan elke link kunnen maximaal 4 modules gekoppeld zitten, waarbij de eerste link standaard een loadlockmodule heeft. Binnen dit project wordt de naamgeving van de modules binnen een lineaire cluster tools als volgt genoteerd. De module naam eindigt met een getal met 2 cijfers, waarvan het eerste nummer verwijst naar de link, en het tweede nummer naar de positie van de module. Zo heet de eerste procesmodule van link 1 ‘PM11’. In Fig 2.2 is schematisch te zien hoe de posities van de modules in een lineaire cluster tool gedefinieerd zijn voor een 1 link systeem. Zo is aan de linkerkant van de robotmodule 0, boven 1, onder 2 en rechts module 3 gedefinieerd.
Fig. 2.2 Naamgeving modules
Het blijkt dat er steeds meer behoefte is aan het sneller, flexibeler en dynamischer functioneren van een cluster tool in de semiconductor industrie. Dit betekent dat de procestijden in de procesmodules steeds korter worden, er moeten meer bewerkingen gedaan worden en het transport van de producten moeten sneller verlopen. Als gevolg van deze behoefte is een lineaire cluster tool ontworpen. Enkele voordelen van een lineaire cluster zijn als volgt: [2]
Verkorte procestijden in de procesmodules leiden tot grotere doorzet van de cluster tool. Deze grotere doorzet zal bij een traditionele cluster tool leiden tot vertraging. Door de verkorte procestijden zal de robot in een traditionele cluster tool een bottleneck vormen. Bij lineaire cluster tools heeft elke robot maar één tot maximaal drie procesmodules welke hij moet bedienen, waardoor de robot minder snel een bottleneck vormt dan bij een groter aantal procesmodules.
Recept flexibiliteit Het veranderen van het te doorlopen recept van de producten en het toevoegen van extra procesmodules is bij een lineaire cluster mogelijk door het uitbreiden van de tool met een extra link. Door de buffermodules en meerdere transportrobots is een lineaire cluster tool flexibeler wat betreft het te doorlopen recept dan bij een traditionele cluster tool, wat betekent dat je meer geavanceerde processen kunt uitvoeren in dezelfde tool. 4
Door de grote flexibiliteit van een lineaire cluster tool, zal men ook enkele beperkingen moeten toevoegen. Deze beperkingen zullen ervoor zorgen dat het systeem enkel de handelingen en bewerkingen kan uitvoeren welke gewenst zijn, zodat het systeem optimaal werkt en dat er geen deadlock ontstaat. Deadlock wil zeggen dat het systeem vastloopt. Enkele oorzaken van deadlock zijn [2]:
Overbeladen Wanneer de cluster tool het maximaal aantal producten binnen een systeem of link aan het bewerken is zal hier geen extra product aan toegevoegd kunnen worden, zowel niet vanuit de loadlock- als buffermodule zoals schematisch weergegeven in Fig. 2.3
Synchroon plaatsen Het tegelijkertijd plaatsen van een product in een 1-plaats buffermodule vanuit twee links zal leiden tot deadlock. Een 1-plaats buffer kan maar 1 product opslaan zodoende zal dit een deadlock opleveren, zoals schematisch is weergegeven in Fig. 2.3
Fig. 2.3 overbeladen (links) en synchroon plaatsen (rechts)
In de figuren hierboven staan blauwe cirkels welke producten voorstellen, wafers bijvoorbeeld. In deze figuren is duidelijk schematisch geïllustreerd hoe de producten in een lineaire clustertool geplaatst zijn, ook zijn hier de bewegingen van de robot weergeven. Het optimaal functioneren van een cluster tool zal voor een groot deel beïnvloedt worden door de eigenschappen en de prestaties van de specifieke procesmodules. Ook zal het af te leggen traject tussen de procesmodules, het recept van de producten, invloed hebben op de performance van de gehele cluster tool. Enkele voorbeelden van factoren die invloed hebben op het optimaal functioneren zijn: [2]
Robot optimalisatie Wanneer een robot een product naar de volgende procesmodule moet transporteren zal hij wanneer mogelijk of met de klok mee moeten draaien of tegen de klok in, waarbij hij op precies dezelfde plaats terecht moet komen. Wanneer het product een kwartslag verplaatst moet worden zal bij gelijke draaisnelheden de robot sneller zijn door een kwartslag met de klok mee te draaien ipv driekwart tegen de klok in te draaien. Zie Fig. 2.4 5
Procesmodules optimalisatie Door de procesmodules zo in de lineaire cluster tool te positioneren dat er geen onnodige verplaatsingen door de robot worden verricht. Zo zal bijv. bij een 2 link lineaire cluster tool eerst een bewerking in procesmodule 11 plaatsvinden waarna vervolgens naar link 2 getransporteerd wordt voor verdere bewerkingen. Vervolgens zal het product bewerkt worden in de procesmodules van link 2 alvorens deze weer via de buffermodule naar link 1 getransporteerd wordt. In link 1 zullen vervolgens in procesmodule 12 de laatste bewerkingen plaatsvinden alvorens weer uit het systeem te worden gehaald via de loadlockmodule. Zo zullen er geen onnodige bewegingen van de robot plaatsvinden.
Fig. 2.4 robot optimalisatie
Het figuur hierboven geeft aan dat bij een 1 link systeem met 3 procesmodules waarbij telkens maar 1 product bewerkt wordt, de robot de kortste weg aflegt door steeds een kwartslag met de klok mee te draaien. De robot zou hetzelfde recept ook kunnen doorlopen door telkens driekwart tegen de klok in te draaien, wat niet efficiënt is.
6
3 Supervisor synthese Het is nu bekend hoe een lineaire cluster tool is opgebouwd, hoe het werkt en hoe het geoptimaliseerd kan worden. Het is duidelijk wat het systeem allemaal kan, echter is er vaak maar een gedeelte hiervan benodigd voor het uitvoeren van de geplande bewegingen en bewerkingen. Het overige gedeelte is overbodig en dient uitgeschakeld of geblokkeerd te worden. Dit blokkeren kan gedaan worden door het opleggen van supervisor. De supervisor is een model waarin alle informatie staat wat het systeem mag. De supervisor controleert steeds alle handelingen die het systeem kan en vergelijkt dit met de handelingen die mogen. Zodoende zal de supervisor de overbodige en ongewenste bewegingen en bewerkingen blokkeren. Ook kun je aan deze supervisor eisen toevoegen over hoe de bewegingen en bewerkingen en in welke volgorde ze uitgevoerd moeten worden. De supervisor zal dus het gehele gedrag van het systeem bepalen. Voor kleine systemen is deze supervisor gemakkelijk zelf uit te rekenen, maar bij grotere systemen zijn hier tools voor ontworpen. Met deze tools kan men gemakkelijk een supervisor synthetiseren. Er zijn verschillende tools beschikbaar voor dit soort berekeningen, enkele hiervan zijn Supremica, TCT en SCIDE. [5] Een van de deze tooling welke in dit verslag nader uitgelegd wordt is Supervisory Control Integrated Development Environment (SCIDE). Dit is een tool waarbij in een grafische omgeving het gehele systeem ingevoerd kan worden. Zo kan men met deze tooling het gehele systeem in modellen zetten. De supervisor zal pas gesynthetiseerd kunnen worden wanneer deze modellen goed gedefinieerd zijn. Hiervoor zullen vooraf 2 soorten modellen aangeleverd moeten worden. Zowel de procesmodellen als de requirement modellen dienen gedefinieerd te zijn. De plantmodellen waarin de gehele structuur van de cluster tool aangegeven is, geven aan wat het systeem allemaal kan. De requirement modellen zullen zo gedefinieerd zijn dat deze alle bewegingen en bewerkingen blokkeren welke ongewenst zijn. De supervisor wordt gesynthetiseerd door het combineren van zowel een model met alle mogelijkheden van het systeem en een model met alle mogelijkheden die gewenst zijn. Dit is schematisch te zien in Fig. 3.1
Fig. 3.1 supervisor synthese model. De rode pijlen van het proces model zijn wederzijdse pijlen.
7
Het optimaliseren zoals beschreven is op pagina 5 en 6. zal pas kunnen gebeuren nadat er een non-blocking supervisor gesynthetiseerd is. Na deze synthese kan men de supervisor optimaliseren met diverse optimalisatiecriteria. Enkele criteria zijn: throughput, WorkInProgress (WIP) en totale cyclustijd.
8
4 Case study Het doel van dit project is om een nieuwe tool genaamd Supervisory Control Integrated Development Environment (SCIDE) [4] te evalueren. Deze tooling is ontworpen op de TU/e. Bij dit project zal niet alleen worden gekeken naar het al dan niet functioneren van de supervisor. Er zal ook gekeken worden in hoeverre SCIDE geschikt is voor de analyse van de gesynthetiseerde supervisor. Aangezien deze mogelijkheden die SCIDE biedt beperkt zijn, dienen er ook ideeën geopperd te worden betreffende eventuele betere mogelijkheden tot het valideren van de supervisor. Dit zal aan de hand van deze case study duidelijk worden. Het uitgangspunt van dit project is de master’s thesis van P.A.W. van Overmeire, getiteld ‘Nonblocking and time-optimal scheduling for Lineair Cluster Tools’ [2]. Het doel van dat project was het vinden van een juiste methode om Supervisory Control Theory, geïntroduceerd door Ramagde en Wonham, te combineren met de bepaling van een tijd optimale sequentie [3],[6]. Dit is gedaan voor een lineaire cluster tool, welke uitgelegd is in hoofdstuk 1. Door steeds de lineaire cluster tool uit te breiden met een extra link zal ook de supervisor ingewikkelder worden. Zo is de lineaire cluster tool in dat project uitgebreid tot een 12 links lineaire cluster tool welke opgebouwd was uit totaal 12 robots, 11 buffers, 25 procesmodules en een loadlockmodule. Bij deze grootte van cluster tools is het onmogelijk om de supervisor met de hand uit te rekenen. Zelfs bij een 2 links lineaire cluster tool is het momenteel met de computer al moeilijk, door de grootte van de supervisor. Tijdens dit project is er gebruik gemaakt van de tooling SCIDE. Deze tooling is binnen de groep Systems Engineering ontworpen. Gezien deze tooling recent ontworpen is wordt deze nog met regelmaat geupdate naar een nieuwere versie [4]. Voor dit project ben ik uitgegaan van versie 1.0.5860.
9
4.1 Werking SCIDE 4.1.1 Opbouw SCIDE model van een 1-link lineaire cluster tool Om enigszins bekend te worden met de tooling is in dit project begonnen met ontwerpen van een 1 link lineaire cluster tool, welke veel lijkt op een standaard cluster tool. Eerst worden modellen van de procesmodules genaamd ‘plants’ ingevoerd, welke bestaan uit een loadlock, robot en 3 procesmodules. Voor deze 1 link lineaire cluster tool is gebruik gemaakt van het model uit de Master Thesis van P.A.W van Overmeire. [2] In Fig. 4.1 is een 1-link lineaire cluster tool schematisch weergegeven. Schematische weergave 1-link lineaire cluster tool
Proces Module 11
Loadlock Module 10
Robot 1
Proces Module 13
Proces Module 12
Fig. 4.1 1-link lineaire cluster tool
De modellen die binnen SCIDE ontworpen dienen te worden zijn opgebouwd uit toestanden en transities. De toestanden geven aan wat de conditie is van een product of een module, zoals ‘bewerkt’. Deze transities, ook wel events of acties genoemd, representeren bewegingen of bewerkingen die uitgevoerd kunnen worden. [2] De functie van een loadlockmodule is om zowel een product in het systeem te plaatsen als het ontvangen van een product uit het systeem dat zijn recept doorlopen heeft. In Fig. 4.2 zijn het plant model van een loadlockmodule en een procesmodule schematisch weergegeven. Deze plant modellen dienen in deze vorm ontworpen te worden in SCIDE. Een procesmodule ontvangt een product van de robot na event place_11, bewerkt het daar na event proces_11, en daarna haalt de robot het product weer op na event pick_11.
10
Fig. 4.2 loadlockmodule (links) en procesmodule (rechts)
Ook voor de robot zal er een model ingevoerd moeten worden. Dit model zal alle bewegingen van de robot laten zien. Dit model zal alle handelingen van de robot beschrijven, zowel het draaien (turn, turn_CCW) als het oppakken en neerleggen van de producten (pick, place). Een voorbeeld van zo’n robot model is weergegeven in Fig. 4.3. Hoewel dit een plantmodel is omschrijft het tevens ook enkele requirements. Zo is hierin is te zien dat de robot een product kan pakken, vervolgens vasthouden en weer moet plaatsen. Hiermee wordt omschreven dat een robot te allen tijde een product kan pakken, en weer ergens kan plaatsen. Aan deze handelingen zit maar één enkele eis, dat hij maar één product tegelijk kan pakken, vasthouden en neerleggen. Wanneer de robot geen product vasthoudt, kan hij toch vrij draaien.
Fig. 4.3 Robot buffer
11
Het model van Fig. 4.4 omschrijft alle handelingen die de robot kan doen. Deze handelingen bestaan uit draaien van de robot en pakken en plaatsen van producten. Dit draaien zal op twee manieren kunnen, zowel met de klok mee (Turn) als tegen de clock in (Turn_CCW waarbij CCW staan voor CounterClockWise).
Fig. 4.4 Robotmodule
Voordat er een supervisor gesynthetiseerd kan worden dienen ook de control requirement modellen ingevoerd te worden. Zo zal er een requirement model moeten zijn die vastlegt welke processen er in welke vooraf bepaalde volgorde plaatsvinden, het ‘recept’ van de producten. Deze requirements zijn vaak opgebouwd uit meerdere requirement modellen welke alle zo zijn gedefinieerd dat wanneer er een product uit één van de modules wordt gehaald deze enkel naar de vooraf ingestelde procesmodule geplaatst kan worden, zie Fig. 4.5
Fig. 4.5 voorbeeld requirement model, vormt een deel van het productrecept.
12
Voor dit 1-link systeem zullen deze requirement modellen samen voldoende zijn om een supervisor te kunnen synthetiseren. De plant modellen geven aan wat binnen het systeem allemaal mogelijk is. De requirement modellen geven aan wat gewenst is, dus de volgorde van processen. Dat de robot tijdens het verwerken van een product in een module vrij is om rond te draaien en producten te transporteren heeft verder geen invloed op de bewerkingen van de producten. De robot moet enkel ervoor zorgen dat de verplaatsingen op tijd gebeuren, zodat het recept van bewerkingen welke vooraf is ingesteld te volbracht wordt. Dit is dus tot op heden in dit model dan ook onafhankelijk van de tijd. In de tooling kan een supervisor als volgt gesynthetiseerd worden. Er wordt een product gemaakt van alle plants, en een product van alle requirements. Deze producten bevatten alle informatie van wat het systeem kan en wat er gewenst is. Uit deze twee producten wordt vervolgens een supervisor gesynthetiseerd. Dit is schematisch weergegeven in Fig. 4.6.
Fig. 4.6 supervisor synthese model binnen SCIDE
Het SCIDE model van de 1-link lineaire cluster tool is compleet met supervisor synthese model uitgewerkt te zien in bijlage I.
13
4.1.2 Opbouw SCIDE model van een 2-link lineaire cluster tool Wanneer men een grotere lineaire cluster tool gaat gebruiken, zal het model uitgebreid moeten worden. Aangezien elke link maximaal 4 modules kan bedienen, zullen er meerdere links aan elkaar gekoppeld worden. Dit koppelen wordt gedaan met een buffermodule. Deze module kan zowel producten ontvangen vanuit beide links en kan wanneer mogelijk tijdelijk één of meerdere producten opslaan, afhankelijk van het type buffermodule. Echter is het in ons systeem maar een 1-plaats buffermodule waarbij het niet mogelijk is een product op te slaan en een tweede product te verplaatsen tegelijk.
Fig. 4.7 Buffermodule
In Fig. 4.7 is een schematische weergave van een 1-plaats buffermodule te zien. Hierbij kan men zien dat deze vanuit beide aanliggende links producten kan ontvangen en deze weer terug kan plaatsen bij de andere link. Een 2-link lineaire cluster tool is opgebouwd uit twee losse links, welke beide 4 losse modules kunnen bedienen. Een schematische weergave van deze clustertool is te zien in Fig. 4.8. Totaal heeft deze cluster tool 2 robots, 1 loadlockmodule, 5 procesmodules en een buffermodule. Het SCIDE model van de 2-link lineaire cluster tool is compleet met supervisor synthese model uitgewerkt te zien in bijlage II. Schematische weergave 2-link lineaire cluster tool
Proces Module 11
Loadlock Module 10
Robot 1
Proces Module 12
Proces Module 21
Buffer module 13 / 20
Robot 2
Proces Module 23
Proces Module 22
Fig. 4.8 2-link lineaire cluster tool
14
4.2 Synthese binnen SCIDE. Nu alle plant en requirement modellen in SCIDE gemodelleerd zijn kan men de supervisor gaan synthetiseren. Dit gebeurt ook in SCIDE zelf. Met verschillende commando’s zet men SCIDE aan tot het berekenen van de supervisor. Dit berekenen kan in de meeste gevallen niet met de hand gedaan worden. Deze synthese gebeurt geheel door en binnen SCIDE zelf, zonder dat men er zelf aan hoeft te rekenen. De supervisor is een automaat welke het gedrag van het systeem of proces regelt en enkel de events en acties welke toegestaan zijn laat uitvoeren. Op deze manier gedraagt het systeem zich naar het vooraf bepaalde gedrag en zal niet blokkeren. Om snel een indruk van de omvang en complexiteit van de supervisor te krijgen kan men kijken naar de hoeveelheid toestanden (states) en acties (transities) van de supervisor. Bij het visualiseren van deze supervisor ziet deze er dan uit als een model waarbij de toestanden zijn aangegeven met cirkels en alle transities met pijlen. Hier is dan ook gemakkelijk te zien bij elke toestand welke transities mogelijk zijn. De supervisor is correct wanneer er in elke toestand de mogelijke acties doorlopen kunnen worden en waarbij men dan uiteindelijk op dezelfde eindresultaten of dezelfde doorlopen recepten uitkomt.
15
4.2.1 Supervisor synthese van een 1-link systeem. De supervisor synthese wordt binnen SCIDE grafisch weergeven. Zoals men in het supervisor synthese model in bijlage A.1 kan zien wordt de supervisor gesynthetiseerd uit een samenstelling van alle plantmodellen en alle requirement modellen. Men kan hier de opbouw zien van de synthese. Door nu enkele commando’s te geven in het window kan men de supervisor genereren. De volgende commando’s worden gebruikt, waarbij default staat voor de naam van het SCIDE model. Om de supervisor te synthetiseren vanuit het SCIDE model dient men de volgende commando’s te geven [4]. Deze zetten het supervisor synthese model wat binnen SCIDE gemodelleerd is aan tot het synthetiseren. Supervisor synthese 1. >> scim2cif -g yes default.scim 2. >> ./default_synth_sup
De supervisor synthese van een 1-link systeem is schematisch weergegeven in Fig. 4.9 1-link supervisor synthese model G1 Supervisor synthese
Supervisor
H1 1.
1.
Synthese van supervisor uit plantmodellen G1 en requirementmodellen H1
Fig. 4.9 supervisor synthese van 1-link model
16
4.2.2 Supervisor synthese van een 2-link systeem. Een supervisor van dit 2-links model is anders dan die van een 1-link model. Bij dit model is er gekozen om de andere manier van supervisor synthese te gebruiken voor een systeem met meerdere links. Zo is hier gekozen voor een gedistribueerde supervisor. Een gedistribueerde supervisor wordt gebruikt voor grotere systemen die opgesplitst kunnen worden in deelsystemen. Bij gedistribueerde supervisors wordt er voor elk los deelsysteem een locale supervisor gesynthetiseerd. Een gedistribueerde supervisor wordt vervolgens gesynthetiseerd uit de locale supervisors. Wanneer de interacties tussen deelsystemen conflicterend zijn, dient er ook nog een coördinator gesynthetiseerd te worden. De gedistribueerde supervisor wordt dan opgebouwd uit de locale supervisors en de coördinator. Alle locale supervisors eventueel uitgebreid met coördinatoren werken samen als een ‘team’ om het gehele systeem functionaliteit te geven. Zo wordt er zowel van link 1 als link 2 een locale supervisor gesynthetiseerd, S1 en S2. Vervolgens dienen deze twee locale supervisors gecheckt worden op conflicten. Wanneer er conflicten zijn tussen de locale supervisors dient men een coordinator te synthetiseren. Gezien de complexiteit van de supervisors is het erg raadzaam om van deze supervisors abstracties te nemen welke dan gebruikt worden voor de coordinator synthese. Deze abstracties dienen net zoals de modellen non-blocking te zijn. Om de abstracties uit te rekenen dient een specifiek alfabet, aangeduid met ∑’, bepaald te worden. Dit alfabet bevat informatie over de acties welke belangrijk zijn om de abstractie te maken. Een abstracte is het weglaten van events die niet van invloed zijn op de interacties tussen de deelsystemen. Zodoende zullen het kleinere en minder gecompliceerde modellen worden. De acties die nog meegenomen worden in de gedistribueerde supervisor zijn voornamelijk de in- en uitvoer van de losse systemen. Zo zijn de acties die zorgen voor de toe- en afvoer van producten naar de buffermodule hierin ook meegenomen. Van de abstracties wordt vervolgens de coordinator gesynthetiseerd. Deze synthese van coordinator S3 kan men doen vanuit de twee abstracties (W1 en W2) in combinatie met een requirementmodel. Dit requirementmodel zal de onderlinge acties tussen beide systemen moeten coördineren en alle acties verbieden welke ongewenst zijn. Deze gedistribueerde supervisor is vervolgens de collectie {S1, S2, S3}. De bijbehorende functies voor het maken van een abstractie vanuit een plantmodel en een supervisor kunnen niet vanuit SCIDE aangeroepen worden. Zoals men binnen SCIDE een grafisch model op kan stellen voor het synthetiseren van een supervisor is het nog niet mogelijk om binnen SCIDE een grafisch SCIDE model op te stellen om een abstractie te maken.
17
Om een abstractie te maken dient men zelf nog commando’s in te voeren. Zo worden er voor de abstracties te maken de volgende commando’s gebruikt: [4] Abstractie van supervisor met plantmodellen. Voor link 1 >> make_sequential_abstraction(‘superlink1.cfg’, ‘tau, ∑’ link 1’, ‘superlink1ab.cfg’) Voor link 2 >> make_sequential_abstraction(‘superlink2.cfg’, ‘tau, ∑’ link 2’, ‘superlink2ab.cfg’)
Waarbij geldt: superlink1 = locale supervisor link 1 gesynchroniseerd met de plant ∑’ link 1 = alphabet van acties van link 1 superlink1ab = abstractie van link 1 reqlink12 = requirement model voor interface tussen link 1 en link 2 Vervolgens kan men met de volgende commando’s de coördinator van link 1 en link 2 synthetiseren. [4] Sythese van Coordinator S3 voor link 1 en link 2 >> frontend.make_product (‘superlink1ab.cfg, superlink2ab.cfg’, ‘link12.cfg’) >> frontend.make_supervisor(‘link12.cfg’, ‘reqlink12.cfg’, ‘coordinator12.cfg’)
Het is mogelijk om zo voor zeer grote systemen coördinators uit te rekenen. Men dient telkens van twee modellen met locale supervisors een abstractie te maken, en deze vervolgens bij elkaar te voegen tot een nieuw model met een coordinator, telkens op dezelfde manier als hiervoor besproken. De synthese van de coördinator van dit 2-link model is vanuit de twee losse links schematisch weergegeven in Fig. 4.10.
18
2-link supervisor synthese model
S3
Supervisor synthese
H3
3. W1=(G1 x S1)/
(
A
{ })
' A
W2=(G2 x S2)/ (
Abstractie
B
{ })
B
'
Abstractie 2.
2.
G1
G2 Supervisor synthese
Supervisor S1
H1
Supervisor synthese
Supervisor S2
H2 1. Link 1
1. 2. 3.
1. Link 2
Synthese van lokale supervisor voor link 1 (G1 en H1) en link 2 (G2 en H2) Abstractie van link 1 (G1 en S1) en link 2 (G2 en S2) Synthese van coordinator S3 voor link 1 en link 2 (abstractie W1 en W2 en requirementmodel H3)
Fig. 4.10 supervisor synthese van 2-link model
19
4.3 Simuleren van supervisor Nu de supervisor gesynthetiseerd is kan men deze testen. Dit testen kan op verschillende manieren, maar één daarvan is het doorlopen van de supervisor. Dit doorlopen is een manier van het simuleren van de supervisor. Bij dit simuleren heeft men steeds de keuze uit verschillende acties en bewerkingen die niet door de supervisor geblokkeerd zijn. Welke keuze men ook maakt, uiteindelijk moeten de producten hetzelfde recept van bewerkingen gevolgd hebben. Zo zal een product eerst verplaatst moeten worden voordat het bewerkt kan worden in de volgende procesmodule.
4.3.1 Simulatie van modellen zonder tijd. Om vervolgens de gesynthetiseerde supervisor te simuleren kan men met de volgende commando’s de simulatie starten[4]. Supervisor untimed simulation 1. >> simcif default_supervisor.core.cifx
Bij dit simuleren komt men steeds voor de keuze welke acties en bewerkingen er op welke volgorde gedaan moeten worden. Na het traject doorlopen te hebben is het met SCIDE ook mogelijk om dit traject te visualiseren in de modellen. Zo kan men met commando’s alle modellen openen, en vervolgens alle acties en bewerkingen welke gedaan zijn in stappen weergeven. Zo ziet men precies welk plantmodel in welke toestand is. De commando’s voor het visualiseren staan hieronder[4]. Supervisor visual automata untimed simulation 1. >> scim2cif -p yes -o default_plants.core.cifx default.scim 2. >> merge_cif -o default_plants_supervisor.core.cifx -m default_plants_supervisor default_plants.core.cifx default_supervisor.core.cifx 3. >> simcif default_plants_supervisor.core.cifx
20
Vervolgens krijgt men steeds de transities te zien welke mogelijk zijn. Door een van de keuzes te maken gaat men naar de volgende ‘toestand’ en kan men de volgende transitie kiezen. Een voorbeeld van mogelijke transitie keuzes is te zien in Fig. 4.11
Fig. 4.11 simulatie voorbeeld
21
4.3.2 Simulatie van modellen met tijd. Het gedrag van een lineaire cluster tool in combinatie met de supervisor kan getest en gesimuleerd worden met een simulatie met tijd. Zo kan er gekeken worden of er geen kritieke situaties ontstaan. Een voorbeeld van deze kritieke situaties is het vol zijn van een buffermodule. De buffermodule zoals deze in dit project gekozen is kan immers niet meer dan 1 product vasthouden. Als gevolg kunnen er geen producten in de buffermodule geplaatst worden voordat het vorige product uit de buffermodule is gehaald. Nu we ook tijden aan de acties gaan koppelen zal blijken of het systeem nog steeds nonblocking en deadlock vrij is. Vervolgens kan men het systeem gaan optimaliseren naar een non-blocking time-optimal lineair cluster tool. Deze simulatie met tijd kan worden gedaan in SCIDE. Nu dient er nog tijd toegevoegd te worden aan de events en acties, wil men een simulatie met tijd uitvoeren. Deze tijd kan men toevoegen aan de plantmodellen waaruit de supervisor gesynthetiseerd is. In het model met tijd hoeven enkel de events en acties die tijd kosten gemodelleerd te worden. Wanneer acties in de plant modellen met tijd meerdere keren voorkomen behoeft er maar een enkele keer de tijd aan gekoppeld te worden, welke bij de rest van de plantmodellen dan ook zal gelden. De plantmodellen welke geen events met tijd hebben zullen niet meegenomen hoeven te worden in het model met tijd. Voor de modellen met tijd dient men ook rekening te houden met het aanloopverschijnsel. Zo is het mogelijk om in de modellen met tijd al het aanloopverschijnsel te verwerken, zo zal er dus ook in de plantmodellen met tijd een opstartverschijnsel zichtbaar zijn welke alle bewerkingen en acties op de juiste volgorde weergeeft, alvorens er een constante cyclus ingesteld wordt. Deze constante cyclus, het recept, is een gesloten lus en zal zich na het aanloopverschijnsel continu herhalen. Door vervolgens de supervisor te koppelen aan het model met de getimede events / acties met tijd zal er een tijdsafhankelijke simulatie uitgevoerd kunnen worden. Een schematische weergave van de supervisor synthese en de opbouw van een simulatie met tijd is weergegeven in Fig. 4.12 Supervisor synthese en simulatie met tijd G1, met tijd
Tijd toevoegen aan plantmodellen
2.
Supervisor synthese
Simulatie resutlaten
Simulatie
G1 Supervisor
3.
H1 1. 1. 2. 3.
Synthese van supervisor uit plantmodellen G1 en requirementmodellen H1 tijd toevoegen aan plantmodellen G1, als resultaat plantmodellen G1, met tijd Simulatie van de supervisor met de plantmodellen met tijd.
Fig. 4.12 algemeen model voor simulatie met tijd
22
Wanneer de producten alle volgens hetzelfde recept bewerkt dienen te worden zal een lineaire cluster tool na verloop van tijd een constante cyclus gaan doorlopen, de steady state. Deze cyclus zal pas constant worden nadat de aanlooptijd verstreken is. Deze lengte van de aanlooptijd is geheel afhankelijk van het model en de gekozen procestijden. Na de aanlooptijd zal het systeem continu dezelfde cyclus gaan doorlopen. Een lineaire cluster tool waarbij de producten telkens eenzelfde doorloopcyclus met vooraf bepaalde route en bewerkingen dienen te volgen, zal na verloop van tijd een cyclustijd instellen. Men kan tijd aan een actie of event toevoegen door er een klok aan te koppelen. Deze klok loopt continu met tijdstappen van 1.0 seconde. Zo kan men meerdere klokken gebruiken, mochten er events of acties tegelijkertijd plaatsvinden. Aan elke getimede actie kan men een guard en of een update koppelen. De guard is een eis waaraan voldaan moet worden voordat de actie plaats kan vinden. Vervolgens kan men tijdens of na de actie de klok updaten naar een gewenste waarde. Hierdoor wordt het mogelijk gemaakt om bij eenzelfde timer de gesloten lus te laten herhalen. Hierbij wordt voor elke actie binnen de gesloten lus eenzelfde tijdklok gebruikt, welke na elke laatste actie van de gesloten lus gereset wordt. Hierdoor zal deze continu dezelfde cyclus doorlopen. Om vervolgens een simulatie met tijd te doen dient men weer enkele commando’s uit te voeren. Voor het samenvoegen van de supervisor met de plantmodellen met tijd dient men eerst de volgende commando’s uit te voeren[4]: Samenvoegen van supervisor met plantmodellen met tijd 1. >> cift2cif -o defaulttimedplants.core.cifx default.cift 2. >> merge-cif -o defaulttimedplantssup.core.cifx -m defaulttimedplantssup defaulttimedplants.core.cifx default_plants_supervisor.core.cifx Het simuleren van de supervisor samen met de plantmodellen met tijd: Supervisor simulatie met tijd 2. >> simcif defaulttimedplantssup.core.cifx
Het visualiseren van de werking van het gehele model: Supervisor visual automata timed simulation 4. >> scim2cif -p yes -o defaulttimedplants.core.cifx defaulttimed.scim 5. >> merge_cif -o defaulttimedplantssup.core.cifx -m defaulttimedplantssup defaulttimedplants.core.cifx default_supervisor.core.cifx 6. >> simcif defaulttimedplantssup.core.cifx 23
Wanneer de simulatie gestart is heeft men telkens weer de keuze uit de mogelijkheden welke toegestaan zijn door de supervisor. Echter hangt er aan elke actie of transitie een bepaalde tijd vast welke eerst verstreken moet zijn voordat er een volgende actie of transitie uitgevoerd kan worden. In Fig. 4.13 is te zien dat na elke stap een tijdtransitie plaats moet vinden voordat naar de volgende actie overgegaan kan worden.
Fig. 4.13 simulatie voorbeeld met tijd
24
4.4 Modellen compleet uitgewerkt Met de kennis die men tot nu toe op heeft gedaan in dit project is men in staat simulaties te doen voor diverse kleine systemen. Ter verduidelijking is er besloten aan de hand van twee voorbeelden de complete werking en uitkomsten van SCIDE te presenteren. Er is gekozen voor een 1-link lineaire cluster tool en een 2-link lineaire cluster tool. Bij deze 2-link lineaire cluster tool zal uitgelegd worden hoe men meerdere links aan elkaar kan koppelen waardoor tevens duidelijk wordt hoe meerdere links lineaire cluster tools opgebouwd en gemodelleerd worden in SCIDE. Echter tijdens de uitvoering van beide voorbeelden is er gekozen om het aanloopverschijnsel mee te modelleren, wat achteraf niet nodig bleek te zijn. Zo is er gekozen om eerst voor de systemen een complete Gantt chart uit te werken, welke alle bewerkingen en verplaatsingen al vast legt. Bij het opstellen dient men ervan uit te gaan dat het systeem zich optimaal en zo efficiënt mogelijk gedraagt. Uit deze Gantt chart kan men genoeg informatie vinden om het gehele model met tijd op te stellen. Vervolgens is er gekeken naar het aanloopverschijnsel en wanneer de constante cyclus zich instelt. Hetgeen wat normaal door de supervisor berekent dient te worden is dan reeds uitgerekend met de hand, en zodoende ook gemodelleerd. Zo wordt de supervisor zo beperkt dat de uitkomst identiek is aan het recept wat vooraf is ingevoerd. Door tijdgebrek is het niet meer mogelijk geweest om dit aan te passen. Wel is de uitwerking en uitvoering van deze voorbeelden uitgewerkt te zien in de volgende paragrafen.
25
4.4.1 1-link model met tijd uitgewerkt We hanteren vooralsnog het 1-link lineaire cluster tool, besproken in voorgaand hoofdstuk. De volgende aannames en ontwerpeisen zijn gemaakt: Zo hoog mogelijke throughput. Elke kwartslag draaien van de robot neemt een tijdseenheid in beslag. Een product pakken of plaatsen in een module neemt twee tijdseenheden in beslag. Procestijden van procesmodules: Proces modules PM11 PM13 PM12 Tijdseenheden
15
12
11
De producten zijn oneindig beschikbaar vanuit de loadlock. De producten zijn alle ideaal en klaar om bewerkt te worden De producten dienen alle dezelfde route van bewerkingen te volgen. Bij het opstellen van de Gantt chart van dit systeem blijkt dat er inderdaad sprake is van een aanloopverschijnsel. In bijlage III. staat de Gantt chart van het 1-link model. Het plantmodel van de LoadLockModule met acties met tijd toevoeging pick_10 en place_10 ziet er als volgt uit:
Fig. 4.14 Loadlockmodule met tijd
Na 2.0 seconden wordt de actie pick_10 uitgevoerd waarna op t1=34 wederom een actie pick_10 wordt uitgevoerd. Tijdens deze actie wordt tevens de klok t1 geupdate naar t1=0. Deze twee acties behoren tot het aanloopverschijnsel. Vervolgens zal de loadlockmodule constant dezelfde cyclus gaan doorlopen. Deze cyclus bestaat uit twee acties, welke pas mogen beginnen nadat de guard toestemming gegeven heeft. Tijdens de actie dient de timer weer geupdate te worden. Zo kan men zien dat de guard van de eerste actie 29 is en dus pas mag beginnen na 29 tijdseenheden, vervolgens wordt deze geupdate na t1:=0, 26
waardoor timer t1 op 0 gezet wordt. Bij de tweede actie is de guard 2 en mag dus pas beginnen nadat t1>=2 geworden is. Deze wordt wederom ook na de actie geupdate naar t1:=0. In de gesloten lus kan men duidelijk zien dat de totale doorlooptijd gelijk is aan de totale aantal wacht- en bewerkingstijden van het systeem. Zo blijkt uit de gesloten lus dat de totale doorlooptijd gelijk is aan 29 + 2 = 31 tijdseenheden. Elke 31 tijdseenheden zal er een product in en uit het systeem worden geplaatst. Het model voor procesmodule 11 ziet er uit met de acties met tijd place_11, proces_11 en pick_11, zoals weergegevean in Fig 4.15
Fig. 4.15 Procesmodule met tijd
De andere procesmodules van de 1-link lineaire cluster tool hebben een soortgelijk model, enkel verschillen deze in de tijden van het aanloopverschijnsel en in benamingen van de acties. De getimede acties van deze procesmodules zijn de acties place, proces en pick. Ook uit dit model blijkt de totale doorlooptijd van procesmodule 1 welke na het aanloopverschijnsel wordt ingesteld: 14 + 2 + 15 = 31 tijdseenheden. Het plant model van de robot is weergegeven in Fig. 4.6. Dit model heeft enkel de getimede actie R1_turn. De robot kan ook de actie R1_turnCCW uitvoeren, wat volgens de Gantt chart van dit model vanwege het recept niet efficienter blijkt in het huidige model met ontwerpeisen en bewerkingen.
27
Ook de robot heeft een aanloopverschijnsel en zoals men kan zien bestaat het model met tijd van de robot uit veel toestanden.
Fig. 4.16 Robotmodule met tijd
Het gehele model met alle plantmodellen met tijden is te vinden in bijlage A.5 Door deze plantmodellen te koppelen aan de supervisor die men uit de modellen zonder tijd heeft gesynthetiseerd, zal er een simulatie gedaan kunnen worden. De uitvoering van deze simulatie is gelijk aan de simulatie van het model zonder tijd welke besproken is in voorgaande hoofdstukken. Echter zal men bij elke actie met tijd de desbetreffende tijdstap moeten maken voordat het in de volgende toestand terecht kan komen. Zodoende kan men voor de gewenste cyclus welke opgesteld is in de Gantt chart een simulatie doen en concluderen of het wel of niet werkt zoals gepland.
28
Dus voor een tijdsafhankelijke simulatie heeft men zowel de supervisor, als een getimed model (G1, timed) met alle getimede acties van het systeem. De supervisor van het ongetimede model en het getimede model zorgen samen voor een getimed model welke gesimuleerd kan worden. Schematisch is dit weergegeven in Fig. 4.17. 1-link simulatie model
G1, met tijd
Tijd toevoegen aan plantmodellen
2.
Supervisor synthese
Simulatie resutlaten
Simulatie
G1 Supervisor
3.
H1 1. 1. 2. 3.
Synthese van supervisor uit plantmodellen G1 en requirementmodellen H1 tijd toevoegen aan plantmodellen G1, als resultaat plantmodellen G1, met tijd Simulatie van de supervisor met de plantmodellen met tijd.
Fig. 4.17 1-link simulatie model
Wanneer de simulatie gedaan is blijkt dat het systeem zich inderdaad identiek gedraagt als de werking die in de Gantt chart staat opgesteld. Dit aangezien de modellen met tijd gemodelleerd zijn vanuit de Gantt chart. Het gepland recept met de specifieke tijden worden doorlopen zoals opgesteld is in de Gantt chart. Wat natuurlijk logisch blijkt zoals men hier te werk is gegaan.
29
4.4.2 2-link model met tijd uitgewerkt We hanteren nu het 2-link lineaire cluster tool, besproken in voorgaand hoofdstuk. De volgende aannames en ontwerpeisen zijn gemaakt: Zo hoog mogelijke throughput. Elke kwartslag draaien van de robot neemt een tijdseenheid in beslag. Een product pakken of plaatsen in een module neemt twee tijdseenheden in beslag. Procestijden van procesmodules: Procesmodules PM11 PM12 PM21 PM22 PM23 8 Tijdseenheden 15 11 10 De producten zijn oneindig beschikbaar vanuit de loadlock. De producten zijn alle ideaal en klaar om bewerkt te worden De producten dienen alle dezelfde route van bewerkingen te volgen.
10
Bij het opstellen van de Gantt chart van dit systeem blijkt dat ook bij dit model inderdaad sprake is van een aanloopverschijnsel gevolgd door een constante cyclustijd, de steady state. In de bijlage A.6 staat de Gantt chart van het 2-link model. Zoals in voorgaande hoofdstukken is uitgelegd, heeft men voor een meerdere links lineaire cluster tool een buffermodule nodig die het transport van producten tussen beide links uitvoert. Echter dient men voor het simuleren nog een requirement model te ontwerpen welke alle beperkingen van de buffermodule oplegt. Zo zal in dit model aangegeven worden welke verplaatsingen achter elkaar moeten plaatsvinden om zo het transport van de producten tussen twee links te regelen. Met dit requirementmodel wordt tevens het recept van de producten gemodelleerd. Dit requirementmodel is te zien in Fig. 4.18
30
Fig. 4.18 Requirement model gedistribueerde supervisor De gevolgde procedure voor synthese van de gedistribueerde supervisor voor twee links en de simulatie samen met de plantmodellen is schematisch weergegeven in Fig. 4.129
31
2-link simulatie model
S3
Supervisor synthese
H3
3. W1=(G1 x S1)/ (
{ })
A
' A
W2=(G2 x S2)/ (
Abstractie
B
{ })
B
'
Abstractie 2.
2.
G1
G2 Supervisor synthese
Supervisor S1
H1
Supervisor synthese
Supervisor S2
H2 1.
1.
LINK 1
G1,2 met tijd
Tijd toevoegen aan plantmodellen
4.
Simulatie
Simulatie resutlaten 5.
1. 2. 3. 4. 5.
Synthese van lokale supervisor voor link 1 (G1 en H1) en link 2 (G2 en H2) Abstractie van link 1 (G1 en S1) en link 2 (G2 en S2) Synthese van coordinator S3 voor link 1 en link 2 (abstractie W1 en W2 en requirementmodel H3) Tijd toevoegen aan plantmodellen G1 en G2, als resultaat plantmodel G1,2 met tijd Simulatie van 2-link model met supervisor S1 en S2, coordinator S3 en plantmodel G1,2 met tijd.
Fig. 4.129 2-link simulatie model
Nu de coördinator en de twee locale supervisors gesynthetiseerd zijn kan men een simulatie van het systeem uitvoeren. Voordat de simulatie gedaan kan worden dient men eerst tijd toe te voegen aan de plantmodellen van zowel link 1 als link 2. Vervolgens kan men met de plantmodellen G1,2 waar tijd aan toegevoegd is, de locale supervisors S1 en S2 en de coördinator S3 een simulatie uitvoeren. De gedistribueerde supervisor is dan {S1, S2, S3} Het blijkt dat ook bij deze test, gelijk aan de test met het 1-link model de uitvoering van de simulatie identiek is aan het te doorlopen recept met specifieke tijden zoals opgesteld in de Gantt chart.
32
4.5 Evaluatie en ervaring SCIDE In dit project zijn verschillende modellen en voorbeelden uitgewerkt met SCIDE. Hoewel het kleine en eenvoudige modellen waren zijn er toch de meeste mogelijkheden van SCIDE getest. Zodoende kunnen er toch enkele uitspraken gedaan worden over het gebruik van SCIDE. Zo zijn hieronder de voordelen en nadelen van SCIDE opgesomd hoe ze in dit project ondervonden zijn. Ook worden enkele aanbevelingen gedaan voor de verdere ontwikkeling van SCIDE. Voordelen Zowel de plantmodellen als requirement modellen kan men grafisch opbouwen, wat veel tijd bespaart. Dit grafisch opbouwen neemt minder tijd in beslag dan programmeren. De modellen zijn grafisch en overzichtelijk. Men kan direct zien welke acties bij welke transities mogelijk zijn. Tijdens het ontwerpen in SCIDE is goed duidelijk hoe het model opgebouwd is. Supervisor synthese kan gedaan worden door een grafisch model op te stellen waarbij alle plant modellen en requirement modellen gebruikt worden om een supervisor synthese uit te voeren. Met enkele blokken en lijnen bepaalt men de structuur waaruit de supervisor gesynthetiseerd wordt. Voor een simulatie met tijd is het mogelijk om de tijd aan de plant modellen te koppelen door er guards en of updates aan toe te voegen. Vervolgens door enkele commando’s welke buiten SCIDE ingevoerd moeten worden stuurt men SCIDE modellen aan tot het synthetiseren van de supervisor. SCIDE maakt gebruik van een foutendetectie waardoor het systeem gecontroleerd wordt alvorens een supervisor gesynthetiseerd kan worden. De modellen dient men met vele onderdelen op te bouwen in SCIDE. Zodra SCIDE aangezet wordt tot het synthetiseren van de supervisor wordt gekeken of het model wel klopt en compleet is. Zo niet krijgt men hier meteen een feedback van terug met de precieze details over de fout. Hierdoor kan men concluderen dat SCIDE een handige tool is voor het grafisch opbouwen van systemen om vervolgens een supervisor synthese uit te voeren. Nadelen -
-
SCIDE is een grafisch overzichtelijke ontwerp omgeving, echter kan men hier niet alles uitrekenen / grafisch modelleren. Zoals men voor de supervisor grafisch een model kan opstellen zou men dit ook moeten kunnen voor: make sequential abstractie, samenvoegen van beide locale supervisors, make coördinator etc. Nu dient men buiten SCIDE hiervoor commando’s in te voeren waardoor je geheel buiten SCIDE om de modellen van SCIDE gebruikt om nieuwe modellen te genereren. Dit zou ook binnen SCIDE moeten kunnen, helaas is dit tot op heden niet mogelijk. Het uitvoeren van een supervisor synthese gaat gedeeltelijk binnen SCIDE en gedeeltelijk buiten SCIDE om. Dit zou in zijn geheel binnen SCIDE moeten 33
-
-
kunnen. Zo zal binnen SCIDE een mogelijkheid zijn tot het aanroepen van de uitvoering van de gehele synthese. In veel gevallen is een systeem opgebouwd uit een aantal dezelfde componenten en deelsystemen. Bij het modeleren in SCIDE dient met telkens voor elk deelsysteem dezelfde systemen te modeleren. Het is binnen SCIDE niet mogelijk om een gedeelte te kopiëren en vervolgens aan te passen. Hierdoor dient men veel dubbel te modeleren wat natuurlijk de nodige tijd en frustratie met zich meebrengt. De behandelde modellen tijdens dit project zijn niet van zeer grote omvang. Zodra deze modellen uitgebreid worden zouden er gemakkelijk problemen kunnen ontstaan. Enkele problemen die zich voor kunnen doen zijn: Ruimte op het scherm wordt te klein. De modellen kunnen niet meer overzichtelijk gepresenteerd worden binnen SCIDE door een te klein scherm. Hoe groter en ingewikkelder het model des te langer zullen de rekentijden voor supervisor synthese worden. Bij ingewikkelde systemen wordt er veel gebruik gemaakt van gedistribueerde supervisors. Bij grotere systemen met meerdere links zal er een steeds hogere orde gedistribueerde supervisor gesynthetiseerd moeten worden.
Aanbevelingen Aangezien het een grafische tool is, zou het ook mogelijk moeten zijn dat de simulatie ook binnen SCIDE uitgevoerd zou kunnen worden. Dat er tijdens de simulatie een module was waarbij men binnen SCIDE steeds de mogelijkheid heeft een keuze te maken uit de events die op dat moment mogelijk zijn. SCIDE zou dan twee modes moeten hebben waarbij in de eene mode het model grafisch ontworpen kan worden en tevens een supervisor gesynthetiseerd kan worden. De andere mode zou dan het grafisch simuleren van de supervisor. Bij de simulatie heeft men steeds de keuze uit alle events die plaats kunnen vinden. Deze simulatie zou dan ook met tijd gekoppeld gaan welke ook meegenomen dienen te worden in de simulatie binnen SCIDE. Ook zouden de diverse klokken die in het model met tijd meegenomen zijn grafisch weergegeven moeten worden. Zo ziet men op elk tijdstip hoe de klokken lopen en wanneer ze geupdate zijn. Deze klokken dienen dan met de simulatie mee te lopen. Wanneer men een simulatie heeft uitgevoerd, zou SCIDE moeten onthouden welke events en acties er op welke tijdstippen plaatsgevonden hebben. Zodoende zou men een Gantt chart op moeten kunnen vragen welke automatisch gegenereerd is na het uitvoeren van de simulatie.
34
5 Conclusie SCIDE is voor diverse systemen gebruikt voor het synthetiseren van een supervisor. Zo is er gekeken naar een 1-links lineaire cluster tool maar ook naar een meerdere links lineaire cluster tool. Daaruit blijkt dat SCIDE een goede tooling is voor het synthetiseren van supervisors. Doordat er bij deze tooling niet veel geprogrammeerd hoeft te worden maar veel gebruik wordt gemaakt van de grafische toepassing. Zo kan men de systemen als grafische modellen invoeren wat erg overzichtelijk is en in relatief korte tijd gedaan kan worden. Het simuleren van een model kan met enkele commando’s gedaan worden en geeft de ontwerper snel een indruk van het systeem en de betrouwbaarheid van de supervisor. Hoewel SCIDE goed functioneert voor het synthetiseren van supervisors merkt men wel dat het nog niet compleet is. De versie die tijdens dit project gebruikt is was nog niet in staat om voor grote modellen de gedistribueerde supervisors te synthetiseren, hoewel SCIDE wel in staat was een gecentraliseerde supervisor te synthetiseren. In dit project zijn geen grote modellen gebruikt, echter zullen er wel enkele problemen zich voordoen wanneer grote systemen ingevoerd worden. SCIDE is een zeer handige tool voor het synthetiseren en het vervolgens analyseren van supervisors. Echter zal het nog wel de nodige aanpassingen moeten ondergaan wil het ook bruikbaar worden voor grote systemen welke uit meerdere deelsystemen bestaat. Ook enkele aanpassingen voor de gebruiksvriendelijkheid zijn gewenst zoals het kunnen kopiëren van eenzelfde model, zonder het opnieuw in te hoeven voeren.
35
36
Literatuurlijst [1]
P. van der Meulen. Linear semiconductor manufacturing logistics and the impact on cycle time. In Proc. 18th Annual IEEE/SEMI Advanced Semiconductor Manufacturing Conference, 6(7):111-116, 2007
[2]
P.A.W. van Overmeire. Nonblocking and time-optimal scheduling for Linear Cluster Tools, Master thesis, Eindhoven University of Technology, 2009
[3]
P.J. Ramadge and W.M. Wonham. Supervisory control of a class of discrete event systems. SIAM J. Control and Optimization, 1987
[4]
SCIDE User Guide. SEwiki http://se.wtb.tue.nl/sewiki/supcon/scide/user_guide, Systems Engineering group, Eindhoven University of Technology. 2010
[5]
Sewiki, http://se.wtb.tue.nl/sewiki/start, Systems Engineering group, Eindhoven University of Technology, 2010
[6]
W.M. Wonham. Supervisory Control of Discrete-event Systems. Systems Control Group, Dept. of ECE, University of Toronto, 1997
37
38
Bijlagen I. II. III. IV. V. VI. VII. VIII.
SCIDE model 1-link....................................................................................................40 SCIDE model 2-link....................................................................................................42 Gantt chart 1-link model, test 1 ...............................................................................45 SCIDE model link 1, test 1 ........................................................................................46 SCIDE model getimed link 1, test 1........................................................................48 Gantt chart 2-link model, test 2 ...............................................................................49 SCIDE model 2-link, test 2 .......................................................................................50 SCIDE model getimed, 2-link, test 2 ......................................................................52
39
I. SCIDE model 1-link SCIDE model van 1-link system uitgewerkt met supervisor synthese van gecentraliseerde supervisor. Model na aanleiding van hoofdstuk 3.1.1
40
41
II. SCIDE model 2-link SCIDE model van 2-link system uitgewerkt met supervisor synthese van gecentraliseerde supervisor. Model na aanleiding van hoofdstuk 3.1.2
42
43
44
III. Gantt chart 1-link model, test 1 Gantt chart van 1-link system uitgewerkt met geplande verplaatsingen en bewerkingen met tijd. Gantt chart na aanleiding van hoofdstuk 3.4.1
45
IV. SCIDE model link 1, test 1 SCIDE model van 1-link system uitgewerkt met supervisor synthese van gecentraliseerde supervisor. Model na aanleiding van hoofdstuk 3.4.1
46
47
V. SCIDE model met tijd link 1, test 1 SCIDE model van 1-link system met modellen waar tijd aan gekoppeld is. Tijden zijn bepaald na aanleiding van de Gantt chart van bijlage IV. Model na aanleiding van hoofdstuk 3.4.1
48
VI. Gantt chart 2-link model, test 2 Gantt chart van 2-link system uitgewerkt met geplande verplaatsingen en bewerkingen met tijd. Gantt chart na aanleiding van hoofdstuk 3.4.2
49
VII. SCIDE model 2-link, test 2 SCIDE modellen van 2-link system uitgewerkt met supervisor synthese van locale supervisor. Modellen na aanleiding van hoofdstuk 3.4.2
50
51
VIII. SCIDE model met tijd 2-link, test 2 SCIDE modellen van 2-link system met modellen waar tijd aan gekoppeld is. Tijden zijn bepaald na aanleiding van de Gantt chart van bijlage VI. Model na aanleiding van hoofdstuk 3.4.2
52
53
