software module for laser lithography - mk-info.com · programs (e.g. autocad), and then run...
TRANSCRIPT
HELSINKI UNIVERSITY OF TECHNOLOGY Faculty of Electrical Engineering Mika Karilahti
Software Module for Laser Lithography This Master's Thesis is submitted to the Faculty of Electrical Engineering at Helsinki University of Technology for partial fulfilment of the requirements for the degree of Master of Science, 31 May 1993. Supervisor: Mr. Turkka Tuomi, Professor, Doctor of Technology Instructor: Mr. Kari Laiholuoto, Licentiate of Technology
ii
Abstract of the Master's Thesis
University: Helsinki University of Technology Author: Mr. Mika E. Karilahti Name of the thesis: Software Module for Laser Lithography Date: 31 May 1993 Number of pages: 95
Faculty: Electrical Engineering Professorship: Tfy-3, Optoelectronics
Supervisor: Professor Mr. Turkka Tuomi Instructor: Tech.Lic. Mr. Kari Laiholuoto
For a long time steppers have been the only method available for exposing large-area objects with a repetitive pattern. The masks with a single pattern for the steppers have been made mainly by photoplotters and electron-beam methods. Now a recent technology - laser beam scanning - is being accepted for patterning large area photomasks (up to 60 cm by 50 cm) one at a time. This focus will be on the LRS-55, a machine using such a principle, manufactured by Micronic Laser Systems Ab, Sweden. For the LRS-55 varying patterns are normally designed with generic CAD programs (e.g. Autocad), and then run through a conversion and a sorting routine. However, when a repetitive pattern with small placement variations is required it has to be generated with macro command sequences on the CAD system - and the result is 'out of memory'. The objective of this Master's Thesis is to solve this problem by constructing a software interpreter. It will convert written special commands, into vector-type drawing data for the LRS-55. This interpreter will soon be used on an LRS-55 for exposing patterns onto shadow masks and LCD masters. At the moment the interpreter software produces vector-files, but in the future the program will be modified to create patterns for real-time exposure.
Keywords: interpreter, computer, graphics, mask / reticle, laser, lithography
iii
Diplomityön lyhennelmä
Korkeakoulu: Teknillinen Korkeakoulu Tekijä: Mika E. Karilahti Työn nimi: Laseriin perustuvan maskinvalotuslaitteen ohjelmamoduli Päiväys: 31.05.1993 Sivujen lukumäärä: 95
Osasto: Sähkötekniikan osasto Professuuri: Tfy-3, Optoelektroniikka
Valvoja: Professori Turkka Tuomi Ohjaaja: Tekniikan lisensiaatti Kari Laiholuoto
Askeltimet ovat pitkään olleet ainoa menetelmä valottaa suuripinta-alaisia kohteita toistuvalla kuviolla. Maskit on tehty askeltimia varten pääasiassa fotoplottereilla ja elektronisuihkumenetelmällä. Nyt on yleisesti hyväksytty käyttöön uudehko menetelmä - laserpyyhkäisy - suurten (jopa 60 cm x 50 cm) maskien valottamiseen kerralla. Diplomityössä käytetään ruotsalaisen Micronic Laser Systems Ab:n valmistamaa LRS-55 -laservalotuslaitetta. LRS-55:lle suunnitellaan erilaiset kuviot tavallisesti yleisillä CAD-ohjelmilla (esim. Autocad), joiden tuotokset ajetaan muunnos- ja lajitteluohjelmien läpi. Haluttaessa aikaansaada toistuvia rakenteita pienillä sijoitusvaihteluilla, ne tehtäisiin CAD-järjestelmän makrokäskyillä, jolloin rakenteiden lukumäärän kasvaessa tietokoneen muisti loppuisi. Tämän diplomityön tarkoituksena oli ratkaista ongelma tekemällä ohjelmatulkki, joka tulkitsee tekstinä kirjoitetut piirtokäskyt LRS-55:lle sopivaksi vektorityyppiseksi tiedostoksi. Tätä tulkkia käytetään lähiaikoina eräässä LRS-55 -laitteessa valottamaan mastereita TV:n varjomaskeja ja LCD-näyttöjä varten. Tällä hetkellä ohjelmatulkki tuottaa vektoritiedostoja, mutta tulevaisuudessa ohjelmaa muutetaan niin, että se pystyy tuottamaan kuvioita reaaliajassa suoraan valotuslaitteelle.
Avainsanat: tulkki, tietokone, grafiikka, maski, laser, litografia
iv
Diplomarbetets referat
Högskola: Tekniska Högskolan Författare: Mika E. Karilahti Rubrik: Programmodul för en laser-baserad maskexponerande maskin Datum: 31.05.1993 Sidantal: 95
Avdelning: Elektroteknisk avdelning Professur: Tfy-3, Optoelektronik
Arbetets övervakare: Professor Turkka Tuomi Arbetets handledare: Teknologielicentiat Kari Laiholuoto
För en lång tid har användning av stepper-maskiner varit den enda metoden vid exponering av stora ytor med periodiska mönster. Maskerna för stepper-maskinerna är vanligen producerade med fotoplotter och elektronstråle-metoden. Nu har vi en ny teknologi - exponering med laserstråle - för att skapa mönster på fotomasker med stora ytor (upp till 60 cm x 50 cm). Här koncentrerar vi oss på LRS-55, en maskintyp som använder denna metod. Den tillverkas av Micronic Laser Systems Ab, Sverige. För LRS-55 skapas olika mönster med allmänna CAD-program (t.ex. Autocad). Mönstren körs sedan genom konversions- och sorteringsprogram. Vill man ha periodiska mönster med små placeringsvariationer, används en makrorutin på CAD-systemet. Om antalet objekt blir för stort, finns en risk att minnesutrummet tar slut. Syftet med detta diplomarbete är att undvika detta problem genom att konstruera en programtolk, som konverterar skrivna, speciella instruktioner till vektoriserade ritningsdata för LRS-55. Denna tolk kommer att användas i en LRS-55 för att exponera mastermasker för bildskärm- och LCD-tillverkare. Tolken producerar för tillfället vektorfiler, men i framtiden kommer programmet att modifieras så att mönster skapas i realtid.
Nyckelord: tolk, dator, grafik, mask, laser, litografi
v
Preface
This work has been done at Terapixel [Oy] Inc. in Espoo, Finland, in co-operation with Micronic Laser Systems [Ab] Ltd. in Stockholm, Sweden.
Terapixel is a small, innovative company established in 1990. Their main business is to process patterns onto photomasks for a wide range of applications, including inducers, detectors, electroluminescent and LCD displays, planar optics, wafer scale integration, binary holograms, etc.
Terapixel uses two laser-based photomask patterning machines manufactured by Micronic (LRS-18 and LRS-55). At the moment there are only three well-known companies in the world manufacturing laser-based photomask exposure machines (Micronic included). Micronic has been manufacturing such commercial ones now for a few years.
Scope
Besides being my Master's Thesis, this document is intended also to be a manual for anyone using this 'GenPatt' software module. If further development of GenPatt should be done by someone else, this book will provide a great deal of necessary information about the algorithms, testing, limitations etc. to ease the complicated task.
Even though the C-source code is over 150 kilobytes, only a fraction of it will be revealed here for trade secret reasons. The underlying algorithms, however, will be analyzed extensively.
Acknowledgments
I wish to express my gratitude to my Professor Mr. Turkka Tuomi at the Optoelectronics Laboratory at Helsinki University of Technology for providing the best of help with my studies, including this Master's Thesis. Thank you for all your interesting lectures I have had the privilege to listen to during my years as a student at HUT.
I want to thank my instructor on this project, Tech.Lic. Mr. Kari Laiholuoto, for all his advice, opinions, and our discussions, his supervisor Tech.Lic. Mrs. Helena Pohjonen, and other people at the VTT (Technical Research Center of Finland) Semiconductor Laboratory and especially at the IC Design Department for all their efforts with this project.
My thanks go also to Lecturer Mr. Tapio Takala (Faculty of Information Technology, HUT) for his suggestions on how to begin with the project, to my friend Mr. Esa Eklund (secretary of the VME Users´ Club) for his help in locating VME specialists, and to Field [Oy] Ltd. for their VME knowledge.
vi
And not least to Mr. Arto Salin, President (Terapixel), to Mr. Kaarlo Komsi (Terapixel), to Mr. Anders Thurén and Mr. Leif Odselius (both at Micronic), and also to all other people at Terapixel and Micronic.
The warmest thanks to my father Thure, and mother Auli for their support with my studies.
To the persons, who are, or are not mentioned here - I want to thank you for all your help!
Mika Karilahti
Helsinki, 31 May 1993
I can be contacted best through: Modicus [Oy] Ltd., P.O. Box 8, 00841 Helsinki, Finland/Europe tel. (90) 4002428, Int. +358 0 4002428, fax. (90) 4002429, Int. +358 0 4002429.
Other contact information:
Mr. Arto Salin Terapixel [Oy] Inc., Olarinluoma 9, 02200 Espoo, Finland/Europe tel. (90) 423537, Int. +358 0 423537, fax. (90) 423813, Int. +358 0 423813, EMAIL, Internet: [email protected] Mr. Leif Odselius Micronic Laser Systems Ab, P.O. Box 3141, 18303 Täby, Sweden/ Europe tel. (08) 792 6095, Int. +46 8792 6095, fax. (08) 792 2480, Int. +46 8792 2480, EMAIL, Internet: [email protected]
vii
Table of Contents
Software Module for Laser Lithography .................................................................i
Abstract of the Master's Thesis ...............................................................................ii
Diplomityön lyhennelmä..........................................................................................iii
Diplomarbetets referat ............................................................................................iv
Preface ...................................................................................................................v Scope.................................................................................................................v Acknowledgments..............................................................................................v
Table of Contents ...................................................................................................vii
List of Abbreviations & Vocabulary........................................................................viii
1 Introduction.........................................................................................................13
2 Mask Production Cycle........................................................................................14 2.1 Mask Types..................................................................................................14
2.1.1 Substrate Materials ...............................................................................15 2.1.2 Metal Layer ..........................................................................................15 2.1.3 Resist Types .........................................................................................16
2.2 Mask Exposure ............................................................................................16 2.2.1 Electron-beam Writing..........................................................................16 2.2.2 Laser-beam Writing ..............................................................................16
2.3 Mask Development and Etching ...................................................................17 2.4 Defect Inspection .........................................................................................18 2.5 Using the Patterned Masks ...........................................................................18
3 System Overview of LRS-55................................................................................19 3.1 Hardware .....................................................................................................20
3.1.1 Exposure System ..................................................................................20 3.1.2 Interferometer System...........................................................................22 3.1.3 X-Y-Stage ............................................................................................22 3.1.4 Computer System .................................................................................23
3.2 Software ......................................................................................................23 3.3 Limitations...................................................................................................24
4 Objectives of the Program Module.......................................................................26 4.1 Background..................................................................................................26 4.2 Tools of the Project ......................................................................................26
4.2.1 Programming Environment...................................................................26 4.3 Input File Format..........................................................................................27 4.4 Output File Format.......................................................................................28
5 Structure of the Program Module.........................................................................30 5.1 Input Section................................................................................................30 5.2 Output Section .............................................................................................31
6 Program Essentials...............................................................................................35 6.1 Pseudocode..................................................................................................35
viii
6.2 Commands ...................................................................................................35 6.3 Functions .....................................................................................................35 6.4 Numerical values ..........................................................................................36 6.5 Stack (LIFO)................................................................................................36 6.6 FIFO-Buffer .................................................................................................36 6.7 Window Specifications .................................................................................36 6.8 CF/DF Specifications....................................................................................37 6.9 Header Data .................................................................................................37 6.10 Stripe Lines ................................................................................................37 6.11 Block Approach .........................................................................................37 6.12 Drawing a Segment ....................................................................................38 6.13 Creating Objects.........................................................................................39
6.13.1 Rectangles ..........................................................................................39 6.13.2 Polygons.............................................................................................39 6.13.3 Circles ................................................................................................40
7 Testing the Module..............................................................................................42 7.1 Sample Test Run ..........................................................................................42
7.1.1 Theoretical Drawing .............................................................................42 7.1.2 The Actual Mask: photographs .............................................................44
8 Conclusions .........................................................................................................50 8.1 Reliability.....................................................................................................50 8.2 Speed...........................................................................................................50 8.3 Amount of Data ...........................................................................................51 8.4 Extendibility.................................................................................................51 8.5 Overall Performance.....................................................................................51
8.5.1 VME ....................................................................................................51 8.5.2 SUN .....................................................................................................52
8.6 True Customer Example: A Shadow Mask ...................................................52
9 Future..................................................................................................................53 9.1 Error Checking.............................................................................................53 9.2 Parameter File ..............................................................................................53 9.3 Rectangle and Polygon Clipping ...................................................................54
9.3.1 Clipping against a Rectangular Boundary ..............................................54 9.3.2 Clipping against an Arbitrary Boundary.................................................55
9.4 Real-Time Processing...................................................................................56 9.4.1 Modifications........................................................................................56 9.4.2 Multiprocessing ....................................................................................56
9.5 Visual Pre-Viewing ......................................................................................57 9.5.1 Using Photographic Methods ................................................................57 9.5.2 Pattern Verification...............................................................................57 9.5.3 Post-Script Format................................................................................57 9.5.4 Viewing at a Workstation......................................................................57
9.6 Program Portability......................................................................................58 9.6.1 UNIX Systems......................................................................................58 9.6.2 PC Compatibility...................................................................................58
9.7 Other Possibilities.........................................................................................58
Appendix A: List of Errors and Warnings ...............................................................59
ix
Appendix B: Format Specifications from Micronic ..................................................68
Appendix C: Listing of the Line-clipping Algorithm ................................................76
Appendix D: Contents of Sub-Modules...................................................................81
Appendix E: Examples of Program Essentials .........................................................83
Appendix F: Using the Module ...............................................................................86
Appendix G: Input - the Module Test .....................................................................90
Appendix H: Input - the Combination Array............................................................92
Appendix I: Input - the Single Pattern Arrays..........................................................93
Appendix J: Bibliography........................................................................................94
List of References...................................................................................................95
x
List of Abbreviations & Vocabulary
AC - Alternating Current.
acousto-optic - Typical application with an AO-deflector is laser beam scanning in one dimension. The scanning is done with a special crystal by creating a standing acoustic (frequency a few hundred MHz) wave inside the crystal by a piezoelectric inducer. The wave causes material density variations, and creates a Bragg lattice. This lattice is then able to deflect light into directions depending on the acoustic frequency. In an AO-modulator the scanning angle is smaller, and it is used mainly in switching applications.
ADC - Analog-to-Digital Converter. Converts an input voltage (or current) level into a binary coded output.
AO - See acousto-optic.
AOD - Acousto-Optic Deflector. See acousto-optic.
AOM - Acousto-Optic Modulator. See acousto-optic.
ASCII - pronounced 'as-key', American Standard Code for Information Interchange /13, p. 314/,/14, p. 334/. The set consists of letters, numbers, and some special characters.
byte - one byte consists of 8 bits. With 1 byte it is possible to specify 28 = 256 different characters, numbers, codes, etc.
CAD - Computer Aided Design.
CD - Compact Disk.
chirp signal - a signal, whose frequency increases linearly with time (till a certain cut-off point).
CPU - Central Processing Unit. The microprocessor in a microcomputer, sometimes also known as MPU (Main PU).
CRT - Cathode Ray Tube, e.g. the picture tube in television equipment.
CVD - Chemical Vapor Deposition.
DAC - Digital-to-Analog Converter. Converts a binary coded input to output voltage or current.
DOS - Disk Operating System. It is the best selling operating system for PC's from Microsoft.
FIFO - a buffer using the principle of First In First Out.
HeCd - Helium-Cadmium.
HeNe - Helium-Neon.
HUT - Helsinki University of Technology
HW - Hardware.
IC - Integrated Circuit.
xi
LCD - Liquid Crystal Display.
macro - a command sequence, which can be input/programmed into the system.
mask - Masks are used in lithography to create patterns onto IC wafers with resist and ultraviolet light.
master - the original piece, from which all sub-masters are made.
mil - 1 mil = 2.54 µm.
MIMD - Multiple-Instruction stream, Multiple-Data stream. A system with many connected processors.
MIPS - Millions of Instruction cycles Per Second. A number preceding this word describes the performance of a computer. The readings on a RISC (Reduced Instruction Set Computer) and CISC (Complete Instruction Set Computer) processors are not comparable.
operating system - the program, which controls the running of all other programs.
OEM - Original Equipment Manufacturer. The supplier has bought the products from another manufacturing party.
OS/2 - Operating System/2. The 32-bit multiprocessing operating system from IBM (International Business Machines).
p-p - peak-to-peak. Describes the difference between the highest level and the lowest level of a signal.
PC - Personal Computer. Mainly the computer types, which are based on the 80X86 family of Intel originated microprocessors.
PCB - Printed Circuit Board.
Post-Script - It is a drawing language developed by Adobe Systems Inc., and is used primarily in printers.
RAM - Random Access Memory. This type of memory can be both written to, and read from.
reticle - It is a mask to be used in a stepper, i.e. it has magnified patterns.
RF - Radio Frequency.
RPN - Reverse Polish Notation. This type of logic is used in computations in the software module. Also Hewlett-Packard calculators use it.
spectrum - e.g. the amplitude or power as a function of frequency or wavelength.
sputtering - metalization using ion bombardment.
stepper - used for creating an array of patterns onto a wafer.
shadow mask - The mask with small holes in a CRT.
sub-master - is made from the master. Printing copies are made from sub-masters.
SW - Software, i.e. computer programs.
xii
TV - Television
UV - Ultraviolet
wafer - Wafers are slices, usually less than a millimeter thick, and a few inches in diameter, cut from a silicon rod grown by crystal growth methods. IC's are processed onto these slices.
VCO - Voltage Controlled Oscillator. The output frequency of the circuit can be controlled by the level of the input voltage.
virtual memory - the computer swaps into the main memory that part of the program (or the part of the data-area), which is being accessed at the moment.
VME - Versabus Module for Europe. Identifies VMEbus-compatible products.
VMEbus - A modular, manufacturer-independent computer bus. Developed by Motorola1, but it is a non-patented, public standard.
VTT - Technical Research Center of Finland
1Motorola Inc. is the largest telecommunications equipment manufacturer in the world today.
1 Introduction
Mask-making has come a long way from its beginning. One of the main reasons is, that the semiconductor industry has always pushed the demands for tighter specifications.
In the 50's the first masks were made by drawing the pattern manually on paper, and then filming it to a smaller size. The film was then used to make the master mask.
Photoplotters were introduced in the 60's. With these it was possible to automatically expose the chosen areas of a mask. Photoplotters use vector graphics, and the path is described with special vectored commands. These commands somewhat resemble the commands available in 'GenPatt', the program module developed in this project.
After the invention of steppers, it became a lot easier to transfer multiple copies of structures. Steppers use one ready reticle, whose pattern will be projected to the blank wafer in multiple places. The drawback with this method is, that it is mechanical, and the projected pattern cannot be rotated or resized easily.
In the 70's three new ideas were introduced. They were drum recording (no longer in use), electron-beam recording, and laser beam deflection recording. The exposure machine, the LRS-55, used in this project, is based on the last of the three principles.
During the 80's the quality, feature size, and production speed all improved. This trend will continue.
In the 90's as the cost of entry into business goes up, technology will diverge, and mask defect requirements will tighten, the goal is to make 'perfect' masks.
The LRS-55 represents at the moment the state of the art in laser lithography with large masks. Normally patterns are designed with generic CAD (Computer Aided Design) tools, and then converted into the LRS-55 format.
It is also possible to make shadow mask masters with the machine. Shadow masks have millions of unevenly placed holes and rectangles. The manufacturer of the LRS-55, Micronic Laser Systems Ab, did not have tools for customers to create such patterns efficiently. This master's thesis is about a project to construct a program in C to interpret written special drawing commands, into vectored drawing data for the laser scanner LRS-55.
14
2 Mask Production Cycle
The resist is first exposed to a pattern (by light or e-beam). Then the exposed pattern is made visible by removing the exposed part of the resist. The chrome, which is now visible after removing the resist, is removed in a bath of etchant. The non-exposed areas are still protected by the resist, so the chrome will not dissolve there. After the bath, the rest of the resist is exposed and removed. Then the mask is rinsed and dried. A manufacturer is now ready to use the finished mask for transferring the pattern onto a silicon wafer, a flat-panel display, or a PCB (Printed Circuit Board), etc.
2.1 Mask Types
A dissection of a typical mask is shown in a drawing (figure 1). The standard heights of large masks are 3 and 5 mm.
resistchromesubstrate (glass)
Figure 1a: Typical dissection of a mask blank.
chromesubstrate (glass)
Figure 1b: Typical dissection of a finished patterned mask.
2.1.1 Substrate Materials
15
Four substrate material types are presented here /1/, /2/. The following listing ends with the most expensive ones:
A) Green Soda-Lime glass is cheap, and quite usable for sub-master copies and contact printing. This type of substrate is not suitable for high temperatures e.g. electron beam exposure. The reason is that the sodium atoms of the substrate react with the chrome. This substrate has the highest thermal expansion coefficient. It is not good for making detailed patterns.
B) White Crown glass is suitable for masters, sub-masters and copies. It has almost as high a thermal expansion coefficient as Soda-Lime, but can be exposed to photons or an e-beam.
C) Low Expansion Borosilicate glass is the recommendation for master plates and wafer stepper reticles. It can also be used for contact and proximity print copies. It is possible to use an e-beam to expose this type of mask.
D) Quartz glass has the lowest expansion coefficient of these four. Synthetic quartz is over 90% transparent in the UV area down to 200 nm. Usage includes masters, wafer stepper reticles, and e-beam plates.
2.1.2 Metal Layer
Four different choices of metal layers are presented here /1/.
A) AR3 is called 'low reflective or dark chrome' (reflectivity, R=11%). It is produced by sputtering Cr and CrxOy successively. It is used in optical lithography but not with e-beams. The reason is, that the chrome of some manufacturers can change under an e-beam and cause damage to patterns.
B) CLR/CMR is called 'medium reflective chrome' (R=30%). It is produced by sputtering thin successive layers of Cr and CrxOy. The product is mainly for the e-beam market, and has better durability than 'shiny chrome' (CR).
C) CR is called 'shiny or high reflective chrome' (R=48%). It is only Cr - sputtered, and used as an e-beam product.
D) CRST is called 'see-through chrome' (R=20%). It is only Cr-sputtered. The product is an alternative to Iron oxide.
Iron oxide is today used mainly in very large masks, at least with photon lithography. Chrome is displacing iron oxide in masks smaller than 17 inch.
In addition to these hard surface masks there is emulsion. It is like photographic film, and is able to form gray-scale patterns. The darkness of a pattern depends on the photon energy dosage, i.e. duration time of exposure. There is no resist and no etching is required. However, development is necessary. The mask cannot be cleaned, and it has very poor durability.
16
2.1.3 Resist Types
The resists are divided into two categories A) optical and B) e-beam resists /3, pp. 436-442/, /1/:
A) Optical resists are used in conventional lithography, and are exposed by UV-light. Optical resists for masks have two sub-categories a) positive and b) negative resists:
a) Positive resists are based on long polymer chains. Exposing light cuts the chains, and they become easily soluble, i.e. the exposed parts are to be removed later.
b) Negative resists are based on short polymer chains. The exposing light combines the chains into longer ones, and they become less soluble, i.e. the unexposed parts are to be removed later.
The decision between which of the resist types to use depends on the later processes. Both types are good choices for their applications. Resolution is usually better with positive resists.
B) Electron-beam resists are also classified as positive and negative types. They are not normally exposed to light, but require an e-beam. The e-beam cuts and combines chains the same way photons operate with optical resists respectively.
In addition to these resists, for IC wafers there are also available the 'image reverse' type resists. The used developer determines whether the exposed, or unexposed resist areas are removed.
2.2 Mask Exposure
2.2.1 Electron-beam Writing
The e-beam systems are able to write micron and sub-micron geometries, conceive greater depth of focus than optical systems, and have no problems of interference in the visible part of the spectrum (λelectron << λphoton). However, e-beam machines always require a vacuum, and creating it after each mask change reduces the throughput rate.
The e-beams have two writing schemes, raster and vector scan. The vector scan is good if only a small portion of the mask has to exposed. Some machines even use a variable beam-shape, from small points to large rectangles.
2.2.2 Laser-beam Writing
There are only four manufacturers in the world using the laser principle /4a/, /4b/. Short descriptions are provided here.
17
A) Semitec Semiconductor Equipment GmbH, Ludwigshafen, Germany
An ordinary optical patterning machine equipped with a XeCl-excimer-laser (308 nm) light source instead of a mercury lamp. The laser is stationary, but the table moves in X and Y directions. Main advantage to the traditional machines is the speed.
B) ATEQ, U.S.A.
Their CORE draws one stripe at a time. The light source is an Argon-ion laser (363.8 nm). The beam is split into several parallel parts. The parallel beams are in one plane, and they go through AO-modulators (each beam has one). Then the beams are reflected from a positioning plane mirror to a rotating polygon mirror. The latter is used for scanning the beams one stripe wide.
C) Micronic Laser Systems Ab, Täby, Sweden
Their LRS (Laser Reticle Scanner) machines have a HeCd-laser (441.6 nm, the same type as used elsewhere for making CD masters). The beam goes through an AO-modulator (acts as an on/off-switch) to an AO-deflector, which performs the scanning one stripe wide (128 or 512 µm depending on the model).
D) Heidelberg Instruments Mikrotechnik GmbH, Heidelberg, Germany
Their DWL Lasarray has a HeCd-laser (441.6 nm). The beam goes through an AO-modulator (acts as a beamsplitter) to an AO-deflector, which performs the scanning. Specialized in wafer direct writing, but can make masks, too.
Several manufacturers make traditional mask patterning machines containing ordinary light sources. The price is lower, but so is the resolution and the variety of mask applications.
2.3 Mask Development and Etching
After the mask is exposed the pattern still has to be made visible and permanent. First the exposed part of the resist is removed in a bath of developer chemical. Then the chrome is etched away from the exposed part of the mask with an etchant. If the rest of the resist is to be removed, the whole mask will be exposed. The resist is then removed once again with the developer chemical. Another choice would be to directly use a stripping chemical (no exposure). After the mask is rinsed, dried, checked and packed, it is ready to be delivered to the customer (e.g. IC manufacturer). Rinsing also takes place between all steps from development to etching.
18
2.4 Defect Inspection
A mask cannot be delivered to a customer without a careful inspection for defects, e.g. critical dimensions, misalignment accuracy, and registration. The reasons for defects vary, e.g. pattern design error, data conversion error, exposure error, dust particles, handling errors with chemicals, etc.
The basic inspection is made by the naked eye. It is important not to overlook this method with large area masks having a vast number of small, repeated elements. A trained eye easily spots a small pattern misalignment under suitable light conditions.
It is easy to manually inspect smaller details with microscopes /5/, but checking the whole mask through this way is very time consuming and not entirely error-free. Therefore some companies have developed automatic machines based on microscopes and computer vision systems utilizing databases. Masks can also be repaired using appropriate equipment /6/.
2.5 Using the Patterned Masks
Industry uses the patterned masks to transfer the pattern onto their products, e.g. the layout of integrated circuits, the pixel array of flat panel displays, the waveguides of planar optics, etc.
There are two basic principles for exposing objects through masks A) shadow printing and B) projection /2/.
A) Shadow printing is divided into two categories, contact printing and proximity printing. In contact printing the chrome of the mask makes contact with the object (e.g. IC wafer), and in proximity printing there is a small gap (10...50 µm) between the chrome and the object. The former one provides high resolution, but a problem with dust particles - the latter one the opposite.
B) Projection techniques are divided into scanning projection and step-and-repeat projection. Projections use lenses (or mirrors) to project the pattern of the mask onto the object. With the step-and-repeat method the mask is often of a larger magnification than 1X, quite usual is the 5X (mask patterns : wafer patterns = 5 : 1). These reduction masks are always used in steppers to expose wafers.
19
3 System Overview of LRS-55
The LRS-55 (Laser Reticle Scanner) is manufactured by Micronic Laser Systems Ab, Sweden. Figure 2a shows the write system (i.e. LRS-55).
EL-screen
control panel
keyboard
VME-computer
HeCd-laser and environmental control system
moving table, laser head and interferometer system
Figure 2a: Write system (LRS-55).
Figure 2b: Photograph of the write system.
20
A small summary of the write system /7/ is in table 1. Some details are omitted, e.g. the cooling water temperature, etc.
Table 1: Write system specifications and requirements
Weight 1000 kg
Dimensions: height / width / depth 179 / 214 / 116 cm
Particle control (min. requirements) Class 100
Temperature 19 - 23 °C
Humidity 30 - 70 % relative humidity
Cooling Water Flow 15 liter/min
Air Supply 10 liter/min
Vacuum Level less than 0.1 bar
Power Consumption 120 V, less than 25 A
Communication Ethernet, RS-232
Allowed Room Floor Vibration speed < 25 µm/sec, min. 8 Hz;
> 8 Hz, acceleration < 0.1 cm/sec2
3.1 Hardware
Only the most interesting parts (lasers, movement, computer) of the system /8/ will be described here briefly. However, there are numerous other parts in the LRS-55, e.g. the control panel, the compressed air system, the vacuum system, the cooling water system, the temperature control, the environmental control, and the power supplies.
3.1.1 Exposure System
The machines from Micronic all use the principle of laser scanning. The mask is divided into multiple, parallel stripes (figure 3), which are 512 µm wide in the LRS-55. The table holding the mask is moved around by servos. They are controlled by the computer, which gets the position readings from the interferometers.
21
512 µm
Y
X
Figure 3: Part of a mask showing the stripes. Note the coordinate axes.
Some minor things are overlooked in the following explanation, e.g. mirrors, lenses, and beam aligners.
The exposing blue-light source is a 70 mW HeCd-laser. The beam first passes a solenoid controlled shutter (safety precautions). Then the beam goes through a quarter-wave plate, which transforms the linearly polarized light into circularly polarized light. Now the beam goes through a noise reduction unit. The unit reduces the maximum output power, but stabilizes it. The unit uses a negative feedback, and takes the controlling input signal from an internal beamsplitter.
Then the beam goes through an AO-modulator, which is used as an on/off switch of the beam. The AOM is made of lead molybdate with an attached piezo-electric transducer. The induced acoustic sound wave (200 MHz) causes local changes in material density, and acts as a diffraction grating. Most of the light is diffracted to the first order direction. The Bragg angle is about 0.6° . To switch the beam on/off, the electrical input signal is switched on/off.
Next the beam hits a beamsplitter, where 10% of the incident beam is reflected into a fiber (leads to a detector). This way the laser dosage can be controlled. Also the returning beam (from the mask) is reflected here to the other side. So it will be possible to calibrate the later appearing AOD sweep cycle by using a special, pre-manufactured calibration mask.
Then, again comes another quarter-wave plate, which changes the light beam from circularly polarized back to linearly polarized. Thereafter the polarization is precisely known.
Finally the beam goes through the AO-deflector, which sweeps the beam one stripe wide. The AOD has a structure similar to the AOM, but with some differences. The material is tellurium-dioxide, and the deflection angle is almost
22
proportional to the injected frequency. With the used range of 150-250 MHz the angle is from 3.5° to 4.7° for the first order diffraction. Both the amplitude and the frequency are controlled. To make an even exposure for one microsweep (512 µm wide, 1 µm high), it is necessary to create a look-up-table for the DA-converters from the pre-manufactured calibration mask (to run the VCO and the amplifier).
3.1.2 Interferometer System
The X and Y stage positions are monitored and controlled by interferometers. The system is based on a frequency stabilized HeNe-laser. The stabilization will not work if the beam is reflected back into the aperture. The direction of the linearly polarized beam is adjusted by rotating the laser head. The beam is expanded to 2 mm by using a beam expander to reduce the divergence of the beam. To get an exact polarization, the beam is still passed through one polarizing beamsplitter (a prism), and from there on to the interferometers.
The detector amplifiers are AC-coupled. The carriage does not move in the Y direction during the writing of one stripe (only in the X direction); therefore the carriage requires a wobbler in the Y interferometer to make an AC-signal. This is done by mounting a piezo translator to one of the flat mirrors in the interferometer. By applying a sawtooth signal with an amplitude of 100 V (peak-to-peak), the piezo contracts and expands 0.5 µm (p-p).
The interferometers have to be able to distinguish the direction, and detect the movement in either direction.
3.1.3 X-Y-Stage
The platform moves in the Y direction and the write head moves in the X direction.
X-direction (the write head)
Y-direction (the table)
mask
write head
+-
+
-
HeCd-laser
Figure 4: Movement in X and Y directions, and laser-beam trace.
23
Let us first take a look at the movement in the X direction. The circuit board translates the λ/2 pulses on the interferometer to 1.0 µm unit increments in the X direction. A linear motor is used for running the carriage in the X direction. The movement is linear, not stepwise, and the speed correction signals are processed in real-time using PAL decoders and a signal processor.
The coarse Y-positioning is done with a stepper motor. The fine positioning is done with two piezo translators. When the carriage is moving in the X direction (and the laser is writing), the small errors that are too fast for the piezos to compensate for, are corrected by delaying the laser sweep start point.
3.1.4 Computer System
The computer system is built on the VMEbus. The main features are listed in table 2. Some of the boards are supplied by Micronic, others are OEM (Original Equipment Manufacturer) products. The boards control the whole write system from chassis temperature to laser sweep timing.
Table 2: Computer system
Processor MC68030, 25 Mhz
RAM 8 Mbytes
Disk space 2 drives, each 1 Gbyte
Virtual memory 4 Gbytes
Disk communication SCSI
I/O ports 2 parallel, 4 serial
Ethernet communication TCP/IP
Tape unit 150 Mbytes, 1/4-inch tape cartridge
3.2 Software
The operating system is Motorola UNIX system V Rel. 3, a multi-user environment for real-time applications.
Micronic has supplied the system with some programs to make file format conversions from other formats to their format, i.e. MEBES, GDS II, MANN, GERBER, and ELECTROMASK can all be handled. These formats are the link between the design system and the exposure machine. Using the conversion program, these most well known formats can all be converted to the LSR-55 format of Micronic. Figure 5 shows a flow chart of a job.
24
Read tape
Input file type?
Syntax check: MANN,MEBES, E-MASK, GERBER
Extract GDS layers
Get the sorting options,e.g. offset, array, rotation
Sort the file (fracturing)
Get the exposure options
Write mask
GDS
other
Syntax check
Figure 5: Job flowchart
Micronic also supplies the software for viewing parameters, monitoring the writing process, and calibrating the laser sweep. All these programs come with the machine itself.
3.3 Limitations
The limitations of the LRS-55 are listed in table 3. The most important one in writing is the minimum pattern feature size, which is 3 µm. This means that no one object may be smaller than 3 µm. However, the step size in the X direction is 1.0 µm. Note that the plate size may exceed the exposable area in all four directions by 5 mm.
25
Table 3: Some specifications of the LRS-55
Lifetime of HeCd-laser 2200 Hours
Minimum pattern feature size 3.0 µm
Line width uniformity of write head (3 sigma)
max. error 1.0 µm
Line edge roughness (3 sigma) max. error 0.7 µm
Writing speed 1000 mm2/min (typical) one stripe
Chamber air temperature 20 to 24°C, stability ±0.1°C
Chamber air quality MIL 209C, class 10
Exposable area 550 mm x 500 mm (LRS-55A)
600 mm x 500 mm(LRS-55B)
Exposure to plate edge 5 mm
Stage control laser HeNe, 632.8 nm
Raster increment 1.0 µm
Data address increment 0.12 µm
Overlay accuracy (3 sigma) max. error 0.9 µm
Plate thickness 1.5 to 6.5 mm
Vacuum clamp induced distortion in plate flatness
max. distortion 3 µm
26
4 Objectives of the Program Module
4.1 Background
It is relatively simple to write a macro for a CAD system to copy a structure to places separated by even spacing. However, with very large arrays the system will easily run out of memory space, or at least slow down considerably. There still remains the problem of sorting such vast structure arrays.
The sorting program provided by Micronic is capable of creating an array when sorting the data. The options of the sorting program are very limited concerning uneven spacing of the array points.
These problems accumulate especially when creating a shadow mask for a TV screen. In December 1992 Terapixel had to make a shadow mask master. This master required 7 million holes, and merely the sorting stage took 1 week to accomplish. At Terapixel there were no direct tools to create the holes, because they were unevenly spaced. The only way was to crack the GDS format, and to write a program to create the data. GDS has no circles, so polygons with 12 edges were used as a compromise between accuracy and memory space (GERBER has circles). The data then required a sorting phase. Finally the laser-writing had to be done in nine passes - three passes for each color. The sorted files totally occupied 4 Gigabytes.
Micronic's format specifications for the 'GenPatt'-module - the Generator of Patterns - are now realized in about 150 kilobytes of C source code. The program is capable of generating unevenly spaced arrays of rectangles, polygons, and circles. At the moment the program outputs data into a file, but in the future it will output data directly to the laser-write program in real-time, without creating an output file, only a temporary file of two stripes.
4.2 Tools of the Project
The project was carried out at Terapixel, and the tools were leased from the IC Design Department of the VTT (Technical Research Center of Finland) Semiconductor Laboratory.
4.2.1 Programming Environment
The workstation used was a SUN SparcStation 1 with two remote windows (telnet and ftp) to the LRS-55 through the local-area network, and one window to a SparcStation 10, which was used for C compilation and test runs. The program module was totally developed to run both on the SUN Sparc and on VME. SUN's operating system, SunOS, corresponds to Berkeley bsd 4.2 UNIX, but also has features from bsd 4.3 and System V. VME is using Motorola's UNIX System V. The C compilers had some differences, but all
27
incompatibility problems were solved. SUN has a debugger, which I used only in the beginning stage of the project to examine some, at that time, mystical errors.
I used the SparcStation 10 to run the software, and then transferred the data through the network to the LRS-55, since the former ran the program about 10 times as fast as the latter.
My programming experience is mainly in the Intel-based Personal Computer area, so it was quite a relief to note that an attempt to access an undefined array location in UNIX resulted in the error message 'core dumped'. When using segmenting 16 bit compilers, e.g. Borland and Microsoft C, on PC systems, the attempt results in writing the data into wrong memory areas without a warning. However, on the other hand the C compilers in UNIX will not print out too much of a warning. Then, sometimes I could have used less than what 'lint' lists out.
Object-oriented programming was not found necessary for this project, because the source code had to be quite special. If parts of the source code were needed later in other programs, it would have been a good idea to write the code with objects, if I had known more about them.
There are professional programming environments also available for UNIX systems. The high price is an obstacle when only small projects are rarely initiated. An optimizing compiler for the Sparc architecture was available at no extra cost, but it was not used in this project.
4.3 Input File Format
The complete specifications for the input format is in appendix B. Example input listings can be found in appendices E and F. The main idea is to use arraying commands to spread copies of an object through the entire mask. Small variations of the objects are accepted by the special input format of the commands.
REC draws rectangles, POL draws polygons, and CIR draws circles. The arguments are delimited by white-space characters. Computations are allowed in the argument positions, and are delimited by semicolons. For example
REC 10 ; 20 ; X 2 + ; Y ; 10 DRAD ;
draws rectangles, whose width y=20, and height x=10. The rectangle center is placed in position X+2,Y, and the rectangle is rotated by 10 degrees counter-clockwise. All units are always in µµµµm unless otherwise stated.
The positions X and Y are defined with the command A, e.g.
A 1000 2000 50 70 -1 3 0 5
The array center is x=1000, y=2000. The delta-values, i.e. the spacing of the array lattice points: delta_x=50, delta_y=70. The final positions of the landing points of the objects in global coordinates are: X=1000+50*(-1..3) and
28
Y=2000+70*(0...5). The coordinate axes used by GenPatt are always -90 degrees rotated from the conventional ones (figure 6).
4.4 Output File Format
There are three main types of output segments. Activating a beginning segment will cause the horizontal projection to be exposed (in common language: filled) until the stripe end, or until the next ending segment, see figure 6. Vertical segments are not used. All segments to be drawn must have a Y component.
The three main segment types are the following:
a) An orthogonal line segment is a segment with no X component. Two types: one switches filling on, the other off.
b) A slanted line segment must have dimensions in both X and Y directions. Two types: one switches filling on, the other off.
c) Circle line segments are actually arcs, of which every one must be drawn on one side of the circle center Four types are available: begin-segment under center (smaller X), end-segment over center (greater X); and for inverted images: end-segment under center, begin-segment over center.
X X
beginning circlesegment
ending circlesegment
beginning slantedline segments
ending slantedline segment
stripe end
X
Y
Figure 6: Objects created with beginning and ending segments.
It is allowed to connect these different segment types to form polygons, or even approximations of ellipsoids (with small pieces of arcs and line segments after
29
each other). Various possibilities are feasible. However, the so called butterflies, where for example a polygon crosses itself, are prohibited.
After the output file is ready, it still needs to be converted from 'PattForm2' format to 'PattForm1' format, after which it corresponds to the box in figure 5 where fracturing has already been done. The conversion program produces another file, which is normally at least double the size of the one produced by GenPatt. The conversion program from Micronic should be able to do some real-time processing to a certain degree.
30
5 Structure of the Program Module
The module can be divided into two parts. The first part will interpret the input ASCII text file, and build the pseudocode to run the input. The second part will construct the output data.
The main idea behind constructing the pseudocode is to utilize pointers pointing to functions, and to code the input names into numbers. These numbers can then be used for accessing the right function in an array of functions with just the number code. See section 6.1.
5.1 Input Section
Figure 7 shows the flow chart of the input section. It is much simpler than the output section. The figure is missing some control boxes.
Initialize variables, arrays, pointers.
Get the next string delimited by white-space characters from the input file.
Convert to pseudocode and save to disk.
The final string?
YES
NO
To output section
START
Figure 7: Flow chart of the input section.
Pointers, structures, variables, constants, etc. are initialized in the initialization box. It takes care of the output section initializations, too. Here the pointers to the functions are also set along with the opening memory allocation. Also
31
possible command-line parameters, trace and debug, are analyzed to set the corresponding variables to 1.
After initialization the ASCII input file is opened for reading, and the output pseudocode file for writing. The introductory parameters are extracted from the input (just the first line, where the are no actual commands).
Now the interpretation sequence starts. The program compares every ASCII input string first to the available commands/functions. If a match is found, the index corresponding to the function is transformed into the pseudocode format. If no match is found, the input string will be compared first to the integer character set ("0123456789+-"), and if it matches, the input string is converted to a value with atol(). If the string, however, matches the floating point character set ("0123456789eE.+-") the function atof() is used. Then the converted value is transformed into the pseudocode format. Both atol() and atof() are functions in the mathematics library of C.
The pseudocode memory area allocation is increased until the whole pseudocode fits into the memory, or the allowed maximum limit (set with a parameter) is reached. After this the program starts swapping the pseudocode to the disk. The pseudocode will always be written to the disk. Then one can later examine the pseudocode to find out why something failed.
5.2 Output Section
Figure 8 shows how the window (dotted line) is divided into blocks. One block, at its maximum, is as wide as a stripe is. A block size can be temporarily less. All drawing takes place inside one block at a time. Blocks are used for allowing the program to handle more data in one stripe without memory overflow. The pseudocode will be run through once for each block, therefore it would be good to maximize the block size to speed up the processing.
If pseudocode is too large to fit into base memory, it will be swapped. Note that swapping takes place more/less often than indicated in figure 9. This is adjustable with the pseudocode area size parameter. If the parameter is great enough, no swapping will take place (that is the optimum situation).
The header is first constructed from the data available, and is then output.
The program has a loop sequence. This sequence steps through the whole big window area in small blocks. A stripe is divided into several blocks (parameter specifiable), and all the blocks are then processed sequentially.
32
Y
X
1
2
3
0 4
5
6
7
8
9
Window boundary
Figure 8: Processing order of the blocks.
All blocks are processed in order (see figure 8). Blocks 0,1,2,3 together compose one stripe. At the window boundary, the block size is reduced to fit it into the inside of the window. The blocks are still reduced to fit them into the inside of the sub-windows, which are specified with the CD/DF commands.
The place and the size of the current block are first computed. The block will be handled as a 'minimum window'. When the program encounters a drawing-command, it is executed (it is a function of C, even though, here we use the name 'drawing-command'). The program starts to load the command line arguments from the pseudocode into the FIFO (First In, First Out) memory area. The next pseudocode piece is swapped in automatically when required. FIFO will then be emptied into the stack one item at a time. If the item is a numerical value, it goes directly into the stack, and if it is a function, it will be executed. The performing routine of the function acts directly on the stack items. If there were only completed evaluated numerical values in the pseudocode, the arguments would be piled directly into the stack without using FIFO. The command decides which option to use. Drawing-commands always use FIFO because of computations (separated by semicolons). The drawing-command is ready to pull the items from the stack. The stack was processed into numerical values only.
The array (2-dimensional) consists of one kind of objects only. The drawing-command draws the array into the current block (sub-routines take care of creating the data of the objects). The inner loop of the lattice array points goes on the mask in the Y direction, and the outer loop in the X direction. This way the output primitives of the objects get in place almost automatically. If the objects are unrotated rectangles, this is absolutely true for them.
33
From input section
FINISH
Write out the header.
Choose the next block to be processed.
Load the next pseudocode swap if required.
Load the arguments of the next drawing-command from pseudocode to FIFO.
Call the drawing-command function.
Start a loop-sequence for generating the lattice arraypoints (limit all operations to the current block).
In the drawing-command function, run the functions and the numerical values from FIFO into the stack. The stack will then contain only numerical values (still in pseudocode format).
Get the argument values for the drawing-command from the stack.
Draw the object; perform clipping to limit theobject into the inside of the current block.
Final array point in the block?
PseudocodeEOF reached?
Final blockin the stripe?
Write identifier code for end-of-stripe, update map.
Final stripenumber?
Write out map data.
YES
NO
YES
NO
NO
YES
NO
YES
Figure 9: Flow chart of the output section.
34
After inserting the output primitives into the sorting buffer, they have to be sorted. Today insertion sort /9/ is used for sorting the segments (primitives pointers=prim). This means, that after adding any segment (output primitive) into the buffer area, it will be sorted. The actual data is not moved around the buffer, but the pointers into the data are (fewer bytes to move). Insertion sort was chosen, because the data is almost in a sorted order. One possibility could be to use shellsort, but it is not a guarantee for a better performance. Quicksort was intentionally left out, because the sorting time is N2 /9, p. 115/ for almost sorted data, and it requires a recursive algorithm (the required memory cannot be controlled exactly).
Once the data for one block is ready, i.e. the pseudocode EOF is encountered, the block is written to the disk. If it was the final block in the stripe, the identifier code for a stripe ending is also written out. The map (of the scanstripe) is now updated to show the number of bytes in the stripe.
If the final stripe of the window was just written out, the file pointer will be rewound, and the map will also be written out. Then all files are closed, and the program module terminates.
If the program encounters an error, an error message will be displayed, and the program exits with an exit() returning the number code of the module, where the error occurred, not the error number.
35
6 Program Essentials
6.1 Pseudocode
The decision to use pseudocode was made based on the fact, that this way faster performance could be achieved for the interpreter than in any other way. If this speed was not enough, the next step would be to incorporate the ASCII program into the GenPatt source code, and to compile and run it every time over again. However, the goal of the project was to construct an interpreter.
The idea behind pseudocode is the ability to use pointer arrays to re-direct function execution in C. See appendix E.
6.2 Commands
Commands are actually realized as functions, as everything in C is. The three drawing-commands (REC, POL, CIR) available each have two internal loops to run through the lattice array points, which occupy one block. Actually the loops extend one row and one column outside the block to insure that those objects, which are drawn from the outside of the current block, will create their objects into the inside of it.
EOF, semicolon, CF, DF, and A are also classified as commands. Commands differ from functions (SIN, +, SQRT, etc.) only by their pseudocode action-value. This is because when reading in the arguments of a command, the program knows when to stop (always before the next command). If both functions and commands were classified identically, the program could not differentiate between the two. So, the drawing-command would not know after which argument to start drawing.
When in a drawing-command, it is allowed to do computations. All computations use the logic of RPN (Reverse Polish Notation). This method is very simple for the program, and it will be simple for the user, too. Only some practice is required. It can be done by learning to use a calculator from Hewlett-Packard. At least the scientific and business models use RPN.
6.3 Functions
All functions are run like commands, with an index in the function array. The functions operate directly on the stack, and if we have: 120 140 / ; then '/' pulls two values from the stack, 120 and 140, divides them 120/140 and puts the result back into the stack (see appendix E).
36
6.4 Numerical values
All numerical values in GenPatt are in the double-precision floating point format. Also all the mathematical functions used (sin(), cos(), exp(), sqrt(), etc.) in C accept this format as a parameter.
6.5 Stack (LIFO)
A normal LIFO (Last In, First Out) stack was used. A stack is like a pile of items. The item on the bottom always leaves the pile last. The new items are added to the top of the pile. The items are here referred to as pseudocode data. Everything is, also, removed from the top of the pile (see appendix E).
Drawing-commands use the stack to get final values to their arguments. The raw arguments are copied from FIFO to the stack one at a time. If the copied item was a function, it will be processed immediately.
6.6 FIFO-Buffer
It is possible to load the pseudocode directly into the stack without using FIFO. This is done e.g. with CF, DF, and A commands. However, when a drawing-command executes the array loops, it has to get the pseudocode from somewhere. This pseudocode is normally obtained from the prg_get() routine. Unfortunately prg_get() is not capable of pushing the pseudocode back again (unget). The same pseudocode will be used over and over again because of looping. This is solved by a FIFO-buffer, which inputs the pseudocode from prg_get() once, and is able to run the data into the stack several times in the looping procedure.
6.7 Window Specifications
The window size is specified to be an exact multiple of the so-called data increment. If it is not, the window size is enlarged until it is an exact multiple. This size is then placed in the header. The global window has a CF/DF specification, which will be explained in section 6.8 . One window has to contain one or more sub-windows, and the sub-windows may not overlap each other. All drawing is done inside a sub-window.
37
6.8 CF/DF Specifications
CF (Clear Field) means that the background in a sub-window will be exposed, and the patterns will be unexposed. The result is, that the background will lose all the chrome and the patterns will retain their chrome. If a sub-window area is marked as DF (Dark Field), it will finally have chrome left only in those places, which were not exposed, i.e. not patterned.
It is also necessary to give this specification to the global window. In its case the parameter CF/DF only affects the blank area of the window, where there are no sub-windows. CF will cause the blank area to be exposed, i.e. chrome removed, and DF will leave the chrome left in the blank parts of the window.
6.9 Header Data
The header always contains the creation date, the window size, the version code, the program names, etc. The header is divided into pre-header and header. The former is 90 bytes and the latter 512 bytes. The scanstripe map is 10,240 bytes long, and has 2,560 stripes. It belongs to the header.
6.10 Stripe Lines
The structure of the stripes was explained earlier (see figure 3, and the text in chapter 5). All segments must be sorted in the stripe in an ascending order (X-coordinate) according to the smallest coordinate position of the segment. This is also true for arcs, which might have it in their midpoint.
6.11 Block Approach
All stripes are divided into blocks for processing. The block size can be varied with a parameter, and is limited by the physical memory of the computer. All objects are clipped to the inside of the current block. When the program runs into a CF or DF command, it determines if the current block requires a beginning or ending segment, i.e. if the block sees at least a part of a sub-window. If yes, the segment will be drawn. Either one of CF or DF can make one beginning segment, one ending segment or both into one block.
The drawing-commands loop through the array points in order, including those points which are one row outside the block (top, bottom, left, right). See figure 10. The reason is, that when an object from another block is trying to draw into the current block, that drawing must take place.
38
block boundary
1 2 3 4 5 6 7
8 9
353433
10 11
Figure 10: A pair of extra rows and columns are always included in the array.
6.12 Drawing a Segment
The program has a sub-routine called draw_line() for drawing a line segment. The routine first differentiates between an orthogonal and a slanted line segment, and then calls the appropriate sub-sub-routine. These routines, convert_ortholine() and convert_slantline(), accept, as an input argument, the type of the segment (beginning vs. ending).
It has been specified in the program, that when draw_line() is called with y1 < y2 then the segment is beginning, and if y1 > y2 then the segment is ending; the result is stored. If y1==y2, the line segment will be discarded. To get a correct line type both in CF and DF, the stored result bit is EXORed with the CF/DF bit of the current sub-window.
Arc segments are more complicated to handle. There are four different types, but the basic methods are somewhat the same.
If distinct segments, beginning and ending segments, partly coincide, the common part of the segment is removed, as if there never was a segment boundary. The beginning segments act as creation operators, and the ending segments as destruction operators. When the sum is zero, there is no segment, .i.e. it is removed.
39
6.13 Creating Objects
6.13.1 Rectangles
Rectangles are formed with one beginning and one ending line segment. If a rectangle is rotated, it requires two beginning and two ending line segments (see figure 11). Vertical segments are not drawn. However, the whole area underlying any beginning segment will be exposed totally. This way vertical segments are not required. If exposure is not stopped with an ending line segment, it will be ended by force at the end of the current stripe.
The rectangle on the left side in figure 11 could be created with
REC 20 ; 60 ; X ; Y ; 0 ; and the one on the right with
REC 20 ; 60 ; X ; Y ; 30 DRAD ;
B
B=Beginning line segmentE=Ending line segment
E
BB
E E
Figure 11: Required segments for drawing rectangles.
6.13.2 Polygons
The argument coordinates are specified to go counter-clockwise on the input line. This means that when the polygon drawing-command pulls them out from the stack, they appear in a clockwise order.
The polygon in figure 12 could be created with
POL 10 ; -30 ; 20 ; 20 ; 10 ; 40 ; -20 ; 60 ; 0 ; 0 ; -20 ; 20 ; -40 ; -20 ; -20 ; 0 ; X ; Y ; 0 DRAD ;
where the origin is placed at the intersection of lines 4 and 5. Actually, the origin can be placed anywhere, but that will affect the polygon coordinates.
40
B=Beginning line segmeE=Ending line segment
E
E
E
E
EB
B
B
1 2
34
5
67
8
Figure 12: Drawing a polygon.
Drawing a polygon is almost as easy as drawing a rectangle. We start with the first pair of coordinates in the list. They are connected to the next pair of coordinates. They are then connected to the next ones, and so on. Connecting is done by the draw_line() routine. As we remember (section 6.1.2), it determines itself whether the type of the segment is a beginning or an ending. In figure 12 the coordinates are in a counter-clockwise order, the way they appear on the input line. The output order is irrelevant, because the segments will be sorted by GenPatt. This also makes the rotation of polygons and rectangles possible.
6.13.3 Circles
Circles were the most difficult of the objects. At the moment these are the only objects, which are clipped against all boundaries, including the sub-window boundary. Recall, that upper (beginning) and lower (ending) parts of the arcs both have to be drawn separately.
The original idea was first to follow the intersections of the upper arc and the block, from left to right, and to connect the joins by drawing. Then the same thing is repeated for the lower arc. This algorithm failed because of a large number of hierarchical if-then-else comparisons. Moreover, the method was unable to cover all possible alternative circle and block joins. The algorithm required a growing number of comparison statements. Then it was obvious, that the approach was not so good. It was discarded.
The next idea was to begin from the left starting point of the arc, and follow the circle boundary clockwise - the whole time finding and storing all block boundary intersections - until to the right-side ending point. The same process is repeated with the lower arc, continuing clockwise, until arrived back to the left-side starting point. Then vertical lines and too short segments will be filtered out, and the joins will be output correctly, i.e. arcs and lines as they were. This algorithm was relatively easy to implement, and it seems to be working very well. Figure 13 shows the problems arising from detecting circle intersections with a block boundary, and connecting the joins with segments.
41
B=beginning line segmentE=Ending line segment
block boundary
block boundary
B
E
BB
B
E
Figure 13: Paths within blocks.
42
7 Testing the Module
The module has already been tested with large monotonous arrays of rectangles, polygons, and circles. The real test for the algorithms can be a small one, but the items must be chosen carefully. In this chapter one such test is presented.
7.1 Sample Test Run
7.1.1 Theoretical Drawing
We shall now run a complicated test pattern on GenPatt to be sure that the program works. The test pattern (figure 14) has two rotated rectangles at every stripe boundary to show the clipping points. There is also one block boundary at 10,000 µm in the upper sub-window. The type of the upper sub-window is DF. Hence, the objects will be exposed, and later removed. The lower one is CF, i.e. the background will be etched away, and the objects will remain left.
The first real test object is a rectangle. It will be arrayed to five copies, and each one will be rotated. The rotation angle depends on the position. If a rectangle is to the left of 1,024 µm, the angle is negative growing, and if it is to the right of 1,024 µm, it is positive growing. The next objects are three polygons grouped together to form the text MK with a border around it. The rotation scheme will be the same as for the rectangles (see figure 15). The last objects are circles, which will be unevenly spaced. The distance will grow from 1024 µm in both directions. Note that the largest circle intersects the sub-window boundary, and is thus clipped.
43
512um 1024um 1536um
DF
512um 1024um
CF
blockboundary
1536um
Figure 14: Test pattern.
44
Figure 15 shows the actual structures of the polygons used. The circle indicates a beginning point of a polygon. The origin is the same for all three polygons, it is the midpoint marked with X. All polygons are rotated about this point. GenPatt absolutely requires that the user inputs all the coordinates of polygons in a counter-clockwise order.
polygon starting point
common origin, i.e. rotation center10um
10um
1
2 3
1=polygon number one, 2=polygon number two, 3=polygon number three
X
Y
Figure 15: Polygon test structure.
7.1.2 The Actual Mask: photographs
To assure that GenPatt can actually handle this input code, the photographs of the result are shown in figure 16. Figure 17 is a pair of photographs of a large combination array of rectangles, polygons, and circles (see appendix H for listing).
45
Figure 16a: The test pattern (Dark Field)
Figure 16b: The test pattern (Clear Field)
46
The combination array in figure 17 was created with the input in appendix H.
Figure 17a: Combination array (Dark Field). Distance between the centers of the circles and the triangles (polygons) is 100 µm. The radius of the circles is constant, 10 µm. The spacing of the rectangle centers is 200 µm.
Figure 17b: Combination array (Clear Field).
47
Figure 18 shows the single arrays generated with the listing in appendix I. Note that the rectangles are oversized, and are thus overlapped. Both rectangles and polygons are rotated by (X+Y)/10 degrees.
Figure 18a: Single array of circles (Dark Field). Spacing between the elements is 50 µm. The radii are all 10 µm.
Figure 18b: Single array of circles (Clear Field)
48
Figure 18c: Single array of oversized and rotated rectangles (Dark Field). Distance between the centers of the objects is 50 µm. The rotation is (X+Y)/10 degrees.
Figure 18d: Single array of oversized and rotated rectangles (Clear Field)
49
Figure 18e: Single array of rotated polygons (Dark Field). Distance between the centers of the objects is 50 µm. The rotation is (X+Y)/10 degrees.
Figure 18f: Single array of rotated polygons (Clear Field)
50
8 Conclusions
The time schedule for finishing GenPatt was set for 3 months. When looking at the project now, the schedule seems a little too optimistically set. In reality it took 7 months of hard work. Some details in GenPatt can still change.
8.1 Reliability
GenPatt is very reliable in a UNIX environment. The program module has much internal checking, dozens of error messages and some warnings (see appendix A). The possible errors arise from the ASCII input file.
The worst problem is the stack. Stack manipulation differs a lot from normal calculations, though stack operations are powerful, when used correctly. Hewlett-Packard calculators all have identically working stacks. If extra items are placed (or missing an operation after two parameters) in the stack on each run, it will fill up, and the program will terminate after giving an error message. These kinds of problems are difficult to spot when writing the input file. If, however, the drawing-commands are missing arguments, the stack will then try to remove items from a zero sized stack, and an error message will be printed, and the program will terminate. GenPatt controls the situation.
Mathematical operations are vulnerable. All disallowed values of functions cannot be determined, e.g. the C function of sin() accepts larger arguments than 2*pi, but what is the maximum, or should one always compute fmod() before taking sin()? This way a true program crash can happen, i.e. in UNIX the message 'core dumped' will appear.
The third problem could be the value range. Line-clipping and object-drawing are done in input units, i.e. without the input_unit multiplier. Finding intersections and doing other operations with very large numbers could be dangerous. All values are handled in a double-precision floating-point format, and should prevent this hypothesized third problem from happening. It will be necessary to test also GenPatt with huge circles, whose centers are outside the sub-window area, even outside the window area.
8.2 Speed
All checking, although necessary, requires resources from the processor. This, of course, means that drawing speed will decrease. A 25 MHz Motorola-68030 processor very likely corresponds roughly to a 25 MHz Intel-80386. The data buses are different, but a computer with a 33 MHz i80486 corresponding to a 40 MHz i80386 is probably faster than the first mentioned MC68030. For this reason see section 9.6.2.
51
If large arrays are to be created, it is good to remember the processing time each object requires. The processing speeds of the objects go from fast to slow:
a) rectangles
b) polygons with few vertices (max. 4)
c) circles
d) polygons with many vertices
8.3 Amount of Data
The header and the map together contain about 10 kilobytes. A non-rotated rectangle requires a minimum of 16 bytes, a rotated rectangle practically a min. of 48 bytes, a polygon 12 bytes for each edge (face), and a circle a min. of 32 bytes. If the objects intersect with a block boundary, more output primitives are required.
8.4 Extendibility
It is quite easy to extend the number of functions and drawing-commands. When a new function is added, it goes like this:
a) Add a new number to module 'funct_1.c' to be the index, and adjust (increase) the #define F_LAST statement of the largest index number (statement is in 'funct_1.c').
b) Write the operation of the function to 'funct_2.c'.
c) Add the command text name to 'funct_3.c'.
d) Set the pointer of the function in 'funct_4.c'.
e) If you added an error message, put it in the list of errors and warnings (appendix A).
The procedure is small, and the new function will be available after a re-compilation.
8.5 Overall Performance
8.5.1 VME
With the present processor (25 MHz MC68030), it is very difficult to run extremely large applications. The speed is too slow, probably about 5 MIPS (Million Instruction cycles Per Second). Motorola now supplies a newer CPU board with a 33 MHz MC68040, and Micronic recommends it, since the programs run approximately 6 times as fast as with the current processor.
52
Motorola already has plans to design the next version of the CPU, MC68060 (I recall, that the 68050 was never introduced).
8.5.2 SUN
On a SparcStation 1 (the processor performs about 13 MIPS), the module runs quite efficiently (the processor corresponds to a 25 MHz Intel-80486).
8.6 True Customer Example: A Shadow Mask
The first really serious test job for GenPatt will be to put 7 million holes on a mask master. According to the calculations in section 8.3 it will require a minimum of: 10 kilobytes (header) + 7 x 106 holes x 32 bytes/circle = 224 megabytes of disk space. The true required space will probably be less than double that = 448 Megabytes (without the conversion). The processing time will depend on the block size, and if GenPatt is to be run on VME or SUN.
GenPatt has never before been tested on this scale, and it will be very difficult to make any predictions.
53
9 Future
GenPatt is only a preliminary step into the world of shadow mask manufacturing. It is possible to introduce many modifications to the program module to enhance its operation. In this chapter some will be considered.
9.1 Error Checking
It is possible to add a lot of checking into the program. For example the input file can be verified more thoroughly to improve syntax error checking. Although, I think a greater problem will be the logical errors, and the uncertainty of not seeing the mask before processing it.
Run-time checking could be realized by choosing a character (or taking the semicolon function into use). When the pseudocode hits this character, a stack check will be performed to verify that the user file did not input any extra stack items. There could be a counter to count up every time after running into the special character. Then the number of items in the stack should match the counter value, otherwise there are extra items in the stack. When the drawing-command pulled all its arguments from the stack, it should be empty of items. These are not big modifications, and one could ask why they have not been made already. It would require some new negotiations about the specifications of the input format. Extra checking always slows down the program. In this connection it would be nice talk about another format change, about adding size scaling coefficients to rectangles and polygons. Another helpful thing would be to get saveable variables working. Then the result of a long computation could be saved in a variable, and used later on.
9.2 Parameter File
The main idea in programming GenPatt was to avoid #define directives when handling only variables, which were used for memory allocation. Had direct #defined arguments been used for allocating array tables (e.g. long int prim[size]), the size would not have been alterable. Instead all memory allocations are carried out by using malloc() and realloc() functions of C. They accept variables as arguments, and no #defines were used.
It is possible to create a parameter file outside the source code to be read by the executable code. This parameter file will contain all possible parameters, and bring them to the user. The source code will not have to be recompiled after a parameter change. Actually the explanations in the list of errors in appendix A was written with a parameter file in mind. The parameters there are referred to as user-changeable. These parameters include block size, size of primitives sorting space, stack size, FIFO size, etc. GenPatt can also readily generate data for the LRS-18, the previous model from Micronic. The only modifications are
54
to the required raster increment, and to the scanstripe width, which is only 128 µm. Also the LSR-18 cannot process as large masks as the LRS-55 can.
9.3 Rectangle and Polygon Clipping
In this version of GenPatt, rectangles and polygons are not clipped against sub-window boundaries at all, they are deleted. However, the lines are clipped to fit inside a block, but in case an object lands partly outside of a block, the segment beginning is not set. The beginnings of segments implicitly extend themselves into succeeding blocks. The same is also true for the ends of segments. If a part of a rectangle or a polygon is drawn outside a sub-window, the whole object shall be deleted, i.e. not even a part of that object will be drawn.
9.3.1 Clipping against a Rectangular Boundary
It is also possible to modify the program to clip those rectangles and polygons, which land on a sub-window boundary. Let us first take a look at the upper side of the block. When the data for a block is created, it is necessary to find the lines above (to infinity) it, and to project them onto the block top (see figure 19).
Then, if the number of intersections of the lines going left exceeds the number of those going right, a block segment beginning is set at the top of the block. The top intersection can also be on the block boundary. Then a shorter block segment beginning will be set (till/from the intersection with the block).
Thus, correspondingly if we are on the bottom boundary of the block, the intersections are projected upwards to the block bottom. When the right-going intersections exceed the left-going, a block segment end is set to the bottom boundary of the block.
This way, of course, the block size would be a minimum of the original block and the one limited by the sub-window boundaries. After the modification each block would be self-sufficient.
This kind of checking would considerably reduce the speed the program is able to achieve in creating rectangles and polygons. Any optimization, when the whole object is inside the block, would be out of question, because the required shadow-mask rectangles are typically 600 µm wide (Y direction) and 40 µm high (X direction), and the stripe width is 512 µm. If the time required for drawing an object is 10, then after this modification it would be roughly 30. In addition, to determine the drawable parts, the whole object has to be put through the clipping algorithm twice more, to determine the upper segment start and the lower segment end of the block.
Alternatively, a similar method could be adopted to clip polygons, as is already in use for clipping circles. In the boundary search of this block, polygons would be traced line by line to save only those parts that are inside, always connecting loose ends on the boundary region.
55
9.3.2 Clipping against an Arbitrary Boundary
Micronic has expressed their interest in sub-windows, whose boundaries are arcs of circles. The radius of a circle could be from almost zero (point) to infinity (straight line). Some computational problems can emanate from the size of the radius, e.g. numeric precision, overflow, etc.
Other sub-window boundaries could also be used. These are splines, B-splines, higher order polynomial curves, Bézier curves, etc.
When clipping against an arbitrary boundary (related to sorting in three dimensions), three methods /10, pp. 273-274/ are usable:
a) To constrain oneself to quadtree (on a plane) representation.
b) To approximate the curve with a polygon.
c) To deal directly with the equations of the curves.
Only method a) is quite unacceptable for GenPatt (because of the output format), but either b) or c) could be used.
sub-window boundary
8 8
polygon
block boundary
Figure 19: Clipping polygons
56
9.4 Real-Time Processing
At the moment Micronic supports the merging of multiple 'PattForm1' -files during laser-write. This way, however, files are required. The original objective of GenPatt's future at Micronic was to write the program module so that it could be modified to create patterns in real-time. Only a communication link between GenPatt and the write-program would be required, either a temporary file or a common memory area.
9.4.1 Modifications
The modifications for such real-time processing are reasonably small. GenPatt writes out data in stripes (blocks), and they can be output to temporary files. Such a file is the input for the write-program, which writes it out as soon as the data creation of the stripe is finished. In this scenario the write-program has an integrated 'PattForm2' to 'PattForm1' conversion routine. It should be ready, or at least almost ready at Micronic.
9.4.2 Multiprocessing
At Micronic Mr. Thurén wanted GenPatt to have an advanced pattern handling scheme. The parts, which go over the stripe boundaries will be saved to be their own segments in later stripes. It was agreed to be a much too advanced technique at that point, so the block approach was chosen.
In a way it was a good decision, because there are no objects laying around with 'strings' attached to other stripes, but each stripe is complete. Therefore, it is possible to modify GenPatt for multicomputer purposes. A multicomputer is classified to the MIMD (Multiple-Instruction stream, Multiple-Data stream) class /15, p.41/. Multicomputer systems have several processing units, of which each computes a small part of the same problem. In this case one processor could be producing one stripe. This, again, requires creating a file of each scanstripe, and then putting the files together. This way the creation of the file speeds up with a multiplying factor as big as the number of processors in the system is. Those masks, which have a lot of objects, can be run more quickly, but for the very same masks the output files will build up. This could be a serious drawback.
A better choice would be to assign each processor one block of the stripe to process. This way the processing can be speeded up by the same factor as before, but the amount of output data is restricted to only one stripe at a time.
For example, some years ago a student at HUT, Mr. Andreas Gustafsson, wrote a program to compute the Mandelbrot fractal picture in a multicomputer environment. The university net had 20 student workstations, and each was used for computing a small block of the whole picture. The computing power corresponded to hundreds of MIPS, and the performance of the program was very impressive.
57
9.5 Visual Pre-Viewing
9.5.1 Using Photographic Methods
A simple addition to GenPatt would be to use photographic paper for preliminary exposure - or photographic plates, if they are inexpensive. A very large mask blank can cost as much as US $10,000 and there is no guarantee that the exposure will be correct the first time.
9.5.2 Pattern Verification
It could be possible to extract the raster data from the rasterizing algorithm in the LRS-55. This requires knowledge of the programs in the machine, and probably is not realistically possible without extensive co-operation from Micronic.
9.5.3 Post-Script Format
Because the GenPatt output data is already in a vectored format, it should be relatively easy to add a feature to the program to also output a Post-Script file. This file can then be printed out, or readily viewed on a UNIX workstation. UNIX supports Post-Script very well with various viewing and editing programs. This way the only problem is the amount of data, which will build up tremendously if the whole mask is scaled to a basic laser printer with 300 dpi (dots per inch). The size of A4 paper is 210 mm by 297 mm. This way we get 2480 by 3507 pixels. To achieve the same precision as in the LRS-55, we should scale 1 µm (LRS-55) to 1 pixel (printer). This way a sheet of A4 paper shows clearly only about 2.48 mm by 3.51 mm. Viewing large masks this way would be almost totally unacceptable without having an option to zoom in and out. Also workstations cannot handle such vast amounts of data as one whole mask might have in one Post-Script picture file.
9.5.4 Viewing at a Workstation
The best way would probably be to pre-view the mask at a workstation with a special program. This way the data can be formed only from those blocks (or part of the blocks), which are of interest. Zooming in and out would not be a real problem. Only if the data is required from the whole mask might the computations take a long while. So, the more computing power you have, the better. Viewing at a workstation is probably the best choice, because there are not any material costs after the viewing program is written. Unfortunately programming in the X-Window System is not easy at all, and it could be a project for the distant future.
58
9.6 Program Portability
9.6.1 UNIX Systems
The C source code of GenPatt can be compiled on various UNIX systems, at least on system V. The severe requirement is that the file system saves variables of the highest order data first and the lowest order data last.
9.6.2 PC Compatibility
If running UNIX on a PC, GenPatt can be compiled there. If, however, one wants to run GenPatt directly under DOS or OS/2, or some other operating system, it is possible. The following things have to be secured:
a) Make sure to use a true 32-bit compiler, like the ones from Zortech or Watcom. At this time the compilers from Borland and Microsoft will not work. When compiling in the 32-bit mode, the keywords far and near for variables are not allowed, and all variables should be addressed with true 32-bit pointers (in the code, just plain variables, e.g. long int test).
b) Recheck that in the GenPatt source code all int identifiers have a more specific notation, e.g. short int, unsigned short int, long int, unsigned long int. If there is somewhere a plain int, change it to long int; unsigned int should be changed to unsigned long int, i.e. all int's are long.
c) Test the file handling of the compiler output on unsigned short integers. The output two bytes should be in an order, where the high-order byte comes first and the low-order byte second. It would also be wise to test unsigned long int the same way. Do not try to write out structures with such items (the system can throw in some pointers in between the data, as happens at least on SUN).
d) remember to link in the mathematics library.
If the compiler does not give an error alert, you are ready to run the executable code. I could not get my hands on a 32-bit compiler, so I had to experiment with a Borland C++ v. 3.1 in the huge mode. The compilation was fine, but I got a run-time error complaining about an overflow. Personally I am convinced, that this is due to compiler segmenting (produces non-32 bit code).
9.7 Other Possibilities
If precise aligning of wafers were possible in the LSR-55, it could be thinkable to produce layers of prototype structures with direct wafer writing. This also goes for GenPatt output.
59
Appendix A: List of Errors and Warnings
genpatt.c
E_002 Pseudocode memory allocation error. Location: 'genpatt.c'. It means that malloc() failed with very small arguments (unless the initial allocation value was changed) when allocating memory for pseudocode.
E_003 The ASCII input file name was not given. Location: 'genpatt.c'. It means that the user, who is running GenPatt, did not give the name of the ASCII input text file, or mistyped the name (the given file name does not exist).
E_004 Memory allocation error of output primitives and indices. Location: 'genpatt.c'. It means that malloc() failed with very small arguments when allocating memory for output primitives (lines and arcs). Same type of error as E_002.
funct_a.c
E_005 Could not open the file name for reading. Location: 'funct_a.c'. It means that the user did still not give the input file name correctly, or it does not exist.
E_006 Parameter should be CF or DF. Location: 'funct_a.c'. The parameter for the whole window is defined to be CF or DF. CF means that the area of the window, that is free from the sub-window area, will be exposed. DF means conversely that the specific area will not be exposed.
E_007 Could not open 'filename'. Location: 'funct_a.c'. The input file name is still misspelled. It could be a good idea to try the file name with the whole path. If the input filename contains extensions, these will also have to be supplied to GenPatt.
E_009 The input file was too short and did not contain all the fields. Location: 'funct_a.c'. There is an error in the number of input arguments in the ASCII input text file just before the user commands begin.
E_010 Illegal input length. Location: 'funct_a.c'. The input command length is zero characters long. Should be at least one character.
E_011 Memory allocation failed, all data lost. Location: 'funct_a.c'. The user defined the pseudocode data area too large for the system to handle. Reduce the pseudocode data area size parameter.
E_012 Out of memory after disk write. Location: 'funct_a.c'. The pseudocode data block was written to the disk, but the succeeding memory allocation failed.
E_013 Failed writing pseudocode to disk. Location: 'funct_a.c'. Disk write returned an error, the disk could be full.
60
E_014 Failed writing program code to disk. Location: 'funct_a.c'. The pseudocode allocation routine asked for a disk write, but this failed. Essentially same as E_013.
E_015 Could not interpret. Location: 'funct_a.c'. The input command is not in accordance with the syntax. There is a syntax error in the ASCII input text file.
E_016 The end-of-file keyword not found. Location: 'funct_a.c'. The input ASCII text file is missing 'EOF' from the end of text.
E_017 Disk write error occurred while writing program data. Location: 'funct_a.c'. GenPatt was not able to write the pseudocode program to the disk. The disk could be full.
E_054 Unable to process a file with this header code. Location: 'funct_a.c'. The four first letters in the input text file must read EXTR with capital letters.
E_055 Unable to process a file with this version code. Location: 'funct_a.c'. The version code must be of format AXX.XX, where X's denote numbers. The version code for the first GenPatt release is A00.00, the letter A is always capitalized.
E_057 Disk services not available. Location: 'funct_a.c'. GenPatt previously determined that disk writes will fail, and if the pseudocode is too large to fit the user-specified pseudocode area (and a disk swap is needed) this error will occur.
E_059 Data output stuck (disk full?). Location: 'funct_a.c'. Disk write failed in a pseudocode write frame. The disk became full or inaccessible during the disk storing of the pseudocode.
funct_b.c
E_101 Stack index negative out of range. Location: 'funct_b.c'. The user input to GenPatt an ASCII text file, which did not contain enough arguments for a command. The converse of E_107.
E_103 Could not allocate more stack space. Location: 'funct_b.c'. This means that the computer ran out of memory when allocating more. It is a physical limitation of your computer.
E_105 Could not read pseudocode program from disk. Location: 'funct_b.c'. GenPatt was not able to load the next (or the first) pseudocode swap from the disk. The pseudocode file (*.prg) has been removed, replaced, renamed, or otherwise misplaced during the GenPatt execution. Only a user with the same login name (or system manager privileges) has been able to do this (or a program with the described privileges has done it).
E_106 Internal prg_unget fatal error. Location: 'funct_b.c'. GenPatt can unget only one pseudocode datum. This is only an internal check. It could indicate a syntax error in the ASCII input file.
E_107 Stack size overflow. Location: 'funct_b.c'. Memory allocation exceeds the limit allowed by the user-definable stack size parameter. Increasing
61
the size could lead to E_103. One cause of the error could be that the input file contained more arguments for a command than required. These arguments will pile up in the stack, because the commands remove only the number of arguments they require for executing the command.
E_109 Pseudocode program file inconsistency read error. Location: 'funct_b.c'. The pseudocode (*.prg) was too short. Someone or something has deleted a part of the file. For possible reasons see E_105.
E_111 Illegal code in the pseudocode action register. Location: 'funct_b.c'. The pseudocode is corrupted in some way. See also E_122.
E_113 Constants not allowed in pseudocode program. Location: 'funct_b.c'. Numerical constants are not available in this version of GenPatt.
E_115 Pseudocode program file input opening failed. Location: 'funct_b.c'. The recently (on the same run) created pseudocode file (*.prg) does not exist any more. For possible reasons see E_105.
E_116 Pseudocode program file input failed. Location: 'funct_b.c'. GenPatt was able to open the pseudocode input file, but was not able to input data from it. For possible reasons see E_109.
E_117 Could not create output data file. Location: 'funct_b.c'. GenPatt was not able to open the output file (*.st) for writing. The file name exists and is write-protected, or another program is using a file with this name.
E_122 Only a command was allowed. Location: 'funct_b.c'. Here only a pseudocode command was allowed. The pseudocode is in error. This is an internal integrity check. It is an indication of a hardware error, or a compilation error in GenPatt.
E_130 Pre-header was not written out correctly. Location: 'funct_b.c'. The pre-header has exactly 90 bytes. This error could indicate that the file system is different on this computer, or the C-compiler produces executable code, which has an inappropriate file handling scheme. Could also indicate a full disk.
E_131 Header size info was not written out correctly. Location: 'funct_b.c'. The data area for the header size is exactly 4 bytes. The same type of error as E_130, although it could indicate a full disk.
E_132 Header was not written out correctly. Location: 'funct_b.c'. The data area for the header must be exactly 512 bytes. The same type of error as E_130, although it could indicate a full disk.
E_133 Scanstripe header was not written out. Location: 'funct_b.c'. Could indicate a different file system (as in E_130), or just a full disk.
E_153 FIFO size overflow. Location: 'funct_b.c'. Memory allocation exceeds the limit allowed by the user-definable fifo size parameter. Increasing the size could lead to E_157.
62
E_155 Failed ungetting pseudocode. Location: 'funct_b.c'. There were two pseudocode ungets after each other, but only one unget is possible before the next get. An internal check, but could indicate an error in the ASCII input file, as in E_106.
E_157 Could not allocate more FIFO space. Location: 'funct_b.c'. Out of physical memory, the same type as E_103.
E_163 Tried to read past FIFO end. Location: 'funct_b.c'. FIFO is filled from the pseudocode, and stack is filled from the FIFO. A rare error that could indicate some sort of input syntax or argument (or missing/excessive arguments) error.
E_165 Could not read from disk. Location: 'funct_b.c'. The pseudocode program file (*.prg) is inaccessible. For possible reasons see E_105.
funct_2.c
NOTE: X and Y are now used here as parameters (any numbers), they are not to be confused with the input code position variables X and Y.
E_201 Stack multiplication error. Location: 'funct_2.c'. The routine pulls two numbers from the stack, multiplies them, and puts the result back into the stack. Putting the data back into the stack has failed for some reason.
E_202 Stack addition error. Location: 'funct_2.c'. The same error as for E_201.
E_203 Stack subtraction error. Location: 'funct_2.c'. The same error as for E_201.
E_204 Divide by zero error. Location: 'funct_2.c'. Divide operation failed due to an attempt to divide by a zero denominator.
E_205 Stack divide error. Location: 'funct_2.c'. The same error as for E_201.
E_206 Stack 2^X error. Location: 'funct_2.c'. The same error as for E_201.
E_207 Stack 10^X error. Location: 'funct_2.c'. The same error as for E_201.
E_209 Stack X^Y error. Location: 'funct_2.c'. The same error as for E_201.
E_210 Zeroth root error. Location: 'funct_2.c'. You cannot extract root zero from a number. Check your input.
E_211 Stack X \/¨¨ Y (=XROOTY) error. Location: 'funct_2.c'. The same error as for E_201.
E_213 Stack exp() error. Location: 'funct_2.c'. The same error as for E_201.
E_215 Stack expm1() error. Location: 'funct_2.c'. The same error as for E_201. The expm1 routine will be able to evaluate exp()-1 with good precision especially for small X. The routine has not yet been modified for this use.
E_218 Non-positive log2() error. Location: 'funct_2.c'. The argument of a logarithm may not be zero, nor negative.
E_219 Stack log2() error. Location: 'funct_2.c'. The same error as for E_201.
63
E_222 Non-positive log10() error. Location: 'funct_2.c'. The argument of a logarithm may not be zero, nor negative.
E_223 Stack log10() error. Location: 'funct_2.c'. The same error as for E_201.
E_226 Non-positive log() error. Location: 'funct_2.c'. The argument of a logarithm may not be zero, nor negative.
E_227 Stack log() error. Location: 'funct_2.c'. The same error as for E_201.
E_230 Non-positive log(1+X) error. Location: 'funct_2.c'. The argument of a logarithm may not be zero, nor negative. Good precision, especially for small arguments. The routine has not yet been modified for this use.
E_231 Stack log(1+X) error. Location: 'funct_2.c'. The same error as for E_201.
E_234 Negative argument SQRT error. Location: 'funct_2.c'. Extracting the square root from a negative number is not allowed.
E_235 Stack SQRT error. Location: 'funct_2.c'. The same error as for E_201.
E_237 Stack square error. Location: 'funct_2.c'. The same error as for E_201.
E_238 Argument out-of-range ASIN error. Location: 'funct_2.c'. Check the argument range for the arcus sine function.
E_239 Stack ASIN error. Location: 'funct_2.c'. The same error as for E_201.
E_240 Argument out-of-range ACOS error. Location: 'funct_2.c'. Check the argument range for the arcus cosine function.
E_241 Stack ACOS error. Location: 'funct_2.c'. The same error as for E_201.
E_243 Stack ATAN error. Location: 'funct_2.c'. The same error as for E_201.
E_245 Stack SIN error. Location: 'funct_2.c'. The same error as for E_201.
E_247 Stack COS error. Location: 'funct_2.c'. The same error as for E_201.
E_249 Stack TAN error. Location: 'funct_2.c'. The same error as for E_201.
E_251 Sincos() not available. Location: 'funct_2.c'. The purpose of this function is to utilize the sincos floating processor command (on the MC68030) to compute both sin and cos of an argument. This will take less time than computing the same things separately. This function is not available in GenPatt.
E_253 Stack SINH error. Location: 'funct_2.c'. The same error as for E_201.
E_255 Stack COSH error. Location: 'funct_2.c'. The same error as for E_201.
E_257 Stack TANH error. Location: 'funct_2.c'. The same error as for E_201.
E_258 ASINH not available. Location: 'funct_2.c'. The hyperbolic arcus sine is not available; resort to mathematics textbooks.
E_260 ACOSH not available. Location: 'funct_2.c'. The hyperbolic arcus cosine is not available; resort to mathematics textbooks.
64
E_262 ATANH not available. Location: 'funct_2.c'. The hyperbolic arcus tangent is not available; resort to mathematics textbooks.
E_265 Stack ABS error. Location: 'funct_2.c'. The same error as for E_201.
E_266 MOD by zero error. Location: 'funct_2.c'. The second argument has a value of zero. To compute MOD, one divide operation is required, and will result in divide by zero error. The operation is cancelled.
E_267 Stack MOD error. Location: 'funct_2.c'. The same error as for E_201. the MOD command is used for computing the modulus, i.e. the integer part of the remainder. This routine works with floating point numbers. You could get results differing from the integer routine in C (x % y). It is of no use to try to write the integer routine, because all computations in GenPatt are done in the floating point, double-precision format. It uses fmod() of C.
E_ 269 Stack NEG error. Location: 'funct_2.c'. The same error as for E_201. Negating the front sign of a number failed.
E_271 REM not available. Location: 'funct_2.c'. This remainder function acts as MOD, but the resulting signs are different. This function is not yet available in GenPatt.
E_273 Stack SCALE error. Location: 'funct_2.c'. The same error as for E_201. Scaling means here x*(2^y). In MC68030 it is done by shifting bits up (y is first made an integer by a floor() function). Here we do the very same thing without resorting to computer dependent instructions. It takes a little longer time.
E_275 Stack FLOOR error. Location: 'funct_2.c'. The same error as for E_201.
E_277 Stack DRAD error. Location: 'funct_2.c'. The same error as for E_201. DRAD converts degrees into radian. All the drawing command rotations use radian.
E_278 Stack RDEG error. Location: 'funct_2.c'. The same error as for E_201. RDEG converts radian into degrees.
E_279 GRAD not available. Location: 'funct_2.c'. The conversion for gradian to radian is not yet available in GenPatt.
E_280 Got unexpected data type from fifo. Location: 'funct_2.c'. The rectangle creating routine took datum from FIFO. It was not a function, nor a number (the only two types allowed). This could result from putting two of the command words directly after each other. There is a syntax error in the input file.
E_282 Got unexpected data type from fifo. Location: 'funct_2.c'. The polygon creating routine took datum from FIFO. See E_280.
E_284 Error in number of stack arguments for polygon. Location: 'funct_2.c'. The error results from a missing argument/arguments for the polygon command.
65
E_288 Got unexpected data type from fifo. Location: 'funct_2.c'. The circle creating routine took datum from FIFO. See E_280.
E_289 Negative or zero circle radius. Location: 'funct_2.c'. The radius argument in the circle is non-positive. You cannot draw a circle with a negative, or zero size radius. Correct the input file.
funct_c.c
E_301 Primitives allocation error, data is lost. Location: 'funct_c.c; subroutine: output_ortholine'. An error occurred when allocating more memory for othogonal line segment output primitives. The reason is the physical memory limit of the computer.
E_302 Prim allocation error, data is lost. Location: 'funct_c.c; subroutine: output_ortholine'. Error is identical to E_301 with the exception, that the memory allocation was for an index table ( with indexes, not pointers) into primitives.
E_304 Internal logical error. Location: 'funct_c.c; subroutine: draw_arc'. The routine determines the smallest X-coordinate of an arc (left, right, middle), and then calls the routine, which inserts the primitives data into the array. Should not occur.
E_305 Primitives allocation error, data is lost. Location: 'funct_c.c; subroutine: output_slantline'. Error is identical to E_301, but with slanted line segments.
E_307 Prim allocation error, data is lost. Location: 'funct_c.c; subroutine: output_slantline'. Error is identical to E_302, but with slanted line segments.
E_308 Primitives allocation error, data is lost. Location: 'funct_c.c; subroutine: output_circle'. Error is identical to E_301, but with arc segments.
E_309 Prim allocation error, data is lost. Location: 'funct_c.c; subroutine: output_circle'. Error is identical to E_302, but with arc segments.
E_310 Ortholine has zero length. Location: 'funct_c.c'. If the length of a segment is zero, it should have been discarded before. This error tells about internal computation misalignment.
E_311 Internal delta-y computation error. Location: 'funct_c.c'. When creating a slanted line segment the program first evaluates delta-y to be non-zero (if it equals zero, the program should have discarded the line previously).
E_312 Internal delta-x computation error. Location: 'funct_c.c'. When creating a slanted line segment the program first evaluates delta-x to be non-zero (if it equals zero, the program automatically calls the orthogonal line segment routine). Later evaluations with the same algorithm give a zero value. Used for internal checking, and the error should never occur.
66
E_317 Out of space for output primitives sorting area. Location: 'funct_c.c'. All output primitives are sorted in the X direction. The user-specified parameter for the sorting space size is too small for the specified block size. Reduce the block size to overcome this problem. You can also increase the parameter for the sort space size, but beware of the CPU memory shortage. The possible resulting errors are E_301, E_302, E_305, E_307, E_308, or E_309 (not E_304).
E_319 Out of space for prim index table. Location: 'funct_c.c'. The index table into primitives space area exceeded the user-defined limit. Reduce the block size, or increase the index table size parameter. See E_317 for results.
E_321 Negative index error when deleting prims. Location: 'funct_c.c'. The program tried to delete more output primitives than were created into the primitives space area. Only REC and POL commands use primitives deletion. This error indicates an internal error in deletion algorithms. Should never appear.
E_323 Data area lost when freeing memory. Location: 'funct_c.c'. After having finished writing any scanstripe the primitives storage space is reduced to a minimum (2 items). The same is also true for the prim index table (items point into the 'primitives' space).
E_325 Non-allowed line clipping code. Location: 'funct_c.c'. The line-clipping algorithm determines the parts of all lines, that show in every block. If the return code from the routine is an undetermined one, this error message appears. Indicates a flaw in the algorithm - used for internal checking only. This error should never appear.
E_351 Internal inconsistency error. Location: 'funct_c.c; subroutine: draw_circ'. The circle drawing algorithm is extremely complicated, and this error message will indicate a flaw in the algorithm. It is an internal check for missing an option in the left-side intersections of the block with the circle. Should never appear.
E_353 Internal inconsistency error. Location: 'funct_c.c; subroutine: draw_circ'. Internal check for the top intersection. See E_351.
E_355 Internal inconsistency error. Location: 'funct_c.c; subroutine: draw_circ'. Internal check for the right-side intersection. See E_351.
E_357 Internal inconsistency error. Location: 'funct_c.c; subroutine: draw_circ'. Internal check for the bottom intersection. See E_351.
All warnings:
67
W_003 Could not open file name 'file' for writing. Location: 'funct_a.c'. The file name is related to the pseudocode output data. It means that the file *.prg already exists, and is write-protected, or in access (reserved) by another program.
W_012 Memory allocation failed, data is safe. Location: 'funct_a.c'. The pseudocode size parameter was too high. The system cannot handle larger memory areas for pseudocode. The system automatically decides the maximum size, and adjusts itself to it. THIS IS NOT OPERATIONAL.
W_359 Clipped too small pieces. Location: 'funct_c.c'. The clipped circle contained too few parts. This relates to an internal error. The program is allowed to continue, but the integrity of the circle is destroyed. Could result in ruin to the whole stripe (max. one for one error).
W_291 Rectangle violated a sub-window - was removed. Location: 'funct_2.c'. The rectangle was placed outside or on the boundary of a sub-window. All rectnagles must be drawn into the inside of a sub-window. This warning is displayed max. 10 times, but all misplaced rectangles are always removed.
W_293 Polygon violated a sub-window - was removed. Location: 'funct_2.c'. The polygon was placed outside or on the boundary of a sub-window. All polygons must be drawn into the inside of a sub-window. This warning is displayed max. 10 times, but all misplaced polygons are always removed.
68
Appendix B: Format Specifications from Micronic
Spc GenPatt, a program for on-line generation of dot patterns, Ver f
By: Anders Thurén & MK Date:93.04.21
1 Parameter description file
[] indicates one or more elements of the specified type. {} indicates zero or more elements of the specified type. Bold type indicates keywords. / indicates alternatives.
File:= EXTR ProgramName VersionCode MaskpartID Unit DataIncrement Window [ Area ] EOF
EXTR := A keyword.
ProgramName := A text string of a maximum of 80 characters.
VersionCode := Maximum eight ASCII characters.
MaskpartID := Text string 19 bytes total length. This is essentially a job name that shall be passed through to the output file.
Unit Input data unit in um.
DataIncrement:= The raster increment in um 0.5 for the LRS18 and 1 for the LRS55.
Window:= CF/DF X Y
Area:= Subwindow Array
Subwindow:= CF/DF Xs0 Ys0 Xs1 Ys1
Array:= A Xa0 Ya0 Xd Yd Xil Xih Yil Yih { Structure }
Structure=: REC Xsexpr ; Ysexpr ; Xexpr ; Yexpr ; angexpr ;
POL [ coord ] Xexpr ; Yexpr ; angexpr ;
CIR Xexpr ; Yexpr ; Rexpr ;
69
File Note that the delimiter used is one or more space characters.
EXTR The keyword EXTR must be the first four characters in the file. Note that nothing must precede this keyword in a file.
EOF The keyword EOF must be used to mark the end-of-file. The ASCII file itself does not have to end, but no text after EOF shall be interpreted by the program.
ProgramName is the name of the program that shall be started to interpret this file. In the case of GenPatt this string will normally be "/usr/bin/genpatt".
VersionCode is a six character ASCII code defining the file format. The code for the first version is "A00.00". This code must be checked by the program before the file is used.
Window is the size of the window limiting the dot pattern areas defined in this file.
Subwindow One window shall contain one or more subwindows. Subwindows are not allowed to overlap as they might have different CF/DF values. This is the first item that may be separated into its own line. Everything until the subwindow must be placed into only one input line.
CF/DF is clear field or dark field. "Clear field" is black objects on a transparent background (FIELD). Positive resist is assumed which means that "Dark field" means exposed objects on a not exposed background. This flag will affect a Boolean flag in the out data format that selects the pattern polarity. If you want the laser to paint (expose) the area (the FIELD) you described, then use CF. With DF the area is left intact, and the arrayed objects will be exposed by the laser.
Xs0, Ys0, Xs1, Ys1 are positions and dimensions of the subwindow. Xs0 and Ys0 are the coordinates for the origin of the subwindow. Xs1 and Ys1 are the height and width (respectively) of the subwindow.
Array One sub-window shall contain one array. Note that one array element may contain zero,
70
one or several Structure elements. The Structure elements are not allowed to overlap.
Xa0, Ya0 Array origin in sub-window.
Xd, Yd Step values for the array coordinates Xa and Ya.
Xil, Xih Lower and upper limit for the index. X will step from Xs0+Xa0+Xil*Xd to Xs0+Xa0+Xih*Xd.
Yil, Yih Lower and upper limit for the index. Y will step from Ya0+Ya0+Yil*Yd to Ys0+Ya0+Yih*Yd.
Xexpr, Yexpr Expression for placement of the structure. The expression must be monotonous in the sub-window interval.
angexpr Expression for rotation max. ±pi (,which is 3.141592653... the angles are in radian; if you wish to use degrees, apply the DRAD function). The rotation with a RECtangle is executed around its center of mass and with a POLygon it is executed around the local origin (i.e. Xexpr and Yexpr).
Structures RECtangles, POLygons and CIRcles are allowed. Note that these are the only ones requiring a space and a semicolon delimiter after their numerical expressions. Structures are allowed to overlap. In POLygons counter-clockwise rotation of the coordinates is absolutely required. The last coordinates, (which are of course the same as the very first ones) are left out.
Xexpr, Yexpr Expression specifying the placement of the object.
Xsexpr, Ysexpr Expression for side length of the object.
coord Coordinate pair Xkexpr; Ykexpr;. Each is an expression specifying a polygon corner. The polygon description may contain one or several corner coordinates. If two polygon sides run along the same vector, the zero-width area between the line is suppressed. The end-point coordinates, which will be the same as the starting coordinates, must be left out. The program will join the first and the last points automatically to form a closed region.
71
The user must take care that no folded surfaces like butterflies are formed.
Rexpr Expression for peripheral radius.
Expression is a general expression F(X,Y). X,Y are all possible node coordinate pairs generated from Xd,Yd in the interval Xil*Xd,Yil*Yd to Xih*Xd,Yih*Yd. The node coordinates X and Y represent a virtual node point. These points are where the structures will be placed if the placement expressions are Xexpr= X and Yexpr=Y.
The expression is a string with any number of elements separated by spaces and ending with a semicolon. The syntax is reversed Polish notation. Allowed symbols are the variable names "X" and "Y", some functions available in the MC68881 instruction set, and numeric constants.
The functions operate against an implicit stack. Parameters are fetched from the top of the stack in order. Function results are pushed onto the stack. The stack pointer is always adjusted automatically.
Symbols In the table below, the first column is the keyword. The second is the corresponding MC68881 function and an explanation when this is not self evident. The MC68881 function name is normally the name in column 1 preceded by the letter F.
" Comment start and
comment end character.
! Comment until end of line.
Constant name NOT ALLOWED IN THE FIRST VERSION OF THE PROGRAM.
0…9, ., E Used in numerical constants. Examples: 5 45.899 0.568E45
X and Y The placement variable generated from Xa0,Ya0 Xd,Yd Xil,Yil Xih,Yih (i.e. in global coordinates
72
X=Xs0+Xa0+Xd*(Xil..Xih) and Y=Ys0+Ya0+Yd*(Yil..Yih). That means when having the origin in Xa0,Ya0 in a subwindow, then X=Xd*(Xil to Xih) ).
* FMUL normal precision multiplication.
+ FADD
- FSUB
/ FDI, normal precision division.
2TOX FTWOTOX, 2X
10TOX FTENTOX, 10X
XTOY In hardware XY does not exist; automatically implemented by software using eY*ln(X) .
XROOTY In hardware taking the root X from Y does not exist.; automatically implemented by software e.g. using e(1/X)*ln(Y) .
ABS Absolute value.
ACOS Operand range [-1..+1]; returns the result in range
[-pi/2..+pi/2].
ASIN Operand range [-1..+1]; returns the result in range
[-pi/2..+pi/2].
ATAN Function returns the principal branch:
(-pi/2..+pi/2).
COS
ETOX eX
ETOXM1 eX-1
LOG2 2log X
LOG10 10log X
LOGN elog X
LOGNP1 elog (X+1). Should produce accurate numbers also when X is close to -1.
73
MOD Modulo, e.g. A B MOD means A-floor(A/B)*B.
MUL FSGLMUL, single precision multiplication.
NEG -X
REM IEEE Remainder. Resembles MOD, but the resulting signs differ.
SCALE Scale exponent, the source operand is chopped to an integer value before performing the operation X*(2Y) , i.e. add the number at the top of the stack to the exponent of the next number in the stack. This function will be efficient when needing fast multiplication with 2,4,8, etc.
FLOOR Rounds the operand down to an integer.
SIN
SINCOS Simultaneous SIN and COS (Saves time)
SQRT Square Root
TAN
DRAD Used for converting angles from degrees to radian.
RDEG Used for converting angles from radian to degrees.
GRAD Used for converting angles from gradian to radian. NOT AVAILABLE IN THE FIRST VERSION OF THE PROGRAM.
Hyperbolic functions: Implementation is not necessary in the first program version. ATANH COSH SINH TANH
Functions not used in the expressions but available in MC68881: FBcc FCOMP FDB FINT FINTRZ FMOVE FMOVECR FMOVEM FNOP FScc FTRAPcc FTEST FSGLDIV FGETEXP FGETMAN FRESTORE FSAVE .
74
Expression example The square root of (1+(A*Y2+B*Y 4) / C) when A= 1.11, B= 22.2*102 and C= 333 will be entered as:
1 1.11 Y Y * * 22.2E2 Y Y Y Y * * * * 333 / + SQRT ; Note the semi-colon at the end. The expression is allowed to run over several lines.
Comments
File is in ASCII
The main idea is to be able to use the ASCII file to describe a lattice point matrix, where the patterns (e.g. rectangles) land on a lattice point with a small deviation from the lattice point center. All patterns must lie inside their neighbouring 3 by 3 matrix (i.e. one left, one right, one up, one down). The ASCII file must have this restriction to overcome the problem of definiteness when computing the patterns. If you think about a rectangle that has its center just barely in one of the Window corners, and furthermore extends over several scanstripes and matrix points, computing the coordinates and doing the windowing is a tremendous job - at least when sometime in the future logical operations with the patterns will become possible.
75
2 Output data format The pattern data is stored in the same format as a mask part. In normal operation, the system writes one mask part at a time. All data generated by genpatt from one pattern description file is formatted as a single maskpart.
(The difference between GenPatt and the normal write operation is that normally data is read from the disk but in this case, data is generated in real time, one scanstripe at a time. Data is generated as long as there is space available in the dual port memory and the program waits when no space is available. )
Instead of generating data on-line we store the data in a file in PattFormII pattern data format,. All software should be made so it can be used in an on-line environment, only the output routine will be different.
Format parameters, see enclosed drawing.
[] indicates one or more elements of the specified type. {} indicates zero or more elements of the specified type. Bold type indicates keywords. / indicates alternatives.
THE EXACT OUTPUT DATA FORMAT IS SUPPRESSED!!!
3 Implementation. After init the program generates scanstripes in order from low Y to high Y coordinates. Output is fed through 4 subroutines:
InitMaskpart(pointer to header) Write header, init first scanstripe Write segment(pointer to segment) Write segment, write segment in x order. EndScanstripe() Scanstripe ready, write scanstripe length in Map. Init for next scanstripe EndMaskpart() End of data. Write Map, close file.
The names of the input and output files are taken from inputline. Output filename shall be of the form nnnn.st.
76
Appendix C: Listing of the Line-clipping Algorithm
A listing of the line-clipping algorithm GenPatt is included here, because all textbooks - which I found /10, 11, 12/ - had a bug in their algorithms. I found the bug by first implementing the algorithm in /10/ and using a program listing in /11/ to verify my code. Then, when testing the program with line-sweeps (corner-to-corner over the window) and random-draw (point-to-point, also outside the window) the internal checking warned about the returned coordinates. Sometimes the clipping took place by the wrong crossing-routine.
The original algorithms in the books are missing some extra checking, which insures that when two bits are set, the correct crossing-routine is chosen. If we have both TOP and RIGHT bits set, then the algorithm must not accept the clipping, which has one of the coordinates outside the boundary. The result depends on the processing order (in the algorithm) and on the line endpoints.
The algorithms in the textbooks clip both coordinate points with only one clipping routine. They swap the points, and run again. Anyway, in this sub-program we handle both points in separate dedicated parts. It was important for GenPatt to retain the order of the coordinates.
The routine is usable directly for a normal X-Y-coordinate system, because GenPatt itself has rotated the coordinates before calling this routine.
/* typedefs: */ /* the structure for clipping lines */ typedef struct { double x1,y1; /* the starting point */ /* Also the new clipped.. */ double x2,y2; /* the ending point */ /* ..coordinates are returned here. */ double left,bottom; /* the left, bottom limit */ double right,top; /* the right, top limit */ unsigned char which; /* indicates which one of the points was / clipped: 0=neither (but do accept), 1=first one, 2=second one, 3=both, / 4=discard line (out of window) */ } clip_struct; /* Module name: funct_b1.c / Purpose: Line clipping routine utilizing the Cohen & Sutherland algorithm. / The algorithm is from textbooks, but a bug is corrected. */ clip_struct *clip_line(cp) clip_struct *cp; { clip_struct c; double differ = 1e-11; /* the difference (subtraction) threshold tells / if the line was clipped outside the window; at the moment it would
77
/ be enough to use (512000 1/mm *600 mm*32*2)^-1, but let's / make sure by using 1e-11 (improvement factor of 5). / We assume here that the units */ unsigned char p1=0; /* RTLB 4 bits: RightTopLeftBottom; 1=true, 0=false */ unsigned char p2=0; /* RTLB 4 bits: RightTopLeftBottom; 1=true, 0=false */ double xtemp,ytemp; unsigned char right = 0x08; /* the boundary codes */ unsigned char top = 0x04; unsigned char left = 0x02; unsigned char bottom = 0x01; differ = differ/input_unit; /* normalize the differece */ c = *cp; /* copy data */ /* classify the region for point1 */ if (c.x1 < c.left) p1 |= left; else if (c.x1 > c.right) p1 |= right; if (c.y1 < c.bottom) p1 |= bottom; else if (c.y1 > c.top) p1 |= top; /* classify the region for point2 */ if (c.x2 < c.left) p2 |= left; else if (c.x2 > c.right) p2 |= right; if (c.y2 < c.bottom) p2 |= bottom; else if (c.y2 > c.top) p2 |= top; if (debug) printf("\nbits RTLB: p1=0x%.2x, p2=0x%.2x",p1,p2); /* if p1&p2!=0 then the line can be discarded directly; the points are / outside the window on the same boundary line */ if (p1 & p2) { (*cp).which = 4; return(cp); } /* can the line be accepted trivially (both inside the window) ? */ if ( !(p1 | p2) ) { (*cp).which = 0; return(cp); } c.which = 4; /* set the indicator bit for no clipping done */ /* Now we shall clip the lines with the regions; Right,Left,Top,Bottom */ /* first process p1 */ if (p1) /* if zero, clipping not required */ { /* now clip p1 */ if (p1 & right) /* RIGHT boundary for p1 */ { ytemp = c.y1 + ( c.right - c.x1 ) * ( c.y2 - c.y1 ) / ( c.x2 - c.x1 ); xtemp = c.right; if (debug) printf("\nright- x1, y1 = %.20lg, %.20lg",xtemp,ytemp); if ( (ytemp < differ+c.top) && (c.bottom-differ < ytemp) ) { /* was inside */ c.y1 = ytemp;
78
c.x1 = xtemp; c.which |= 1; if (debug) printf("\n..accepted"); /* goto outp1; */ } } if ( (!(c.which & 1)) && (p1 & left) ) /* LEFT boundary for p1 */ { ytemp = c.y1 + ( c.left - c.x1 ) * ( c.y2 - c.y1 ) / ( c.x2 - c.x1 ); xtemp = c.left; if (debug) printf("\nleft- x1, y1 = %.20lg, %.20lg",xtemp,ytemp); if ( (ytemp < differ+c.top) && (c.bottom-differ < ytemp) ) { c.y1 = ytemp; c.x1 = xtemp; c.which |= 1; if (debug) printf("\n..accepted"); /* goto outp1; */ } } if ( (!(c.which & 1)) && (p1 & top) ) /* TOP boundary for p1 */ { xtemp = c.x1 + ( c.top - c.y1 ) * ( c.x2 - c.x1 ) / ( c.y2 - c.y1 ); ytemp = c.top; if (debug) printf("\ntop- x1, y1 = %.20lg, %.20lg",xtemp,ytemp); if ( (xtemp < differ+c.right) && (c.left-differ < xtemp) ) { c.x1 = xtemp; c.y1 = ytemp; c.which |= 1; if (debug) printf("\n..accepted"); /* goto outp1; */ } } if ( (!(c.which & 1)) && (p1 & bottom) ) /* BOTTOM boundary for p1 */ { xtemp = c.x1 + ( c.bottom - c.y1 ) * ( c.x2 - c.x1 ) / ( c.y2 - c.y1 ); ytemp = c.bottom; if (debug) printf("\nbottom- x1, y1 = %.20lg, %.20lg",xtemp,ytemp); if ( (xtemp < differ+c.right) && (c.left-differ < xtemp) ) { c.x1 = xtemp; c.y1 = ytemp; c.which |= 1; if (debug) printf("\n..accepted"); } } if (debug) printf("\nx1,y1 coordinates clipped"); } /* end: if (p1) */ outp1: if (p2) /* if zero, clipping not required */
79
{ /* clipping p2 */ /* Now clipping p2 */ if (p2 & right) /* RIGHT for p2 */ { ytemp = c.y2 + ( c.right - c.x2 ) * ( c.y2 - c.y1 ) / ( c.x2 - c.x1 ); xtemp = c.right; if (debug) printf("\nright- x2, y2 = %.20lg, %.20lg",xtemp,ytemp); /* printf("\nytemp,c.top,differ,c.bottom = %lg %lg %lg %lg", ytemp,c.top,differ,c.bottom); */ if ( (ytemp < differ+c.top) && (c.bottom-differ < ytemp) ) { c.y2 = ytemp; c.x2 = xtemp; c.which |= 2; if (debug) printf("\n..accepted"); /* goto outp2; */ } } if ( (!(c.which & 2)) && (p2 & left) ) /* LEFT for p2 */ { ytemp = c.y2 + ( c.left - c.x2 ) * ( c.y2 - c.y1 ) / ( c.x2 - c.x1 ); xtemp = c.left; if (debug) printf("\nleft- x2, y2 = %.20lg, %.20lg",xtemp,ytemp); if ( (ytemp < differ+c.top) && (c.bottom-differ < ytemp) ) { c.y2 = ytemp; c.x2 = xtemp; c.which |= 2; if (debug) printf("\n..accepted"); /* goto outp2; */ } } if ( (!(c.which & 2)) && (p2 & top) ) /* TOP for p2 */ { xtemp = c.x2 + ( c.top - c.y2 ) * ( c.x2 - c.x1 ) / ( c.y2 - c.y1 ); ytemp = c.top; if (debug) printf("\ntop- x2, y2 = %.20lg, %.20lg",xtemp,ytemp); if ( (xtemp < differ+c.right) && (c.left-differ < xtemp) ) { c.x2 = xtemp; c.y2 = ytemp; c.which |= 2; if (debug) printf("\n..accepted"); /* goto outp2; */ } } if ( (!(c.which & 2)) && (p2 & bottom) ) /* BOTTOM for p2 */ { xtemp = c.x2 + ( c.bottom - c.y2 ) * ( c.x2 - c.x1 ) / ( c.y2 - c.y1 );
80
ytemp = c.bottom; if (debug) printf("\nbottom- x2, y2 = %.20lg, %.20lg",xtemp,ytemp); if ( (xtemp < differ+c.right) && (c.left-differ < xtemp) ) { c.x2 = xtemp; c.y2 = ytemp; c.which |= 2; if (debug) printf("\n..accepted"); } } if (debug) printf("\nx2,y2 coordinates clipped"); } /* end: if (p2) */ outp2: if (c.which != 4) c.which &= 3; /* remove the indicator bit */ return(&c); /* return the pointer to the structure with clipped coords */ }
81
Appendix D: Contents of Sub-Modules
genpatt.c (main program)
a) contains #include section.
b) contains one #define.
c) contains struct's and typedef struct's (definitions for data-structures: header, map, output primitives, clipline, pseudocode).
d) introduction of functions (not the actual functions, but only the calling convention).
e) global constants and global variables (here are also the parameters for the block size, allowed memory allocation, etc.)
f) main()
g) fundamental allocation
h) extraction of the parent process parameters: filename, trace, debug
funct_1.c
a) contains the introduction of pseudocode index functions (e.g. unsigned char func_12(); /* circle drawing-command *7)
b) contains one #define statement - the last index function number not yet in use.
funct_2.c
a) contains the functions for processing all commands and functions (e.g. REC, SIN, etc.).
funct_3.c
a) initializes the comparison strings of all commands and functions.
funct_4.c
a) initializes the calling pointers of all commands and functions.
funct_a.c
Basically handles the input file and its conversion to pseudocode.
82
a) allocates memory for the pseudocode until it all fits into the allocated part, or until the allowed (parameter) maximum is reached. This allocated area is not freed, but utilized later.
funct_b.c
a) creates the header and writes it out
b) creates the segments for window (not sub-window) CF/DF, also computes all the block coordinates.
c) contains the stack push and pull routines
d) contains the pseudocode reading routine (reads from disk) with the possibility to put one item back into the input stream. Also contains the pseudocode swapping routine (is a sub-routine of the reading routine).
e) contains the FIFO loading and reading routines along with the allocations routine.
funct_b1.c
The line clipping routine. It clips in the normal X-Y coordinates, so the calling routine must do some coordinate swapping before delivering the arguments to this routine (when used from GenPatt).
funct_b2.c
The routine for rotating coordinates. No coordinate swapping is required because of the rotational symmetry of both GenPatt coordinates and normal coordinates.
funct_c.c
a) contains the routines for processing and drawing of line segments and arc segments (circles).
b) contains the routines for finding the intersections between a block and a circle.
c) contains the routines for allocating, indexing, sorting, and deleting the output primitives.
d) contains the routines to write out the processed blocks.
83
Appendix E: Examples of Program Essentials
E.1 Pseudocode
First a small example in C to explain the use of pointer arrays:
#include <stdio.h> int pr1(); /* define the prototypes (calling convention) */ int pr2(); int pr3(); /* main BEGIN */ main(argc,argv) /* MAIN begins */ int argc; char *argv[]; { int (*test[3])(); /* define a pointer array */ int b; test[0] = pr1; /* copy the function pointer values into the pointer array */ test[1] = pr2; test[2] = pr3; (*test[0])(10); /* call the functions by using the pointer array */ (*test[1])(20); (*test[2])(30); } /* main END */ int pr1(a) /* the first function */ int a; { printf("\nFunction pr1 and %d",a); return 1; } /* print message 1 */ int pr2(a) /* the second function */ int a; { printf("\nFunction pr2 and %d",a); return 2; } /* print message 2 */ int pr3(a) /* the third function */ int a; { printf("\nFunction pr3 and %d",a); return 3; } /* print message 3 */ /* END */
The output of the example program is:
Function pr1 and 10 Function pr2 and 20 Function pr3 and 30
The actual format structure of the pseudocode used in GenPatt is:
typedef struct { unsigned char action;
84
short int storage; double fvalue; } pseudo;
And the pseudocode structure explanation follows:
Because some compilers reject the increment (and decrement) of a structure type pointer, we will use the following type pseudocode. unsigned char action[]; consumes 1 byte short int storage[]; consumes 2 bytes double fvalue[]; consumes 8 bytes 'action' always determines the action to be carried out. The possible values so far are: 0:drawing command, 1:function, 2:numerical constant, 3:numerical value(double type). When 'action' is 0,1 or 2, then 'storage' is an index to an array table (1-dimensional), . With 'action' value 3 this 'storage' has no relevance. When 'action' really is 3, then 'fvalue' contains a numerical double-precision floating point value; with other 'action' values 'fvalue' has no relevance.
E.2 Functions
Then two examples of the structure of functions in GenPatt:
Example 1: Divide: '/'
unsigned char func_18() /* divide operation FDIV */ { pseudo data; unsigned char sstatus; double ddata1,ddata2; if (debug) printf("\nperforming: FDIV (function)"); ddata1 = pcode_to_numeric(stk_get()); ddata2 = pcode_to_numeric(stk_get()); if (ddata1==0.0) { printf("\nERROR: divide by zero error! (E_204)\nTerminating."); exit(3); } data.fvalue = ddata2/ddata1; data.action = 3; sstatus = stk_put(&data); if (sstatus) { printf("\nERROR: stack divide error! (E_205)\nTerminating."); exit(3); } return(0); }
Example 2: Take 'SIN'
85
unsigned char func_43() /* take sin */ { pseudo data; unsigned char sstatus; double ddata1,ddata2; if (debug) printf("\nperforming: SIN (function)"); ddata1 = pcode_to_numeric(stk_get()); data.fvalue = sin(ddata1); data.action = 3; sstatus = stk_put(&data); if (sstatus) { printf("\nERROR: stack SIN error! (E_245)\nTerminating."); exit(3); } return(0); }
E.3 Stack (LIFO)
An example of stack get:
/* routine gets a pseudocode item from the stack (the greatest index) */ pseudo *stk_get() { pseudo stk_val; stk_indx--; if (stk_indx < 0) { printf("\nERROR: stack index negative out of range. (E_101)\nTerminating."); exit(2); } stk_val = stk[stk_indx]; if (debug) printf("\nGetting data from stack %u %d %.20lf stk_indx=%d", stk_val.action, stk_val.storage, stk_val.fvalue, stk_indx); return (&stk_val); }
86
Appendix F: Using the Module
F.1 Advanced Input Format
Commands (REC, POL, CIR, CF, DF, A) and functions (SIN, +, SQRT, etc.) have to be written in CAPITAL LETTERS, and delimited with white-space characters. Also the comment character requires one delimiter (not on both sides, only one to separate it from the neighboring command).
You may always divide a long line of characters into several lines. All characters separating commands, functions, and numerics must be white-space characters. There must be at least one separating character between any operands. These are all ASCII values from 0 to 32 in decimal units (include decimal values: CR=13, LF=10, space=32, tabulator=9, etc.) /13, p.315/,/14, p.334/. Here is an example of a polygon with the input line divided into several lines:
POL 10 ; 20 ; 20 ; 30 ; 40 ; -10 ; 0 ; -20 ; -10 ; 10 ; 1000 ; 2000 ; 70 DRAD ;
The text can be written on one or several lines. If the line wraps, but it does not matter.
A pair of coordinates of a polygon is not expressed twice in a row. GenPatt knows that the ending coordinates are the same as the beginning coordinates.
The input file must absolutely end with the command EOF.
When writing numerical input values, several formats can be chosen: 1, 1.0, 1.00, 1e0, 0.1e1, .1E1, 10E-1, etc. All values are converted to double precision, floating point numbers by the input routine of GenPatt.
It is allowed to draw any rectangles, polygons and circles directly with numerical arguments (with a dymmy array). This option uses global coordinates, i.e. the window coordinates, and must be applied extremely carefully. It is a good custom to avoid these separate global objects, because they consume a lot of processing resources. In-line computations of the arguments are allowed. Here is an example of a rotated rectangle drawn to position X=1000, Y=2000:
A 1 1 1 1 1 1 1 1 !dummy array (anywhere before the direct draw) .. REC 10 ; 20 ; 1000 ; 2000 ; 23 SQRT DRAD ; !the direct draw
The argument angles in drawing-commands may exceed 2*pi radian. The maximum depends on the C compiler used. Normally trigonometric functions in C accept arguments with several 2*pi multiplies. If a run-time error message is returned by the operating system - not GenPatt - then MOD must be used with 2*pi.
F.2 Sample Input Files
87
The following input file makes one rectangle, rotated by 45 degrees, at the global coordinates X=10+600-100=510, Y=100+500-0=600:
EXTR /usr/u/run/mika/genpatt A00.00 patt1 1 1 DF 2000 4000.1 "Here we have one rotated rectangle; rotation is 45 degrees" DF 10 100 1900 3800 !This is a comment!!! - to the end of the line... A 600 500 100 99 -1 -1 0 0 REC 150 ; 200 ; X ; Y ; 45 DRAD ; EOF
The same output is achieved with:
EXTR /usr/u/run/mika/genpatt A00.00 patt1 1 1 DF 2000 4000.1 "Here we have one rotated rectangle; rotation is 45 degrees" DF 10 100 1900 3800 !This is a comment!!! - to the end of the line... A 1 1 1 1 0 0 0 0 "Dummy arraying must be done. It is not necessary to fit it into the inside of the sub-window area." REC 150 ; 200 ; 500 ; 500 ; 45 DRAD ; EOF
Now let us create an array of rectangles, polygons, and circles.
EXTR /usr/u/run/mika/genpatt A00.00 patt1 1 1 DF 60000 5000 "Here we have rotated polygons and rectangles. We also have circles with a growing radius" ! The program name: ascii401 !The specifications for the sub-window: DF 0 0 59900 4900 !first the origin, then the sizes ; x y ! The polygons: A 1090 1150 105 150 -6 80 -5 23 POL 10 20 ; -10 10 ; -10 -15 ; 10 -20 ; 20 0 ; X ; Y ; X Y + 1000 / DRAD ; ! The rectangles: A 21090 1150 105 150 -6 80 -5 23 REC 20 ; 50 ; X 20 + ; Y ; X Y + 1000 / DRAD ; ! And the circles: A 31090 1150 105 150 0 80 0 23 CIR X ; Y ; X Y + 350 / 10 + ; EOF
F.3 Common Mistakes
a) A delimiter (white-space character) is missing between two operands.
b) A command is missing one or several arguments.
88
c) A command has extra arguments.
d) A syntax error.
e) In 1-dimensional arraying both the delta-coordinates must be greater than zero, eventhough only one coordinate is arrayed. The indices may run from negative to positive.
f) Combining several structures into one array only. It is possible to do this, but the objects must be very close to the same array points. The reason is, that a specific block sees only one pair of rows and columns from the outside of that block. Therefore an object must not be moved too far from the array point, e.g. this example will fail in the second REC, and only the first drawing-command produces objects:
... A 1000 2000 100 50 -10 10 -10 10 REC 5 ; 5 ; X ; Y ; 0 ; REC 5 ; 5 ; X ; Y 65 + ; 0 ; ...
It is recommended that only one array is cast on one drawing-command. The previous example becomes more correct here:
... A 1000 2000 100 50 -10 10 -10 10 REC 5 ; 5 ; X ; Y ; 0 ; A 1000 2060 100 50 -10 10 -10 10 REC 5 ; 5 ; X ; Y 5 + ; 0 ; ...
The safest alternative of the example:
... A 1000 2000 100 50 -10 10 -10 10 REC 5 ; 5 ; X ; Y ; 0 ; A 1000 2065 100 50 -10 10 -10 10 REC 5 ; 5 ; X ; Y ; 0 ; ...
Using computations in object positioning is fine, but care must be taken to avoid errors.
F.4 Debugging
GenPatt must always be compiled at least with the following options:
cc genpatt.c -o genpatt -lm
where '-lm' stands for linking of the mathematics library.
If the errors in the ASCII input file are puzzling, the locations could be found by using the undocumented command line options for running GenPatt: trace (or TRACE with capitals) and debug (or DEBUG with capitals).
genpatt test00 debug
89
When the program gets either of the two options, it will print out current progress information. The first one, trace, outputs less information than the second one, debug. It is possible to redirect the printing to a file or to a printer with normal UNIX methods, e.g.
genpatt test01 trace >testrun
or to a printer:
genpatt test02 debug | lpr
GenPatt always generates the output binary data file with an extension *.st, and one pseudocode binary swap file with an extension *.prg. Both are retained after finishing the execution.
90
Appendix G: Input - the Module Test
EXTR /usr/u/run/Mika/genpatt A00.00 patt1 1 1 DF 20000 3000 ! Program name: ascii800 !First DF: DF 9000 0 1610 2100 !Specify the sub-window A 100 512 9999 512 0 0 0 2 !array for coordinating rectangles ! 9999 is used for delta_x. The value must great enough to ! simulate the block width. !First the six arrayed coordinating rectangles (rotated by 45 degrees): REC 50 ; 50 ; X ; Y 35.36 - ; 45 DRAD ; ! 50/2*SQRT(2)=35.35 REC 50 ; 50 ; X ; Y 35.36 + ; 45 DRAD ; !The five variably rotated rectangles A 500 1024 9999 256 0 0 -2 2 REC 100 ; 200 ; X ; Y ; Y 10.24 / DRAD ; !max rot= 512/10.24= -50 to 50 degrees "The five variably rotated polygons. The same array points are used for all polygons. It can carefyully be done, see the text. " A 1000 1024 9999 256 0 0 -2 2 !The surrounding border POL 40 ; -60 ; -40 ; -60 ; -40 ; 60 ; 40 ; 60 ; 40 ; -70 ; 50 ; -70 ; 50 ; 70 ; -50 ; 70 ; -50 ; -70 ; 40 ; -70 ; X ; Y ; Y 4.096 / DRAD ; !max. rot= 512/4.096= -125 to 125 degrees !The letter M POL 30 ; -40 ; -10 ; -40 ; 0 ; -30 ; -10 ; -20 ; 30 ; -20 ; 30 ; -10 ; -30 ; -10 ; -10 ; -30 ; -30 ; -50 ; 30 ; -50 ; X ; Y ; Y 4.096 / DRAD ; !The letter K POL 30 ; 20 ; 0 ; 20 ; 30 ; 40 ; 30 ; 50 ; 0 ; 30 ; -30 ; 50 ; -30 ; 40 ; 0 ; 20 ; -30 ; 20 ; -30 ; 10 ; 30 ; 10 ; X ; Y ; Y 4.096 / DRAD ; !The five unevenly spaced circles with varying radius A 1500 1024 9999 256 0 0 -2 2 CIR X ; Y Y 25.6 / + ; 80 Y 10.24 / + ; !When Y is negative the radius diminishes. ! delta_Y= 512/25.6= -20 to 20 um ; radius= 30 to 120 um !---------------- !Now CF:
91
CF 11000 0 1610 2100 !Specify the sub-window A 100 512 9999 512 0 0 0 2 !array for coordinating rectangles !First the six arrayed coordinating rectangles (rotated by 45 degrees): REC 50 ; 50 ; X ; Y 35.36 - ; 45 DRAD ; ! 50/2*SQRT(2)=35.35 REC 50 ; 50 ; X ; Y 35.36 + ; 45 DRAD ; !The five variably rotated rectangles A 500 1024 9999 256 0 0 -2 2 REC 100 ; 200 ; X ; Y ; Y 10.24 / DRAD ; !max rot= 512/10.24= -50 to 50 degrees "The five variably rotated polygons. The same array points are used for all polygons. It can carefyully be done, see the text. " A 1000 1024 9999 256 0 0 -2 2 !The surrounding border POL 40 ; -60 ; -40 ; -60 ; -40 ; 60 ; 40 ; 60 ; 40 ; -70 ; 50 ; -70 ; 50 ; 70 ; -50 ; 70 ; -50 ; -70 ; 40 ; -70 ; X ; Y ; Y 4.096 / DRAD ; !max. rot= 512/4.096= -125 to 125 degrees !The letter M POL 30 ; -40 ; -10 ; -40 ; 0 ; -30 ; -10 ; -20 ; 30 ; -20 ; 30 ; -10 ; -30 ; -10 ; -10 ; -30 ; -30 ; -50 ; 30 ; -50 ; X ; Y ; Y 4.096 / DRAD ; !The letter K POL 30 ; 20 ; 0 ; 20 ; 30 ; 40 ; 30 ; 50 ; 0 ; 30 ; -30 ; 50 ; -30 ; 40 ; 0 ; 20 ; -30 ; 20 ; -30 ; 10 ; 30 ; 10 ; X ; Y ; Y 4.096 / DRAD ; !The five unevenly spaced circles with varying radius A 1500 1024 9999 256 0 0 -2 2 CIR X ; Y Y 25.6 / + ; 80 Y 10.24 / + ; !When Y is negative the radius diminishes. ! delta_Y= 512/25.6= -20 to 20 um ; radius= 30 to 120 um EOF
92
Appendix H: Input - the Combination Array
EXTR /usr/u/run/Mika/genpatt A00.00 patt1 1 1 DF 23000 47000 ! Program name: ascii770 DF 0 0 22000 22000 !first the origin, then the sizes ; x y A 1000 1000 200 200 0 50 0 50 POL 20 ; 30 ; -20 ; 0 ; 20 ; -20 ; X ; Y ; X Y + 10 / DRAD ; A 1000 1100 200 200 0 50 0 50 CIR X ; Y ; 10 ; A 1100 1050 200 200 0 50 0 50 REC 20 ; 40 ; X ; Y ; X Y + 10 / DRAD ; !------------------ CF 0 24000 22000 22000 !first the origin, then the sizes ; x y A 1000 1000 200 200 0 50 0 50 POL 20 ; 30 ; -20 ; 0 ; 20 ; -20 ; X ; Y ; X Y + 10 / DRAD ; A 1000 1100 200 200 0 50 0 50 CIR X ; Y ; 10 ; A 1100 1050 200 200 0 50 0 50 REC 20 ; 40 ; X ; Y ; X Y + 10 / DRAD ; EOF
93
Appendix I: Input - the Single Pattern Arrays
EXTR /usr/u/run/Mika/genpatt A00.00 patt1 1 1 DF 23000 47000 ! Program name: ascii660 DF 0 0 22000 22000 !first the origin, then the sizes ; x y A 1000 1000 50 50 0 100 0 100 CIR X ; Y ; 10 ; A 7000 1000 50 50 0 100 0 100 POL 20 ; 30 ; -20 ; 0 ; 20 ; -30 ; X ; Y ; X Y + 10 / DRAD ; A 13000 1000 50 50 0 100 0 100 REC 30 ; 60 ; X ; Y ; X Y + 10 / DRAD ; !------------------ CF 0 24000 22000 22000 !first the origin, then the sizes ; x y A 1000 1000 50 50 0 100 0 100 CIR X ; Y ; 10 ; A 7000 1000 50 50 0 100 0 100 POL 20 ; 30 ; -20 ; 0 ; 20 ; -30 ; X ; Y ; X Y + 10 / DRAD ; A 13000 1000 50 50 0 100 0 100 REC 30 ; 60 ; X ; Y ; X Y + 10 / DRAD ; EOF
94
Appendix J: Bibliography
McGinnis, K. C. - editor; 11th Annual Symposium on Photomask Technology - SPIE Volume 1604; U.S.A.; 1992; The Society of Photo-Optical Instrumentation Engineers; 348 p.; ISBN 0-8194-0733-X
Lindfors, M. & Sjuls, D.; Masktillverkning med laserteknik - Ingenjörsarbete; Finland; 1993; Tekniska Läroverket; 74 p.
Binnig, G. & Rohrer, H.; October 1989; The Scanning Tunneling Microscope; Scientific American; pp. 74-81.
Robinson, G. M. & Perry, D. M. & Peterson, R. W.; October 1991; Optical Interferometry of Surfaces; Scientific American; pp. 44-49.
Buggraaf, P.; November 1989; Watch Reticle Processing Evolve; Semiconductor International; pp. 72-78.
Gottfried, B. S.; Programming with C - Shaum's Outline Series; U.S.A.; 1990; McGraw-Hill; 531 p.; ISBN 0-07-023854-5
Swenson, J. S. - editor; Laser Processing of Semiconductors and Hybrids - SPIE Volume 611; U.S.A.; 1986; The Society of Photo-Optical Instrumentation Engineers; 101 p.; ISBN 0-89252-646-7
Stone, H. S.; High-Performance Computer Architecture; 2nd ed.; U.S.A.; 1990; Addison-Wesley;
95
List of References
/1/ Photomask Brochure; USA/Japan; 1992; Introduction to Mask Blanks; Hoya Corp.
/2/ Buggraaf, P.; December 1987; Photomask and Reticle Blanks; Semiconductor International; pp. 38-42.
/3/ Sze, S.M.; Semiconductor Devices - Physics and Technology; Singapore; 1985; John Wiley & Sons; 523 p.
/4a/ Buggraaf, P.; May 1988; Laser-based Pattern Generation; Semiconductor International; pp. 116-121.
/4b/ Lasarray Brochure; 10 / 1991; Heidelberg Instruments Mikrotechnik GmbH; 8 p.
/5/ Newboe, B.; August 1991; Optical Microscopes - Still a Good Choice for Inspection; Semiconductor International; pp. 48-51.
/6/ Buggraaf, P.; August 1988; The Skills Behind 'Perfect' Masks; Semiconductor International; pp. 76-80.
/7/ LRS-55 Service manual; Sweden; 1992; Micronic Laser Systems Ab
/8/ LRS-55 Write system; Sweden; 1992; Micronic Laser Systems Ab
/9/ Sedgewick, R.; Algorithms; 2nd ed.; U.S.A.; 1988; Addison-Wesley; 650 p.; ISBN 0-201-06673-4
/10/ Donald, H. & Baker, M. P.; Computer Graphics; U.S.A.; 1986; Prentice-Hall; 352 p.; ISBN 0-13-165598-1
/11/ Ferraro, R. F.; Programmer's Guide to the EGA and VGA Cards; 2nd ed.; U.S.A.; 1990; Addison-Wesley; 1040 p.; ISBN 0-201-57025-4
/12/ Newman, W. M. & Sproull R. F.; Interactive Computer Graphics; 2nd ed.; Japan; 1979; McGraw-Hill Kogakusha Ltd.; 541 p.; ISBN 0-07-066455-2
/13/ Wiatrowski, C. A. & House, C. H.; Logic Circluits and Microcomputer Systems; Singapore export; 1984; McGraw-Hill; 413 p.; ISBN 0-07-Y66632-6
/14/ Bourne, S. R.; The UNIX System; U.S.A.; 1983; Bell Telephone Laboratories Inc.; 351 p.; ISBN 0-201-13791-7
/15/ Quinn, M. J.; Designing Efficient Algorithms for Parallel Computers; Singapore; 1987; McGraw-Hill Book Co.; 288 p.; ISBN 0-07-100249-9